kms

package
v1.62.273 Latest Latest
Warning

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

Go to latest
Published: Apr 7, 2023 License: Apache-2.0 Imports: 6 Imported by: 177

Documentation

Index

Constants

This section is empty.

Variables

View Source
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source
var EndpointType = "regional"

EndpointType regional or central

Functions

func GetEndpointMap

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types

type Alias

type Alias struct {
	AliasArn  string `json:"AliasArn" xml:"AliasArn"`
	AliasName string `json:"AliasName" xml:"AliasName"`
	KeyId     string `json:"KeyId" xml:"KeyId"`
}

Alias is a nested struct in kms response

type AliasesInListAliases

type AliasesInListAliases struct {
	Alias []Alias `json:"Alias" xml:"Alias"`
}

AliasesInListAliases is a nested struct in kms response

type AliasesInListAliasesByKeyId

type AliasesInListAliasesByKeyId struct {
	Alias []Alias `json:"Alias" xml:"Alias"`
}

AliasesInListAliasesByKeyId is a nested struct in kms response

type AsymmetricDecryptRequest added in v1.60.310

type AsymmetricDecryptRequest struct {
	*requests.RpcRequest
	KeyVersionId   string `position:"Query" name:"KeyVersionId"`
	KeyId          string `position:"Query" name:"KeyId"`
	CiphertextBlob string `position:"Query" name:"CiphertextBlob"`
	Algorithm      string `position:"Query" name:"Algorithm"`
}

AsymmetricDecryptRequest is the request struct for api AsymmetricDecrypt

func CreateAsymmetricDecryptRequest added in v1.60.310

func CreateAsymmetricDecryptRequest() (request *AsymmetricDecryptRequest)

CreateAsymmetricDecryptRequest creates a request to invoke AsymmetricDecrypt API

type AsymmetricDecryptResponse added in v1.60.310

type AsymmetricDecryptResponse struct {
	*responses.BaseResponse
	KeyVersionId string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId        string `json:"KeyId" xml:"KeyId"`
	RequestId    string `json:"RequestId" xml:"RequestId"`
	Plaintext    string `json:"Plaintext" xml:"Plaintext"`
}

AsymmetricDecryptResponse is the response struct for api AsymmetricDecrypt

func CreateAsymmetricDecryptResponse added in v1.60.310

func CreateAsymmetricDecryptResponse() (response *AsymmetricDecryptResponse)

CreateAsymmetricDecryptResponse creates a response to parse from AsymmetricDecrypt response

type AsymmetricEncryptRequest added in v1.60.310

type AsymmetricEncryptRequest struct {
	*requests.RpcRequest
	KeyVersionId string `position:"Query" name:"KeyVersionId"`
	KeyId        string `position:"Query" name:"KeyId"`
	Plaintext    string `position:"Query" name:"Plaintext"`
	Algorithm    string `position:"Query" name:"Algorithm"`
}

AsymmetricEncryptRequest is the request struct for api AsymmetricEncrypt

func CreateAsymmetricEncryptRequest added in v1.60.310

func CreateAsymmetricEncryptRequest() (request *AsymmetricEncryptRequest)

CreateAsymmetricEncryptRequest creates a request to invoke AsymmetricEncrypt API

type AsymmetricEncryptResponse added in v1.60.310

type AsymmetricEncryptResponse struct {
	*responses.BaseResponse
	KeyVersionId   string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId          string `json:"KeyId" xml:"KeyId"`
	CiphertextBlob string `json:"CiphertextBlob" xml:"CiphertextBlob"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
}

AsymmetricEncryptResponse is the response struct for api AsymmetricEncrypt

func CreateAsymmetricEncryptResponse added in v1.60.310

func CreateAsymmetricEncryptResponse() (response *AsymmetricEncryptResponse)

CreateAsymmetricEncryptResponse creates a response to parse from AsymmetricEncrypt response

type AsymmetricSignRequest added in v1.60.310

type AsymmetricSignRequest struct {
	*requests.RpcRequest
	KeyVersionId string `position:"Query" name:"KeyVersionId"`
	Digest       string `position:"Query" name:"Digest"`
	KeyId        string `position:"Query" name:"KeyId"`
	Algorithm    string `position:"Query" name:"Algorithm"`
}

AsymmetricSignRequest is the request struct for api AsymmetricSign

func CreateAsymmetricSignRequest added in v1.60.310

func CreateAsymmetricSignRequest() (request *AsymmetricSignRequest)

CreateAsymmetricSignRequest creates a request to invoke AsymmetricSign API

type AsymmetricSignResponse added in v1.60.310

type AsymmetricSignResponse struct {
	*responses.BaseResponse
	KeyVersionId string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId        string `json:"KeyId" xml:"KeyId"`
	Value        string `json:"Value" xml:"Value"`
	RequestId    string `json:"RequestId" xml:"RequestId"`
}

AsymmetricSignResponse is the response struct for api AsymmetricSign

func CreateAsymmetricSignResponse added in v1.60.310

func CreateAsymmetricSignResponse() (response *AsymmetricSignResponse)

CreateAsymmetricSignResponse creates a response to parse from AsymmetricSign response

type AsymmetricVerifyRequest added in v1.60.310

type AsymmetricVerifyRequest struct {
	*requests.RpcRequest
	KeyVersionId string `position:"Query" name:"KeyVersionId"`
	Digest       string `position:"Query" name:"Digest"`
	KeyId        string `position:"Query" name:"KeyId"`
	Value        string `position:"Query" name:"Value"`
	Algorithm    string `position:"Query" name:"Algorithm"`
}

AsymmetricVerifyRequest is the request struct for api AsymmetricVerify

func CreateAsymmetricVerifyRequest added in v1.60.310

func CreateAsymmetricVerifyRequest() (request *AsymmetricVerifyRequest)

CreateAsymmetricVerifyRequest creates a request to invoke AsymmetricVerify API

type AsymmetricVerifyResponse added in v1.60.310

type AsymmetricVerifyResponse struct {
	*responses.BaseResponse
	KeyVersionId string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId        string `json:"KeyId" xml:"KeyId"`
	Value        bool   `json:"Value" xml:"Value"`
	RequestId    string `json:"RequestId" xml:"RequestId"`
}

AsymmetricVerifyResponse is the response struct for api AsymmetricVerify

func CreateAsymmetricVerifyResponse added in v1.60.310

func CreateAsymmetricVerifyResponse() (response *AsymmetricVerifyResponse)

CreateAsymmetricVerifyResponse creates a response to parse from AsymmetricVerify response

type CancelKeyDeletionRequest

type CancelKeyDeletionRequest struct {
	*requests.RpcRequest
	KeyId string `position:"Query" name:"KeyId"`
}

CancelKeyDeletionRequest is the request struct for api CancelKeyDeletion

func CreateCancelKeyDeletionRequest

func CreateCancelKeyDeletionRequest() (request *CancelKeyDeletionRequest)

CreateCancelKeyDeletionRequest creates a request to invoke CancelKeyDeletion API

type CancelKeyDeletionResponse

type CancelKeyDeletionResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

CancelKeyDeletionResponse is the response struct for api CancelKeyDeletion

func CreateCancelKeyDeletionResponse

func CreateCancelKeyDeletionResponse() (response *CancelKeyDeletionResponse)

CreateCancelKeyDeletionResponse creates a response to parse from CancelKeyDeletion response

type CertificatePrivateKeyDecryptRequest added in v1.61.701

type CertificatePrivateKeyDecryptRequest struct {
	*requests.RpcRequest
	CertificateId  string `position:"Query" name:"CertificateId"`
	Algorithm      string `position:"Query" name:"Algorithm"`
	CiphertextBlob string `position:"Query" name:"CiphertextBlob"`
}

CertificatePrivateKeyDecryptRequest is the request struct for api CertificatePrivateKeyDecrypt

func CreateCertificatePrivateKeyDecryptRequest added in v1.61.701

func CreateCertificatePrivateKeyDecryptRequest() (request *CertificatePrivateKeyDecryptRequest)

CreateCertificatePrivateKeyDecryptRequest creates a request to invoke CertificatePrivateKeyDecrypt API

type CertificatePrivateKeyDecryptResponse added in v1.61.701

type CertificatePrivateKeyDecryptResponse struct {
	*responses.BaseResponse
	RequestId     string `json:"RequestId" xml:"RequestId"`
	CertificateId string `json:"CertificateId" xml:"CertificateId"`
	Plaintext     string `json:"Plaintext" xml:"Plaintext"`
}

CertificatePrivateKeyDecryptResponse is the response struct for api CertificatePrivateKeyDecrypt

func CreateCertificatePrivateKeyDecryptResponse added in v1.61.701

func CreateCertificatePrivateKeyDecryptResponse() (response *CertificatePrivateKeyDecryptResponse)

CreateCertificatePrivateKeyDecryptResponse creates a response to parse from CertificatePrivateKeyDecrypt response

type CertificatePrivateKeySignRequest added in v1.61.701

type CertificatePrivateKeySignRequest struct {
	*requests.RpcRequest
	MessageType   string `position:"Query" name:"MessageType"`
	CertificateId string `position:"Query" name:"CertificateId"`
	Message       string `position:"Query" name:"Message"`
	Algorithm     string `position:"Query" name:"Algorithm"`
}

CertificatePrivateKeySignRequest is the request struct for api CertificatePrivateKeySign

func CreateCertificatePrivateKeySignRequest added in v1.61.701

func CreateCertificatePrivateKeySignRequest() (request *CertificatePrivateKeySignRequest)

CreateCertificatePrivateKeySignRequest creates a request to invoke CertificatePrivateKeySign API

type CertificatePrivateKeySignResponse added in v1.61.701

type CertificatePrivateKeySignResponse struct {
	*responses.BaseResponse
	SignatureValue string `json:"SignatureValue" xml:"SignatureValue"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
	CertificateId  string `json:"CertificateId" xml:"CertificateId"`
}

CertificatePrivateKeySignResponse is the response struct for api CertificatePrivateKeySign

func CreateCertificatePrivateKeySignResponse added in v1.61.701

func CreateCertificatePrivateKeySignResponse() (response *CertificatePrivateKeySignResponse)

CreateCertificatePrivateKeySignResponse creates a response to parse from CertificatePrivateKeySign response

type CertificatePublicKeyEncryptRequest added in v1.61.701

type CertificatePublicKeyEncryptRequest struct {
	*requests.RpcRequest
	CertificateId string `position:"Query" name:"CertificateId"`
	Plaintext     string `position:"Query" name:"Plaintext"`
	Algorithm     string `position:"Query" name:"Algorithm"`
}

CertificatePublicKeyEncryptRequest is the request struct for api CertificatePublicKeyEncrypt

func CreateCertificatePublicKeyEncryptRequest added in v1.61.701

func CreateCertificatePublicKeyEncryptRequest() (request *CertificatePublicKeyEncryptRequest)

CreateCertificatePublicKeyEncryptRequest creates a request to invoke CertificatePublicKeyEncrypt API

type CertificatePublicKeyEncryptResponse added in v1.61.701

type CertificatePublicKeyEncryptResponse struct {
	*responses.BaseResponse
	CiphertextBlob string `json:"CiphertextBlob" xml:"CiphertextBlob"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
	CertificateId  string `json:"CertificateId" xml:"CertificateId"`
}

CertificatePublicKeyEncryptResponse is the response struct for api CertificatePublicKeyEncrypt

func CreateCertificatePublicKeyEncryptResponse added in v1.61.701

func CreateCertificatePublicKeyEncryptResponse() (response *CertificatePublicKeyEncryptResponse)

CreateCertificatePublicKeyEncryptResponse creates a response to parse from CertificatePublicKeyEncrypt response

type CertificatePublicKeyVerifyRequest added in v1.61.701

type CertificatePublicKeyVerifyRequest struct {
	*requests.RpcRequest
	SignatureValue string `position:"Query" name:"SignatureValue"`
	MessageType    string `position:"Query" name:"MessageType"`
	CertificateId  string `position:"Query" name:"CertificateId"`
	Message        string `position:"Query" name:"Message"`
	Algorithm      string `position:"Query" name:"Algorithm"`
}

CertificatePublicKeyVerifyRequest is the request struct for api CertificatePublicKeyVerify

func CreateCertificatePublicKeyVerifyRequest added in v1.61.701

func CreateCertificatePublicKeyVerifyRequest() (request *CertificatePublicKeyVerifyRequest)

CreateCertificatePublicKeyVerifyRequest creates a request to invoke CertificatePublicKeyVerify API

type CertificatePublicKeyVerifyResponse added in v1.61.701

type CertificatePublicKeyVerifyResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	CertificateId  string `json:"CertificateId" xml:"CertificateId"`
	SignatureValid bool   `json:"SignatureValid" xml:"SignatureValid"`
}

CertificatePublicKeyVerifyResponse is the response struct for api CertificatePublicKeyVerify

func CreateCertificatePublicKeyVerifyResponse added in v1.61.701

func CreateCertificatePublicKeyVerifyResponse() (response *CertificatePublicKeyVerifyResponse)

CreateCertificatePublicKeyVerifyResponse creates a response to parse from CertificatePublicKeyVerify response

type Client

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) AsymmetricDecrypt added in v1.60.310

func (client *Client) AsymmetricDecrypt(request *AsymmetricDecryptRequest) (response *AsymmetricDecryptResponse, err error)

AsymmetricDecrypt invokes the kms.AsymmetricDecrypt API synchronously

func (*Client) AsymmetricDecryptWithCallback added in v1.60.310

func (client *Client) AsymmetricDecryptWithCallback(request *AsymmetricDecryptRequest, callback func(response *AsymmetricDecryptResponse, err error)) <-chan int

AsymmetricDecryptWithCallback invokes the kms.AsymmetricDecrypt API asynchronously

func (*Client) AsymmetricDecryptWithChan added in v1.60.310

func (client *Client) AsymmetricDecryptWithChan(request *AsymmetricDecryptRequest) (<-chan *AsymmetricDecryptResponse, <-chan error)

AsymmetricDecryptWithChan invokes the kms.AsymmetricDecrypt API asynchronously

func (*Client) AsymmetricEncrypt added in v1.60.310

func (client *Client) AsymmetricEncrypt(request *AsymmetricEncryptRequest) (response *AsymmetricEncryptResponse, err error)

AsymmetricEncrypt invokes the kms.AsymmetricEncrypt API synchronously

func (*Client) AsymmetricEncryptWithCallback added in v1.60.310

func (client *Client) AsymmetricEncryptWithCallback(request *AsymmetricEncryptRequest, callback func(response *AsymmetricEncryptResponse, err error)) <-chan int

AsymmetricEncryptWithCallback invokes the kms.AsymmetricEncrypt API asynchronously

func (*Client) AsymmetricEncryptWithChan added in v1.60.310

func (client *Client) AsymmetricEncryptWithChan(request *AsymmetricEncryptRequest) (<-chan *AsymmetricEncryptResponse, <-chan error)

AsymmetricEncryptWithChan invokes the kms.AsymmetricEncrypt API asynchronously

func (*Client) AsymmetricSign added in v1.60.310

func (client *Client) AsymmetricSign(request *AsymmetricSignRequest) (response *AsymmetricSignResponse, err error)

AsymmetricSign invokes the kms.AsymmetricSign API synchronously

func (*Client) AsymmetricSignWithCallback added in v1.60.310

func (client *Client) AsymmetricSignWithCallback(request *AsymmetricSignRequest, callback func(response *AsymmetricSignResponse, err error)) <-chan int

AsymmetricSignWithCallback invokes the kms.AsymmetricSign API asynchronously

func (*Client) AsymmetricSignWithChan added in v1.60.310

func (client *Client) AsymmetricSignWithChan(request *AsymmetricSignRequest) (<-chan *AsymmetricSignResponse, <-chan error)

AsymmetricSignWithChan invokes the kms.AsymmetricSign API asynchronously

func (*Client) AsymmetricVerify added in v1.60.310

func (client *Client) AsymmetricVerify(request *AsymmetricVerifyRequest) (response *AsymmetricVerifyResponse, err error)

AsymmetricVerify invokes the kms.AsymmetricVerify API synchronously

func (*Client) AsymmetricVerifyWithCallback added in v1.60.310

func (client *Client) AsymmetricVerifyWithCallback(request *AsymmetricVerifyRequest, callback func(response *AsymmetricVerifyResponse, err error)) <-chan int

AsymmetricVerifyWithCallback invokes the kms.AsymmetricVerify API asynchronously

func (*Client) AsymmetricVerifyWithChan added in v1.60.310

func (client *Client) AsymmetricVerifyWithChan(request *AsymmetricVerifyRequest) (<-chan *AsymmetricVerifyResponse, <-chan error)

AsymmetricVerifyWithChan invokes the kms.AsymmetricVerify API asynchronously

func (*Client) CancelKeyDeletion

func (client *Client) CancelKeyDeletion(request *CancelKeyDeletionRequest) (response *CancelKeyDeletionResponse, err error)

CancelKeyDeletion invokes the kms.CancelKeyDeletion API synchronously

func (*Client) CancelKeyDeletionWithCallback

func (client *Client) CancelKeyDeletionWithCallback(request *CancelKeyDeletionRequest, callback func(response *CancelKeyDeletionResponse, err error)) <-chan int

CancelKeyDeletionWithCallback invokes the kms.CancelKeyDeletion API asynchronously

func (*Client) CancelKeyDeletionWithChan

func (client *Client) CancelKeyDeletionWithChan(request *CancelKeyDeletionRequest) (<-chan *CancelKeyDeletionResponse, <-chan error)

CancelKeyDeletionWithChan invokes the kms.CancelKeyDeletion API asynchronously

func (*Client) CertificatePrivateKeyDecrypt added in v1.61.701

func (client *Client) CertificatePrivateKeyDecrypt(request *CertificatePrivateKeyDecryptRequest) (response *CertificatePrivateKeyDecryptResponse, err error)

CertificatePrivateKeyDecrypt invokes the kms.CertificatePrivateKeyDecrypt API synchronously

func (*Client) CertificatePrivateKeyDecryptWithCallback added in v1.61.701

func (client *Client) CertificatePrivateKeyDecryptWithCallback(request *CertificatePrivateKeyDecryptRequest, callback func(response *CertificatePrivateKeyDecryptResponse, err error)) <-chan int

CertificatePrivateKeyDecryptWithCallback invokes the kms.CertificatePrivateKeyDecrypt API asynchronously

func (*Client) CertificatePrivateKeyDecryptWithChan added in v1.61.701

func (client *Client) CertificatePrivateKeyDecryptWithChan(request *CertificatePrivateKeyDecryptRequest) (<-chan *CertificatePrivateKeyDecryptResponse, <-chan error)

CertificatePrivateKeyDecryptWithChan invokes the kms.CertificatePrivateKeyDecrypt API asynchronously

func (*Client) CertificatePrivateKeySign added in v1.61.701

func (client *Client) CertificatePrivateKeySign(request *CertificatePrivateKeySignRequest) (response *CertificatePrivateKeySignResponse, err error)

CertificatePrivateKeySign invokes the kms.CertificatePrivateKeySign API synchronously

func (*Client) CertificatePrivateKeySignWithCallback added in v1.61.701

func (client *Client) CertificatePrivateKeySignWithCallback(request *CertificatePrivateKeySignRequest, callback func(response *CertificatePrivateKeySignResponse, err error)) <-chan int

CertificatePrivateKeySignWithCallback invokes the kms.CertificatePrivateKeySign API asynchronously

func (*Client) CertificatePrivateKeySignWithChan added in v1.61.701

func (client *Client) CertificatePrivateKeySignWithChan(request *CertificatePrivateKeySignRequest) (<-chan *CertificatePrivateKeySignResponse, <-chan error)

CertificatePrivateKeySignWithChan invokes the kms.CertificatePrivateKeySign API asynchronously

func (*Client) CertificatePublicKeyEncrypt added in v1.61.701

func (client *Client) CertificatePublicKeyEncrypt(request *CertificatePublicKeyEncryptRequest) (response *CertificatePublicKeyEncryptResponse, err error)

CertificatePublicKeyEncrypt invokes the kms.CertificatePublicKeyEncrypt API synchronously

func (*Client) CertificatePublicKeyEncryptWithCallback added in v1.61.701

func (client *Client) CertificatePublicKeyEncryptWithCallback(request *CertificatePublicKeyEncryptRequest, callback func(response *CertificatePublicKeyEncryptResponse, err error)) <-chan int

CertificatePublicKeyEncryptWithCallback invokes the kms.CertificatePublicKeyEncrypt API asynchronously

func (*Client) CertificatePublicKeyEncryptWithChan added in v1.61.701

func (client *Client) CertificatePublicKeyEncryptWithChan(request *CertificatePublicKeyEncryptRequest) (<-chan *CertificatePublicKeyEncryptResponse, <-chan error)

CertificatePublicKeyEncryptWithChan invokes the kms.CertificatePublicKeyEncrypt API asynchronously

func (*Client) CertificatePublicKeyVerify added in v1.61.701

func (client *Client) CertificatePublicKeyVerify(request *CertificatePublicKeyVerifyRequest) (response *CertificatePublicKeyVerifyResponse, err error)

CertificatePublicKeyVerify invokes the kms.CertificatePublicKeyVerify API synchronously

func (*Client) CertificatePublicKeyVerifyWithCallback added in v1.61.701

func (client *Client) CertificatePublicKeyVerifyWithCallback(request *CertificatePublicKeyVerifyRequest, callback func(response *CertificatePublicKeyVerifyResponse, err error)) <-chan int

CertificatePublicKeyVerifyWithCallback invokes the kms.CertificatePublicKeyVerify API asynchronously

func (*Client) CertificatePublicKeyVerifyWithChan added in v1.61.701

func (client *Client) CertificatePublicKeyVerifyWithChan(request *CertificatePublicKeyVerifyRequest) (<-chan *CertificatePublicKeyVerifyResponse, <-chan error)

CertificatePublicKeyVerifyWithChan invokes the kms.CertificatePublicKeyVerify API asynchronously

func (*Client) CreateAlias

func (client *Client) CreateAlias(request *CreateAliasRequest) (response *CreateAliasResponse, err error)

CreateAlias invokes the kms.CreateAlias API synchronously

func (*Client) CreateAliasWithCallback

func (client *Client) CreateAliasWithCallback(request *CreateAliasRequest, callback func(response *CreateAliasResponse, err error)) <-chan int

CreateAliasWithCallback invokes the kms.CreateAlias API asynchronously

func (*Client) CreateAliasWithChan

func (client *Client) CreateAliasWithChan(request *CreateAliasRequest) (<-chan *CreateAliasResponse, <-chan error)

CreateAliasWithChan invokes the kms.CreateAlias API asynchronously

func (*Client) CreateCertificate added in v1.61.701

func (client *Client) CreateCertificate(request *CreateCertificateRequest) (response *CreateCertificateResponse, err error)

CreateCertificate invokes the kms.CreateCertificate API synchronously

func (*Client) CreateCertificateWithCallback added in v1.61.701

func (client *Client) CreateCertificateWithCallback(request *CreateCertificateRequest, callback func(response *CreateCertificateResponse, err error)) <-chan int

CreateCertificateWithCallback invokes the kms.CreateCertificate API asynchronously

func (*Client) CreateCertificateWithChan added in v1.61.701

func (client *Client) CreateCertificateWithChan(request *CreateCertificateRequest) (<-chan *CreateCertificateResponse, <-chan error)

CreateCertificateWithChan invokes the kms.CreateCertificate API asynchronously

func (*Client) CreateKey

func (client *Client) CreateKey(request *CreateKeyRequest) (response *CreateKeyResponse, err error)

CreateKey invokes the kms.CreateKey API synchronously

func (*Client) CreateKeyVersion added in v1.60.310

func (client *Client) CreateKeyVersion(request *CreateKeyVersionRequest) (response *CreateKeyVersionResponse, err error)

CreateKeyVersion invokes the kms.CreateKeyVersion API synchronously

func (*Client) CreateKeyVersionWithCallback added in v1.60.310

func (client *Client) CreateKeyVersionWithCallback(request *CreateKeyVersionRequest, callback func(response *CreateKeyVersionResponse, err error)) <-chan int

CreateKeyVersionWithCallback invokes the kms.CreateKeyVersion API asynchronously

func (*Client) CreateKeyVersionWithChan added in v1.60.310

func (client *Client) CreateKeyVersionWithChan(request *CreateKeyVersionRequest) (<-chan *CreateKeyVersionResponse, <-chan error)

CreateKeyVersionWithChan invokes the kms.CreateKeyVersion API asynchronously

func (*Client) CreateKeyWithCallback

func (client *Client) CreateKeyWithCallback(request *CreateKeyRequest, callback func(response *CreateKeyResponse, err error)) <-chan int

CreateKeyWithCallback invokes the kms.CreateKey API asynchronously

func (*Client) CreateKeyWithChan

func (client *Client) CreateKeyWithChan(request *CreateKeyRequest) (<-chan *CreateKeyResponse, <-chan error)

CreateKeyWithChan invokes the kms.CreateKey API asynchronously

func (*Client) CreateSecret added in v1.61.16

func (client *Client) CreateSecret(request *CreateSecretRequest) (response *CreateSecretResponse, err error)

CreateSecret invokes the kms.CreateSecret API synchronously

func (*Client) CreateSecretWithCallback added in v1.61.16

func (client *Client) CreateSecretWithCallback(request *CreateSecretRequest, callback func(response *CreateSecretResponse, err error)) <-chan int

CreateSecretWithCallback invokes the kms.CreateSecret API asynchronously

func (*Client) CreateSecretWithChan added in v1.61.16

func (client *Client) CreateSecretWithChan(request *CreateSecretRequest) (<-chan *CreateSecretResponse, <-chan error)

CreateSecretWithChan invokes the kms.CreateSecret API asynchronously

func (*Client) Decrypt

func (client *Client) Decrypt(request *DecryptRequest) (response *DecryptResponse, err error)

Decrypt invokes the kms.Decrypt API synchronously

func (*Client) DecryptWithCallback

func (client *Client) DecryptWithCallback(request *DecryptRequest, callback func(response *DecryptResponse, err error)) <-chan int

DecryptWithCallback invokes the kms.Decrypt API asynchronously

func (*Client) DecryptWithChan

func (client *Client) DecryptWithChan(request *DecryptRequest) (<-chan *DecryptResponse, <-chan error)

DecryptWithChan invokes the kms.Decrypt API asynchronously

func (*Client) DeleteAlias

func (client *Client) DeleteAlias(request *DeleteAliasRequest) (response *DeleteAliasResponse, err error)

DeleteAlias invokes the kms.DeleteAlias API synchronously

func (*Client) DeleteAliasWithCallback

func (client *Client) DeleteAliasWithCallback(request *DeleteAliasRequest, callback func(response *DeleteAliasResponse, err error)) <-chan int

DeleteAliasWithCallback invokes the kms.DeleteAlias API asynchronously

func (*Client) DeleteAliasWithChan

func (client *Client) DeleteAliasWithChan(request *DeleteAliasRequest) (<-chan *DeleteAliasResponse, <-chan error)

DeleteAliasWithChan invokes the kms.DeleteAlias API asynchronously

func (*Client) DeleteCertificate added in v1.61.701

func (client *Client) DeleteCertificate(request *DeleteCertificateRequest) (response *DeleteCertificateResponse, err error)

DeleteCertificate invokes the kms.DeleteCertificate API synchronously

func (*Client) DeleteCertificateWithCallback added in v1.61.701

func (client *Client) DeleteCertificateWithCallback(request *DeleteCertificateRequest, callback func(response *DeleteCertificateResponse, err error)) <-chan int

DeleteCertificateWithCallback invokes the kms.DeleteCertificate API asynchronously

func (*Client) DeleteCertificateWithChan added in v1.61.701

func (client *Client) DeleteCertificateWithChan(request *DeleteCertificateRequest) (<-chan *DeleteCertificateResponse, <-chan error)

DeleteCertificateWithChan invokes the kms.DeleteCertificate API asynchronously

func (*Client) DeleteKeyMaterial

func (client *Client) DeleteKeyMaterial(request *DeleteKeyMaterialRequest) (response *DeleteKeyMaterialResponse, err error)

DeleteKeyMaterial invokes the kms.DeleteKeyMaterial API synchronously

func (*Client) DeleteKeyMaterialWithCallback

func (client *Client) DeleteKeyMaterialWithCallback(request *DeleteKeyMaterialRequest, callback func(response *DeleteKeyMaterialResponse, err error)) <-chan int

DeleteKeyMaterialWithCallback invokes the kms.DeleteKeyMaterial API asynchronously

func (*Client) DeleteKeyMaterialWithChan

func (client *Client) DeleteKeyMaterialWithChan(request *DeleteKeyMaterialRequest) (<-chan *DeleteKeyMaterialResponse, <-chan error)

DeleteKeyMaterialWithChan invokes the kms.DeleteKeyMaterial API asynchronously

func (*Client) DeleteSecret added in v1.61.16

func (client *Client) DeleteSecret(request *DeleteSecretRequest) (response *DeleteSecretResponse, err error)

DeleteSecret invokes the kms.DeleteSecret API synchronously

func (*Client) DeleteSecretWithCallback added in v1.61.16

func (client *Client) DeleteSecretWithCallback(request *DeleteSecretRequest, callback func(response *DeleteSecretResponse, err error)) <-chan int

DeleteSecretWithCallback invokes the kms.DeleteSecret API asynchronously

func (*Client) DeleteSecretWithChan added in v1.61.16

func (client *Client) DeleteSecretWithChan(request *DeleteSecretRequest) (<-chan *DeleteSecretResponse, <-chan error)

DeleteSecretWithChan invokes the kms.DeleteSecret API asynchronously

func (*Client) DescribeAccountKmsStatus added in v1.61.535

func (client *Client) DescribeAccountKmsStatus(request *DescribeAccountKmsStatusRequest) (response *DescribeAccountKmsStatusResponse, err error)

DescribeAccountKmsStatus invokes the kms.DescribeAccountKmsStatus API synchronously

func (*Client) DescribeAccountKmsStatusWithCallback added in v1.61.535

func (client *Client) DescribeAccountKmsStatusWithCallback(request *DescribeAccountKmsStatusRequest, callback func(response *DescribeAccountKmsStatusResponse, err error)) <-chan int

DescribeAccountKmsStatusWithCallback invokes the kms.DescribeAccountKmsStatus API asynchronously

func (*Client) DescribeAccountKmsStatusWithChan added in v1.61.535

func (client *Client) DescribeAccountKmsStatusWithChan(request *DescribeAccountKmsStatusRequest) (<-chan *DescribeAccountKmsStatusResponse, <-chan error)

DescribeAccountKmsStatusWithChan invokes the kms.DescribeAccountKmsStatus API asynchronously

func (*Client) DescribeCertificate added in v1.61.701

func (client *Client) DescribeCertificate(request *DescribeCertificateRequest) (response *DescribeCertificateResponse, err error)

DescribeCertificate invokes the kms.DescribeCertificate API synchronously

func (*Client) DescribeCertificateWithCallback added in v1.61.701

func (client *Client) DescribeCertificateWithCallback(request *DescribeCertificateRequest, callback func(response *DescribeCertificateResponse, err error)) <-chan int

DescribeCertificateWithCallback invokes the kms.DescribeCertificate API asynchronously

func (*Client) DescribeCertificateWithChan added in v1.61.701

func (client *Client) DescribeCertificateWithChan(request *DescribeCertificateRequest) (<-chan *DescribeCertificateResponse, <-chan error)

DescribeCertificateWithChan invokes the kms.DescribeCertificate API asynchronously

func (*Client) DescribeKey

func (client *Client) DescribeKey(request *DescribeKeyRequest) (response *DescribeKeyResponse, err error)

DescribeKey invokes the kms.DescribeKey API synchronously

func (*Client) DescribeKeyVersion

func (client *Client) DescribeKeyVersion(request *DescribeKeyVersionRequest) (response *DescribeKeyVersionResponse, err error)

DescribeKeyVersion invokes the kms.DescribeKeyVersion API synchronously

func (*Client) DescribeKeyVersionWithCallback

func (client *Client) DescribeKeyVersionWithCallback(request *DescribeKeyVersionRequest, callback func(response *DescribeKeyVersionResponse, err error)) <-chan int

DescribeKeyVersionWithCallback invokes the kms.DescribeKeyVersion API asynchronously

func (*Client) DescribeKeyVersionWithChan

func (client *Client) DescribeKeyVersionWithChan(request *DescribeKeyVersionRequest) (<-chan *DescribeKeyVersionResponse, <-chan error)

DescribeKeyVersionWithChan invokes the kms.DescribeKeyVersion API asynchronously

func (*Client) DescribeKeyWithCallback

func (client *Client) DescribeKeyWithCallback(request *DescribeKeyRequest, callback func(response *DescribeKeyResponse, err error)) <-chan int

DescribeKeyWithCallback invokes the kms.DescribeKey API asynchronously

func (*Client) DescribeKeyWithChan

func (client *Client) DescribeKeyWithChan(request *DescribeKeyRequest) (<-chan *DescribeKeyResponse, <-chan error)

DescribeKeyWithChan invokes the kms.DescribeKey API asynchronously

func (*Client) DescribeRegions

func (client *Client) DescribeRegions(request *DescribeRegionsRequest) (response *DescribeRegionsResponse, err error)

DescribeRegions invokes the kms.DescribeRegions API synchronously

func (*Client) DescribeRegionsWithCallback

func (client *Client) DescribeRegionsWithCallback(request *DescribeRegionsRequest, callback func(response *DescribeRegionsResponse, err error)) <-chan int

DescribeRegionsWithCallback invokes the kms.DescribeRegions API asynchronously

func (*Client) DescribeRegionsWithChan

func (client *Client) DescribeRegionsWithChan(request *DescribeRegionsRequest) (<-chan *DescribeRegionsResponse, <-chan error)

DescribeRegionsWithChan invokes the kms.DescribeRegions API asynchronously

func (*Client) DescribeSecret added in v1.61.16

func (client *Client) DescribeSecret(request *DescribeSecretRequest) (response *DescribeSecretResponse, err error)

DescribeSecret invokes the kms.DescribeSecret API synchronously

func (*Client) DescribeSecretWithCallback added in v1.61.16

func (client *Client) DescribeSecretWithCallback(request *DescribeSecretRequest, callback func(response *DescribeSecretResponse, err error)) <-chan int

DescribeSecretWithCallback invokes the kms.DescribeSecret API asynchronously

func (*Client) DescribeSecretWithChan added in v1.61.16

func (client *Client) DescribeSecretWithChan(request *DescribeSecretRequest) (<-chan *DescribeSecretResponse, <-chan error)

DescribeSecretWithChan invokes the kms.DescribeSecret API asynchronously

func (*Client) DisableKey

func (client *Client) DisableKey(request *DisableKeyRequest) (response *DisableKeyResponse, err error)

DisableKey invokes the kms.DisableKey API synchronously

func (*Client) DisableKeyWithCallback

func (client *Client) DisableKeyWithCallback(request *DisableKeyRequest, callback func(response *DisableKeyResponse, err error)) <-chan int

DisableKeyWithCallback invokes the kms.DisableKey API asynchronously

func (*Client) DisableKeyWithChan

func (client *Client) DisableKeyWithChan(request *DisableKeyRequest) (<-chan *DisableKeyResponse, <-chan error)

DisableKeyWithChan invokes the kms.DisableKey API asynchronously

func (*Client) EnableKey

func (client *Client) EnableKey(request *EnableKeyRequest) (response *EnableKeyResponse, err error)

EnableKey invokes the kms.EnableKey API synchronously

func (*Client) EnableKeyWithCallback

func (client *Client) EnableKeyWithCallback(request *EnableKeyRequest, callback func(response *EnableKeyResponse, err error)) <-chan int

EnableKeyWithCallback invokes the kms.EnableKey API asynchronously

func (*Client) EnableKeyWithChan

func (client *Client) EnableKeyWithChan(request *EnableKeyRequest) (<-chan *EnableKeyResponse, <-chan error)

EnableKeyWithChan invokes the kms.EnableKey API asynchronously

func (*Client) Encrypt

func (client *Client) Encrypt(request *EncryptRequest) (response *EncryptResponse, err error)

Encrypt invokes the kms.Encrypt API synchronously

func (*Client) EncryptWithCallback

func (client *Client) EncryptWithCallback(request *EncryptRequest, callback func(response *EncryptResponse, err error)) <-chan int

EncryptWithCallback invokes the kms.Encrypt API asynchronously

func (*Client) EncryptWithChan

func (client *Client) EncryptWithChan(request *EncryptRequest) (<-chan *EncryptResponse, <-chan error)

EncryptWithChan invokes the kms.Encrypt API asynchronously

func (*Client) ExportDataKey added in v1.61.342

func (client *Client) ExportDataKey(request *ExportDataKeyRequest) (response *ExportDataKeyResponse, err error)

ExportDataKey invokes the kms.ExportDataKey API synchronously

func (*Client) ExportDataKeyWithCallback added in v1.61.342

func (client *Client) ExportDataKeyWithCallback(request *ExportDataKeyRequest, callback func(response *ExportDataKeyResponse, err error)) <-chan int

ExportDataKeyWithCallback invokes the kms.ExportDataKey API asynchronously

func (*Client) ExportDataKeyWithChan added in v1.61.342

func (client *Client) ExportDataKeyWithChan(request *ExportDataKeyRequest) (<-chan *ExportDataKeyResponse, <-chan error)

ExportDataKeyWithChan invokes the kms.ExportDataKey API asynchronously

func (*Client) GenerateAndExportDataKey added in v1.61.342

func (client *Client) GenerateAndExportDataKey(request *GenerateAndExportDataKeyRequest) (response *GenerateAndExportDataKeyResponse, err error)

GenerateAndExportDataKey invokes the kms.GenerateAndExportDataKey API synchronously

func (*Client) GenerateAndExportDataKeyWithCallback added in v1.61.342

func (client *Client) GenerateAndExportDataKeyWithCallback(request *GenerateAndExportDataKeyRequest, callback func(response *GenerateAndExportDataKeyResponse, err error)) <-chan int

GenerateAndExportDataKeyWithCallback invokes the kms.GenerateAndExportDataKey API asynchronously

func (*Client) GenerateAndExportDataKeyWithChan added in v1.61.342

func (client *Client) GenerateAndExportDataKeyWithChan(request *GenerateAndExportDataKeyRequest) (<-chan *GenerateAndExportDataKeyResponse, <-chan error)

GenerateAndExportDataKeyWithChan invokes the kms.GenerateAndExportDataKey API asynchronously

func (*Client) GenerateDataKey

func (client *Client) GenerateDataKey(request *GenerateDataKeyRequest) (response *GenerateDataKeyResponse, err error)

GenerateDataKey invokes the kms.GenerateDataKey API synchronously

func (*Client) GenerateDataKeyWithCallback

func (client *Client) GenerateDataKeyWithCallback(request *GenerateDataKeyRequest, callback func(response *GenerateDataKeyResponse, err error)) <-chan int

GenerateDataKeyWithCallback invokes the kms.GenerateDataKey API asynchronously

func (*Client) GenerateDataKeyWithChan

func (client *Client) GenerateDataKeyWithChan(request *GenerateDataKeyRequest) (<-chan *GenerateDataKeyResponse, <-chan error)

GenerateDataKeyWithChan invokes the kms.GenerateDataKey API asynchronously

func (*Client) GenerateDataKeyWithoutPlaintext

func (client *Client) GenerateDataKeyWithoutPlaintext(request *GenerateDataKeyWithoutPlaintextRequest) (response *GenerateDataKeyWithoutPlaintextResponse, err error)

GenerateDataKeyWithoutPlaintext invokes the kms.GenerateDataKeyWithoutPlaintext API synchronously

func (*Client) GenerateDataKeyWithoutPlaintextWithCallback

func (client *Client) GenerateDataKeyWithoutPlaintextWithCallback(request *GenerateDataKeyWithoutPlaintextRequest, callback func(response *GenerateDataKeyWithoutPlaintextResponse, err error)) <-chan int

GenerateDataKeyWithoutPlaintextWithCallback invokes the kms.GenerateDataKeyWithoutPlaintext API asynchronously

func (*Client) GenerateDataKeyWithoutPlaintextWithChan

func (client *Client) GenerateDataKeyWithoutPlaintextWithChan(request *GenerateDataKeyWithoutPlaintextRequest) (<-chan *GenerateDataKeyWithoutPlaintextResponse, <-chan error)

GenerateDataKeyWithoutPlaintextWithChan invokes the kms.GenerateDataKeyWithoutPlaintext API asynchronously

func (*Client) GetCertificate added in v1.61.701

func (client *Client) GetCertificate(request *GetCertificateRequest) (response *GetCertificateResponse, err error)

GetCertificate invokes the kms.GetCertificate API synchronously

func (*Client) GetCertificateWithCallback added in v1.61.701

func (client *Client) GetCertificateWithCallback(request *GetCertificateRequest, callback func(response *GetCertificateResponse, err error)) <-chan int

GetCertificateWithCallback invokes the kms.GetCertificate API asynchronously

func (*Client) GetCertificateWithChan added in v1.61.701

func (client *Client) GetCertificateWithChan(request *GetCertificateRequest) (<-chan *GetCertificateResponse, <-chan error)

GetCertificateWithChan invokes the kms.GetCertificate API asynchronously

func (*Client) GetParametersForImport

func (client *Client) GetParametersForImport(request *GetParametersForImportRequest) (response *GetParametersForImportResponse, err error)

GetParametersForImport invokes the kms.GetParametersForImport API synchronously

func (*Client) GetParametersForImportWithCallback

func (client *Client) GetParametersForImportWithCallback(request *GetParametersForImportRequest, callback func(response *GetParametersForImportResponse, err error)) <-chan int

GetParametersForImportWithCallback invokes the kms.GetParametersForImport API asynchronously

func (*Client) GetParametersForImportWithChan

func (client *Client) GetParametersForImportWithChan(request *GetParametersForImportRequest) (<-chan *GetParametersForImportResponse, <-chan error)

GetParametersForImportWithChan invokes the kms.GetParametersForImport API asynchronously

func (*Client) GetPublicKey added in v1.60.310

func (client *Client) GetPublicKey(request *GetPublicKeyRequest) (response *GetPublicKeyResponse, err error)

GetPublicKey invokes the kms.GetPublicKey API synchronously

func (*Client) GetPublicKeyWithCallback added in v1.60.310

func (client *Client) GetPublicKeyWithCallback(request *GetPublicKeyRequest, callback func(response *GetPublicKeyResponse, err error)) <-chan int

GetPublicKeyWithCallback invokes the kms.GetPublicKey API asynchronously

func (*Client) GetPublicKeyWithChan added in v1.60.310

func (client *Client) GetPublicKeyWithChan(request *GetPublicKeyRequest) (<-chan *GetPublicKeyResponse, <-chan error)

GetPublicKeyWithChan invokes the kms.GetPublicKey API asynchronously

func (*Client) GetRandomPassword added in v1.61.16

func (client *Client) GetRandomPassword(request *GetRandomPasswordRequest) (response *GetRandomPasswordResponse, err error)

GetRandomPassword invokes the kms.GetRandomPassword API synchronously

func (*Client) GetRandomPasswordWithCallback added in v1.61.16

func (client *Client) GetRandomPasswordWithCallback(request *GetRandomPasswordRequest, callback func(response *GetRandomPasswordResponse, err error)) <-chan int

GetRandomPasswordWithCallback invokes the kms.GetRandomPassword API asynchronously

func (*Client) GetRandomPasswordWithChan added in v1.61.16

func (client *Client) GetRandomPasswordWithChan(request *GetRandomPasswordRequest) (<-chan *GetRandomPasswordResponse, <-chan error)

GetRandomPasswordWithChan invokes the kms.GetRandomPassword API asynchronously

func (*Client) GetSecretValue added in v1.61.16

func (client *Client) GetSecretValue(request *GetSecretValueRequest) (response *GetSecretValueResponse, err error)

GetSecretValue invokes the kms.GetSecretValue API synchronously

func (*Client) GetSecretValueWithCallback added in v1.61.16

func (client *Client) GetSecretValueWithCallback(request *GetSecretValueRequest, callback func(response *GetSecretValueResponse, err error)) <-chan int

GetSecretValueWithCallback invokes the kms.GetSecretValue API asynchronously

func (*Client) GetSecretValueWithChan added in v1.61.16

func (client *Client) GetSecretValueWithChan(request *GetSecretValueRequest) (<-chan *GetSecretValueResponse, <-chan error)

GetSecretValueWithChan invokes the kms.GetSecretValue API asynchronously

func (*Client) ImportKeyMaterial

func (client *Client) ImportKeyMaterial(request *ImportKeyMaterialRequest) (response *ImportKeyMaterialResponse, err error)

ImportKeyMaterial invokes the kms.ImportKeyMaterial API synchronously

func (*Client) ImportKeyMaterialWithCallback

func (client *Client) ImportKeyMaterialWithCallback(request *ImportKeyMaterialRequest, callback func(response *ImportKeyMaterialResponse, err error)) <-chan int

ImportKeyMaterialWithCallback invokes the kms.ImportKeyMaterial API asynchronously

func (*Client) ImportKeyMaterialWithChan

func (client *Client) ImportKeyMaterialWithChan(request *ImportKeyMaterialRequest) (<-chan *ImportKeyMaterialResponse, <-chan error)

ImportKeyMaterialWithChan invokes the kms.ImportKeyMaterial API asynchronously

func (*Client) ListAliases

func (client *Client) ListAliases(request *ListAliasesRequest) (response *ListAliasesResponse, err error)

ListAliases invokes the kms.ListAliases API synchronously

func (*Client) ListAliasesByKeyId

func (client *Client) ListAliasesByKeyId(request *ListAliasesByKeyIdRequest) (response *ListAliasesByKeyIdResponse, err error)

ListAliasesByKeyId invokes the kms.ListAliasesByKeyId API synchronously

func (*Client) ListAliasesByKeyIdWithCallback

func (client *Client) ListAliasesByKeyIdWithCallback(request *ListAliasesByKeyIdRequest, callback func(response *ListAliasesByKeyIdResponse, err error)) <-chan int

ListAliasesByKeyIdWithCallback invokes the kms.ListAliasesByKeyId API asynchronously

func (*Client) ListAliasesByKeyIdWithChan

func (client *Client) ListAliasesByKeyIdWithChan(request *ListAliasesByKeyIdRequest) (<-chan *ListAliasesByKeyIdResponse, <-chan error)

ListAliasesByKeyIdWithChan invokes the kms.ListAliasesByKeyId API asynchronously

func (*Client) ListAliasesWithCallback

func (client *Client) ListAliasesWithCallback(request *ListAliasesRequest, callback func(response *ListAliasesResponse, err error)) <-chan int

ListAliasesWithCallback invokes the kms.ListAliases API asynchronously

func (*Client) ListAliasesWithChan

func (client *Client) ListAliasesWithChan(request *ListAliasesRequest) (<-chan *ListAliasesResponse, <-chan error)

ListAliasesWithChan invokes the kms.ListAliases API asynchronously

func (*Client) ListKeyVersions

func (client *Client) ListKeyVersions(request *ListKeyVersionsRequest) (response *ListKeyVersionsResponse, err error)

ListKeyVersions invokes the kms.ListKeyVersions API synchronously

func (*Client) ListKeyVersionsWithCallback

func (client *Client) ListKeyVersionsWithCallback(request *ListKeyVersionsRequest, callback func(response *ListKeyVersionsResponse, err error)) <-chan int

ListKeyVersionsWithCallback invokes the kms.ListKeyVersions API asynchronously

func (*Client) ListKeyVersionsWithChan

func (client *Client) ListKeyVersionsWithChan(request *ListKeyVersionsRequest) (<-chan *ListKeyVersionsResponse, <-chan error)

ListKeyVersionsWithChan invokes the kms.ListKeyVersions API asynchronously

func (*Client) ListKeys

func (client *Client) ListKeys(request *ListKeysRequest) (response *ListKeysResponse, err error)

ListKeys invokes the kms.ListKeys API synchronously

func (*Client) ListKeysWithCallback

func (client *Client) ListKeysWithCallback(request *ListKeysRequest, callback func(response *ListKeysResponse, err error)) <-chan int

ListKeysWithCallback invokes the kms.ListKeys API asynchronously

func (*Client) ListKeysWithChan

func (client *Client) ListKeysWithChan(request *ListKeysRequest) (<-chan *ListKeysResponse, <-chan error)

ListKeysWithChan invokes the kms.ListKeys API asynchronously

func (*Client) ListResourceTags

func (client *Client) ListResourceTags(request *ListResourceTagsRequest) (response *ListResourceTagsResponse, err error)

ListResourceTags invokes the kms.ListResourceTags API synchronously

func (*Client) ListResourceTagsWithCallback

func (client *Client) ListResourceTagsWithCallback(request *ListResourceTagsRequest, callback func(response *ListResourceTagsResponse, err error)) <-chan int

ListResourceTagsWithCallback invokes the kms.ListResourceTags API asynchronously

func (*Client) ListResourceTagsWithChan

func (client *Client) ListResourceTagsWithChan(request *ListResourceTagsRequest) (<-chan *ListResourceTagsResponse, <-chan error)

ListResourceTagsWithChan invokes the kms.ListResourceTags API asynchronously

func (*Client) ListSecretVersionIds added in v1.61.16

func (client *Client) ListSecretVersionIds(request *ListSecretVersionIdsRequest) (response *ListSecretVersionIdsResponse, err error)

ListSecretVersionIds invokes the kms.ListSecretVersionIds API synchronously

func (*Client) ListSecretVersionIdsWithCallback added in v1.61.16

func (client *Client) ListSecretVersionIdsWithCallback(request *ListSecretVersionIdsRequest, callback func(response *ListSecretVersionIdsResponse, err error)) <-chan int

ListSecretVersionIdsWithCallback invokes the kms.ListSecretVersionIds API asynchronously

func (*Client) ListSecretVersionIdsWithChan added in v1.61.16

func (client *Client) ListSecretVersionIdsWithChan(request *ListSecretVersionIdsRequest) (<-chan *ListSecretVersionIdsResponse, <-chan error)

ListSecretVersionIdsWithChan invokes the kms.ListSecretVersionIds API asynchronously

func (*Client) ListSecrets added in v1.61.16

func (client *Client) ListSecrets(request *ListSecretsRequest) (response *ListSecretsResponse, err error)

ListSecrets invokes the kms.ListSecrets API synchronously

func (*Client) ListSecretsWithCallback added in v1.61.16

func (client *Client) ListSecretsWithCallback(request *ListSecretsRequest, callback func(response *ListSecretsResponse, err error)) <-chan int

ListSecretsWithCallback invokes the kms.ListSecrets API asynchronously

func (*Client) ListSecretsWithChan added in v1.61.16

func (client *Client) ListSecretsWithChan(request *ListSecretsRequest) (<-chan *ListSecretsResponse, <-chan error)

ListSecretsWithChan invokes the kms.ListSecrets API asynchronously

func (*Client) OpenKmsService added in v1.61.535

func (client *Client) OpenKmsService(request *OpenKmsServiceRequest) (response *OpenKmsServiceResponse, err error)

OpenKmsService invokes the kms.OpenKmsService API synchronously

func (*Client) OpenKmsServiceWithCallback added in v1.61.535

func (client *Client) OpenKmsServiceWithCallback(request *OpenKmsServiceRequest, callback func(response *OpenKmsServiceResponse, err error)) <-chan int

OpenKmsServiceWithCallback invokes the kms.OpenKmsService API asynchronously

func (*Client) OpenKmsServiceWithChan added in v1.61.535

func (client *Client) OpenKmsServiceWithChan(request *OpenKmsServiceRequest) (<-chan *OpenKmsServiceResponse, <-chan error)

OpenKmsServiceWithChan invokes the kms.OpenKmsService API asynchronously

func (*Client) PutSecretValue added in v1.61.16

func (client *Client) PutSecretValue(request *PutSecretValueRequest) (response *PutSecretValueResponse, err error)

PutSecretValue invokes the kms.PutSecretValue API synchronously

func (*Client) PutSecretValueWithCallback added in v1.61.16

func (client *Client) PutSecretValueWithCallback(request *PutSecretValueRequest, callback func(response *PutSecretValueResponse, err error)) <-chan int

PutSecretValueWithCallback invokes the kms.PutSecretValue API asynchronously

func (*Client) PutSecretValueWithChan added in v1.61.16

func (client *Client) PutSecretValueWithChan(request *PutSecretValueRequest) (<-chan *PutSecretValueResponse, <-chan error)

PutSecretValueWithChan invokes the kms.PutSecretValue API asynchronously

func (*Client) ReEncrypt added in v1.61.342

func (client *Client) ReEncrypt(request *ReEncryptRequest) (response *ReEncryptResponse, err error)

ReEncrypt invokes the kms.ReEncrypt API synchronously

func (*Client) ReEncryptWithCallback added in v1.61.342

func (client *Client) ReEncryptWithCallback(request *ReEncryptRequest, callback func(response *ReEncryptResponse, err error)) <-chan int

ReEncryptWithCallback invokes the kms.ReEncrypt API asynchronously

func (*Client) ReEncryptWithChan added in v1.61.342

func (client *Client) ReEncryptWithChan(request *ReEncryptRequest) (<-chan *ReEncryptResponse, <-chan error)

ReEncryptWithChan invokes the kms.ReEncrypt API asynchronously

func (*Client) RestoreSecret added in v1.61.16

func (client *Client) RestoreSecret(request *RestoreSecretRequest) (response *RestoreSecretResponse, err error)

RestoreSecret invokes the kms.RestoreSecret API synchronously

func (*Client) RestoreSecretWithCallback added in v1.61.16

func (client *Client) RestoreSecretWithCallback(request *RestoreSecretRequest, callback func(response *RestoreSecretResponse, err error)) <-chan int

RestoreSecretWithCallback invokes the kms.RestoreSecret API asynchronously

func (*Client) RestoreSecretWithChan added in v1.61.16

func (client *Client) RestoreSecretWithChan(request *RestoreSecretRequest) (<-chan *RestoreSecretResponse, <-chan error)

RestoreSecretWithChan invokes the kms.RestoreSecret API asynchronously

func (*Client) RotateSecret added in v1.61.780

func (client *Client) RotateSecret(request *RotateSecretRequest) (response *RotateSecretResponse, err error)

RotateSecret invokes the kms.RotateSecret API synchronously

func (*Client) RotateSecretWithCallback added in v1.61.780

func (client *Client) RotateSecretWithCallback(request *RotateSecretRequest, callback func(response *RotateSecretResponse, err error)) <-chan int

RotateSecretWithCallback invokes the kms.RotateSecret API asynchronously

func (*Client) RotateSecretWithChan added in v1.61.780

func (client *Client) RotateSecretWithChan(request *RotateSecretRequest) (<-chan *RotateSecretResponse, <-chan error)

RotateSecretWithChan invokes the kms.RotateSecret API asynchronously

func (*Client) ScheduleKeyDeletion

func (client *Client) ScheduleKeyDeletion(request *ScheduleKeyDeletionRequest) (response *ScheduleKeyDeletionResponse, err error)

ScheduleKeyDeletion invokes the kms.ScheduleKeyDeletion API synchronously

func (*Client) ScheduleKeyDeletionWithCallback

func (client *Client) ScheduleKeyDeletionWithCallback(request *ScheduleKeyDeletionRequest, callback func(response *ScheduleKeyDeletionResponse, err error)) <-chan int

ScheduleKeyDeletionWithCallback invokes the kms.ScheduleKeyDeletion API asynchronously

func (*Client) ScheduleKeyDeletionWithChan

func (client *Client) ScheduleKeyDeletionWithChan(request *ScheduleKeyDeletionRequest) (<-chan *ScheduleKeyDeletionResponse, <-chan error)

ScheduleKeyDeletionWithChan invokes the kms.ScheduleKeyDeletion API asynchronously

func (*Client) SetDeletionProtection added in v1.61.1118

func (client *Client) SetDeletionProtection(request *SetDeletionProtectionRequest) (response *SetDeletionProtectionResponse, err error)

SetDeletionProtection invokes the kms.SetDeletionProtection API synchronously

func (*Client) SetDeletionProtectionWithCallback added in v1.61.1118

func (client *Client) SetDeletionProtectionWithCallback(request *SetDeletionProtectionRequest, callback func(response *SetDeletionProtectionResponse, err error)) <-chan int

SetDeletionProtectionWithCallback invokes the kms.SetDeletionProtection API asynchronously

func (*Client) SetDeletionProtectionWithChan added in v1.61.1118

func (client *Client) SetDeletionProtectionWithChan(request *SetDeletionProtectionRequest) (<-chan *SetDeletionProtectionResponse, <-chan error)

SetDeletionProtectionWithChan invokes the kms.SetDeletionProtection API asynchronously

func (*Client) TagResource

func (client *Client) TagResource(request *TagResourceRequest) (response *TagResourceResponse, err error)

TagResource invokes the kms.TagResource API synchronously

func (*Client) TagResourceWithCallback

func (client *Client) TagResourceWithCallback(request *TagResourceRequest, callback func(response *TagResourceResponse, err error)) <-chan int

TagResourceWithCallback invokes the kms.TagResource API asynchronously

func (*Client) TagResourceWithChan

func (client *Client) TagResourceWithChan(request *TagResourceRequest) (<-chan *TagResourceResponse, <-chan error)

TagResourceWithChan invokes the kms.TagResource API asynchronously

func (*Client) UntagResource

func (client *Client) UntagResource(request *UntagResourceRequest) (response *UntagResourceResponse, err error)

UntagResource invokes the kms.UntagResource API synchronously

func (*Client) UntagResourceWithCallback

func (client *Client) UntagResourceWithCallback(request *UntagResourceRequest, callback func(response *UntagResourceResponse, err error)) <-chan int

UntagResourceWithCallback invokes the kms.UntagResource API asynchronously

func (*Client) UntagResourceWithChan

func (client *Client) UntagResourceWithChan(request *UntagResourceRequest) (<-chan *UntagResourceResponse, <-chan error)

UntagResourceWithChan invokes the kms.UntagResource API asynchronously

func (*Client) UpdateAlias

func (client *Client) UpdateAlias(request *UpdateAliasRequest) (response *UpdateAliasResponse, err error)

UpdateAlias invokes the kms.UpdateAlias API synchronously

func (*Client) UpdateAliasWithCallback

func (client *Client) UpdateAliasWithCallback(request *UpdateAliasRequest, callback func(response *UpdateAliasResponse, err error)) <-chan int

UpdateAliasWithCallback invokes the kms.UpdateAlias API asynchronously

func (*Client) UpdateAliasWithChan

func (client *Client) UpdateAliasWithChan(request *UpdateAliasRequest) (<-chan *UpdateAliasResponse, <-chan error)

UpdateAliasWithChan invokes the kms.UpdateAlias API asynchronously

func (*Client) UpdateCertificateStatus added in v1.61.701

func (client *Client) UpdateCertificateStatus(request *UpdateCertificateStatusRequest) (response *UpdateCertificateStatusResponse, err error)

UpdateCertificateStatus invokes the kms.UpdateCertificateStatus API synchronously

func (*Client) UpdateCertificateStatusWithCallback added in v1.61.701

func (client *Client) UpdateCertificateStatusWithCallback(request *UpdateCertificateStatusRequest, callback func(response *UpdateCertificateStatusResponse, err error)) <-chan int

UpdateCertificateStatusWithCallback invokes the kms.UpdateCertificateStatus API asynchronously

func (*Client) UpdateCertificateStatusWithChan added in v1.61.701

func (client *Client) UpdateCertificateStatusWithChan(request *UpdateCertificateStatusRequest) (<-chan *UpdateCertificateStatusResponse, <-chan error)

UpdateCertificateStatusWithChan invokes the kms.UpdateCertificateStatus API asynchronously

func (*Client) UpdateKeyDescription

func (client *Client) UpdateKeyDescription(request *UpdateKeyDescriptionRequest) (response *UpdateKeyDescriptionResponse, err error)

UpdateKeyDescription invokes the kms.UpdateKeyDescription API synchronously

func (*Client) UpdateKeyDescriptionWithCallback

func (client *Client) UpdateKeyDescriptionWithCallback(request *UpdateKeyDescriptionRequest, callback func(response *UpdateKeyDescriptionResponse, err error)) <-chan int

UpdateKeyDescriptionWithCallback invokes the kms.UpdateKeyDescription API asynchronously

func (*Client) UpdateKeyDescriptionWithChan

func (client *Client) UpdateKeyDescriptionWithChan(request *UpdateKeyDescriptionRequest) (<-chan *UpdateKeyDescriptionResponse, <-chan error)

UpdateKeyDescriptionWithChan invokes the kms.UpdateKeyDescription API asynchronously

func (*Client) UpdateRotationPolicy

func (client *Client) UpdateRotationPolicy(request *UpdateRotationPolicyRequest) (response *UpdateRotationPolicyResponse, err error)

UpdateRotationPolicy invokes the kms.UpdateRotationPolicy API synchronously

func (*Client) UpdateRotationPolicyWithCallback

func (client *Client) UpdateRotationPolicyWithCallback(request *UpdateRotationPolicyRequest, callback func(response *UpdateRotationPolicyResponse, err error)) <-chan int

UpdateRotationPolicyWithCallback invokes the kms.UpdateRotationPolicy API asynchronously

func (*Client) UpdateRotationPolicyWithChan

func (client *Client) UpdateRotationPolicyWithChan(request *UpdateRotationPolicyRequest) (<-chan *UpdateRotationPolicyResponse, <-chan error)

UpdateRotationPolicyWithChan invokes the kms.UpdateRotationPolicy API asynchronously

func (*Client) UpdateSecret added in v1.61.16

func (client *Client) UpdateSecret(request *UpdateSecretRequest) (response *UpdateSecretResponse, err error)

UpdateSecret invokes the kms.UpdateSecret API synchronously

func (*Client) UpdateSecretRotationPolicy added in v1.61.780

func (client *Client) UpdateSecretRotationPolicy(request *UpdateSecretRotationPolicyRequest) (response *UpdateSecretRotationPolicyResponse, err error)

UpdateSecretRotationPolicy invokes the kms.UpdateSecretRotationPolicy API synchronously

func (*Client) UpdateSecretRotationPolicyWithCallback added in v1.61.780

func (client *Client) UpdateSecretRotationPolicyWithCallback(request *UpdateSecretRotationPolicyRequest, callback func(response *UpdateSecretRotationPolicyResponse, err error)) <-chan int

UpdateSecretRotationPolicyWithCallback invokes the kms.UpdateSecretRotationPolicy API asynchronously

func (*Client) UpdateSecretRotationPolicyWithChan added in v1.61.780

func (client *Client) UpdateSecretRotationPolicyWithChan(request *UpdateSecretRotationPolicyRequest) (<-chan *UpdateSecretRotationPolicyResponse, <-chan error)

UpdateSecretRotationPolicyWithChan invokes the kms.UpdateSecretRotationPolicy API asynchronously

func (*Client) UpdateSecretVersionStage added in v1.61.16

func (client *Client) UpdateSecretVersionStage(request *UpdateSecretVersionStageRequest) (response *UpdateSecretVersionStageResponse, err error)

UpdateSecretVersionStage invokes the kms.UpdateSecretVersionStage API synchronously

func (*Client) UpdateSecretVersionStageWithCallback added in v1.61.16

func (client *Client) UpdateSecretVersionStageWithCallback(request *UpdateSecretVersionStageRequest, callback func(response *UpdateSecretVersionStageResponse, err error)) <-chan int

UpdateSecretVersionStageWithCallback invokes the kms.UpdateSecretVersionStage API asynchronously

func (*Client) UpdateSecretVersionStageWithChan added in v1.61.16

func (client *Client) UpdateSecretVersionStageWithChan(request *UpdateSecretVersionStageRequest) (<-chan *UpdateSecretVersionStageResponse, <-chan error)

UpdateSecretVersionStageWithChan invokes the kms.UpdateSecretVersionStage API asynchronously

func (*Client) UpdateSecretWithCallback added in v1.61.16

func (client *Client) UpdateSecretWithCallback(request *UpdateSecretRequest, callback func(response *UpdateSecretResponse, err error)) <-chan int

UpdateSecretWithCallback invokes the kms.UpdateSecret API asynchronously

func (*Client) UpdateSecretWithChan added in v1.61.16

func (client *Client) UpdateSecretWithChan(request *UpdateSecretRequest) (<-chan *UpdateSecretResponse, <-chan error)

UpdateSecretWithChan invokes the kms.UpdateSecret API asynchronously

func (*Client) UploadCertificate added in v1.61.701

func (client *Client) UploadCertificate(request *UploadCertificateRequest) (response *UploadCertificateResponse, err error)

UploadCertificate invokes the kms.UploadCertificate API synchronously

func (*Client) UploadCertificateWithCallback added in v1.61.701

func (client *Client) UploadCertificateWithCallback(request *UploadCertificateRequest, callback func(response *UploadCertificateResponse, err error)) <-chan int

UploadCertificateWithCallback invokes the kms.UploadCertificate API asynchronously

func (*Client) UploadCertificateWithChan added in v1.61.701

func (client *Client) UploadCertificateWithChan(request *UploadCertificateRequest) (<-chan *UploadCertificateResponse, <-chan error)

UploadCertificateWithChan invokes the kms.UploadCertificate API asynchronously

type CreateAliasRequest

type CreateAliasRequest struct {
	*requests.RpcRequest
	AliasName string `position:"Query" name:"AliasName"`
	KeyId     string `position:"Query" name:"KeyId"`
}

CreateAliasRequest is the request struct for api CreateAlias

func CreateCreateAliasRequest

func CreateCreateAliasRequest() (request *CreateAliasRequest)

CreateCreateAliasRequest creates a request to invoke CreateAlias API

type CreateAliasResponse

type CreateAliasResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

CreateAliasResponse is the response struct for api CreateAlias

func CreateCreateAliasResponse

func CreateCreateAliasResponse() (response *CreateAliasResponse)

CreateCreateAliasResponse creates a response to parse from CreateAlias response

type CreateCertificateRequest added in v1.61.701

type CreateCertificateRequest struct {
	*requests.RpcRequest
	ProtectionLevel         string                 `position:"Query" name:"ProtectionLevel"`
	ExportablePrivateKey    requests.Boolean       `position:"Query" name:"ExportablePrivateKey"`
	ClientToken             string                 `position:"Query" name:"ClientToken"`
	Subject                 string                 `position:"Query" name:"Subject"`
	SubjectAlternativeNames map[string]interface{} `position:"Query" name:"SubjectAlternativeNames"`
	KeySpec                 string                 `position:"Query" name:"KeySpec"`
}

CreateCertificateRequest is the request struct for api CreateCertificate

func CreateCreateCertificateRequest added in v1.61.701

func CreateCreateCertificateRequest() (request *CreateCertificateRequest)

CreateCreateCertificateRequest creates a request to invoke CreateCertificate API

type CreateCertificateResponse added in v1.61.701

type CreateCertificateResponse struct {
	*responses.BaseResponse
	RequestId     string `json:"RequestId" xml:"RequestId"`
	Csr           string `json:"Csr" xml:"Csr"`
	CertificateId string `json:"CertificateId" xml:"CertificateId"`
	Arn           string `json:"Arn" xml:"Arn"`
}

CreateCertificateResponse is the response struct for api CreateCertificate

func CreateCreateCertificateResponse added in v1.61.701

func CreateCreateCertificateResponse() (response *CreateCertificateResponse)

CreateCreateCertificateResponse creates a response to parse from CreateCertificate response

type CreateKeyRequest

type CreateKeyRequest struct {
	*requests.RpcRequest
	ProtectionLevel         string           `position:"Query" name:"ProtectionLevel"`
	KeyUsage                string           `position:"Query" name:"KeyUsage"`
	Origin                  string           `position:"Query" name:"Origin"`
	DKMSInstanceId          string           `position:"Query" name:"DKMSInstanceId"`
	Description             string           `position:"Query" name:"Description"`
	KeySpec                 string           `position:"Query" name:"KeySpec"`
	RotationInterval        string           `position:"Query" name:"RotationInterval"`
	EnableAutomaticRotation requests.Boolean `position:"Query" name:"EnableAutomaticRotation"`
}

CreateKeyRequest is the request struct for api CreateKey

func CreateCreateKeyRequest

func CreateCreateKeyRequest() (request *CreateKeyRequest)

CreateCreateKeyRequest creates a request to invoke CreateKey API

type CreateKeyResponse

type CreateKeyResponse struct {
	*responses.BaseResponse
	RequestId   string      `json:"RequestId" xml:"RequestId"`
	KeyMetadata KeyMetadata `json:"KeyMetadata" xml:"KeyMetadata"`
}

CreateKeyResponse is the response struct for api CreateKey

func CreateCreateKeyResponse

func CreateCreateKeyResponse() (response *CreateKeyResponse)

CreateCreateKeyResponse creates a response to parse from CreateKey response

type CreateKeyVersionRequest added in v1.60.310

type CreateKeyVersionRequest struct {
	*requests.RpcRequest
	KeyId string `position:"Query" name:"KeyId"`
}

CreateKeyVersionRequest is the request struct for api CreateKeyVersion

func CreateCreateKeyVersionRequest added in v1.60.310

func CreateCreateKeyVersionRequest() (request *CreateKeyVersionRequest)

CreateCreateKeyVersionRequest creates a request to invoke CreateKeyVersion API

type CreateKeyVersionResponse added in v1.60.310

type CreateKeyVersionResponse struct {
	*responses.BaseResponse
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	KeyVersion KeyVersion `json:"KeyVersion" xml:"KeyVersion"`
}

CreateKeyVersionResponse is the response struct for api CreateKeyVersion

func CreateCreateKeyVersionResponse added in v1.60.310

func CreateCreateKeyVersionResponse() (response *CreateKeyVersionResponse)

CreateCreateKeyVersionResponse creates a response to parse from CreateKeyVersion response

type CreateSecretRequest added in v1.61.16

type CreateSecretRequest struct {
	*requests.RpcRequest
	SecretType              string           `position:"Query" name:"SecretType"`
	VersionId               string           `position:"Query" name:"VersionId"`
	DKMSInstanceId          string           `position:"Query" name:"DKMSInstanceId"`
	SecretData              string           `position:"Query" name:"SecretData"`
	Description             string           `position:"Query" name:"Description"`
	RotationInterval        string           `position:"Query" name:"RotationInterval"`
	SecretName              string           `position:"Query" name:"SecretName"`
	EnableAutomaticRotation requests.Boolean `position:"Query" name:"EnableAutomaticRotation"`
	EncryptionKeyId         string           `position:"Query" name:"EncryptionKeyId"`
	SecretDataType          string           `position:"Query" name:"SecretDataType"`
	Tags                    string           `position:"Query" name:"Tags"`
	ExtendedConfig          string           `position:"Query" name:"ExtendedConfig"`
}

CreateSecretRequest is the request struct for api CreateSecret

func CreateCreateSecretRequest added in v1.61.16

func CreateCreateSecretRequest() (request *CreateSecretRequest)

CreateCreateSecretRequest creates a request to invoke CreateSecret API

type CreateSecretResponse added in v1.61.16

type CreateSecretResponse struct {
	*responses.BaseResponse
	RequestId         string `json:"RequestId" xml:"RequestId"`
	AutomaticRotation string `json:"AutomaticRotation" xml:"AutomaticRotation"`
	SecretName        string `json:"SecretName" xml:"SecretName"`
	VersionId         string `json:"VersionId" xml:"VersionId"`
	NextRotationDate  string `json:"NextRotationDate" xml:"NextRotationDate"`
	SecretType        string `json:"SecretType" xml:"SecretType"`
	RotationInterval  string `json:"RotationInterval" xml:"RotationInterval"`
	Arn               string `json:"Arn" xml:"Arn"`
	ExtendedConfig    string `json:"ExtendedConfig" xml:"ExtendedConfig"`
	DKMSInstanceId    string `json:"DKMSInstanceId" xml:"DKMSInstanceId"`
}

CreateSecretResponse is the response struct for api CreateSecret

func CreateCreateSecretResponse added in v1.61.16

func CreateCreateSecretResponse() (response *CreateSecretResponse)

CreateCreateSecretResponse creates a response to parse from CreateSecret response

type DecryptRequest

type DecryptRequest struct {
	*requests.RpcRequest
	EncryptionContext string `position:"Query" name:"EncryptionContext"`
	CiphertextBlob    string `position:"Query" name:"CiphertextBlob"`
}

DecryptRequest is the request struct for api Decrypt

func CreateDecryptRequest

func CreateDecryptRequest() (request *DecryptRequest)

CreateDecryptRequest creates a request to invoke Decrypt API

type DecryptResponse

type DecryptResponse struct {
	*responses.BaseResponse
	KeyVersionId string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId        string `json:"KeyId" xml:"KeyId"`
	RequestId    string `json:"RequestId" xml:"RequestId"`
	Plaintext    string `json:"Plaintext" xml:"Plaintext"`
}

DecryptResponse is the response struct for api Decrypt

func CreateDecryptResponse

func CreateDecryptResponse() (response *DecryptResponse)

CreateDecryptResponse creates a response to parse from Decrypt response

type DeleteAliasRequest

type DeleteAliasRequest struct {
	*requests.RpcRequest
	AliasName string `position:"Query" name:"AliasName"`
}

DeleteAliasRequest is the request struct for api DeleteAlias

func CreateDeleteAliasRequest

func CreateDeleteAliasRequest() (request *DeleteAliasRequest)

CreateDeleteAliasRequest creates a request to invoke DeleteAlias API

type DeleteAliasResponse

type DeleteAliasResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteAliasResponse is the response struct for api DeleteAlias

func CreateDeleteAliasResponse

func CreateDeleteAliasResponse() (response *DeleteAliasResponse)

CreateDeleteAliasResponse creates a response to parse from DeleteAlias response

type DeleteCertificateRequest added in v1.61.701

type DeleteCertificateRequest struct {
	*requests.RpcRequest
	CertificateId string `position:"Query" name:"CertificateId"`
}

DeleteCertificateRequest is the request struct for api DeleteCertificate

func CreateDeleteCertificateRequest added in v1.61.701

func CreateDeleteCertificateRequest() (request *DeleteCertificateRequest)

CreateDeleteCertificateRequest creates a request to invoke DeleteCertificate API

type DeleteCertificateResponse added in v1.61.701

type DeleteCertificateResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteCertificateResponse is the response struct for api DeleteCertificate

func CreateDeleteCertificateResponse added in v1.61.701

func CreateDeleteCertificateResponse() (response *DeleteCertificateResponse)

CreateDeleteCertificateResponse creates a response to parse from DeleteCertificate response

type DeleteKeyMaterialRequest

type DeleteKeyMaterialRequest struct {
	*requests.RpcRequest
	KeyId string `position:"Query" name:"KeyId"`
}

DeleteKeyMaterialRequest is the request struct for api DeleteKeyMaterial

func CreateDeleteKeyMaterialRequest

func CreateDeleteKeyMaterialRequest() (request *DeleteKeyMaterialRequest)

CreateDeleteKeyMaterialRequest creates a request to invoke DeleteKeyMaterial API

type DeleteKeyMaterialResponse

type DeleteKeyMaterialResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteKeyMaterialResponse is the response struct for api DeleteKeyMaterial

func CreateDeleteKeyMaterialResponse

func CreateDeleteKeyMaterialResponse() (response *DeleteKeyMaterialResponse)

CreateDeleteKeyMaterialResponse creates a response to parse from DeleteKeyMaterial response

type DeleteSecretRequest added in v1.61.16

type DeleteSecretRequest struct {
	*requests.RpcRequest
	ForceDeleteWithoutRecovery string `position:"Query" name:"ForceDeleteWithoutRecovery"`
	RecoveryWindowInDays       string `position:"Query" name:"RecoveryWindowInDays"`
	SecretName                 string `position:"Query" name:"SecretName"`
}

DeleteSecretRequest is the request struct for api DeleteSecret

func CreateDeleteSecretRequest added in v1.61.16

func CreateDeleteSecretRequest() (request *DeleteSecretRequest)

CreateDeleteSecretRequest creates a request to invoke DeleteSecret API

type DeleteSecretResponse added in v1.61.16

type DeleteSecretResponse struct {
	*responses.BaseResponse
	SecretName        string `json:"SecretName" xml:"SecretName"`
	RequestId         string `json:"RequestId" xml:"RequestId"`
	PlannedDeleteTime string `json:"PlannedDeleteTime" xml:"PlannedDeleteTime"`
}

DeleteSecretResponse is the response struct for api DeleteSecret

func CreateDeleteSecretResponse added in v1.61.16

func CreateDeleteSecretResponse() (response *DeleteSecretResponse)

CreateDeleteSecretResponse creates a response to parse from DeleteSecret response

type DescribeAccountKmsStatusRequest added in v1.61.535

type DescribeAccountKmsStatusRequest struct {
	*requests.RpcRequest
}

DescribeAccountKmsStatusRequest is the request struct for api DescribeAccountKmsStatus

func CreateDescribeAccountKmsStatusRequest added in v1.61.535

func CreateDescribeAccountKmsStatusRequest() (request *DescribeAccountKmsStatusRequest)

CreateDescribeAccountKmsStatusRequest creates a request to invoke DescribeAccountKmsStatus API

type DescribeAccountKmsStatusResponse added in v1.61.535

type DescribeAccountKmsStatusResponse struct {
	*responses.BaseResponse
	AccountStatus string `json:"AccountStatus" xml:"AccountStatus"`
	RequestId     string `json:"RequestId" xml:"RequestId"`
}

DescribeAccountKmsStatusResponse is the response struct for api DescribeAccountKmsStatus

func CreateDescribeAccountKmsStatusResponse added in v1.61.535

func CreateDescribeAccountKmsStatusResponse() (response *DescribeAccountKmsStatusResponse)

CreateDescribeAccountKmsStatusResponse creates a response to parse from DescribeAccountKmsStatus response

type DescribeCertificateRequest added in v1.61.701

type DescribeCertificateRequest struct {
	*requests.RpcRequest
	CertificateId string `position:"Query" name:"CertificateId"`
}

DescribeCertificateRequest is the request struct for api DescribeCertificate

func CreateDescribeCertificateRequest added in v1.61.701

func CreateDescribeCertificateRequest() (request *DescribeCertificateRequest)

CreateDescribeCertificateRequest creates a request to invoke DescribeCertificate API

type DescribeCertificateResponse added in v1.61.701

type DescribeCertificateResponse struct {
	*responses.BaseResponse
	Status                  string                 `json:"Status" xml:"Status"`
	Serial                  string                 `json:"Serial" xml:"Serial"`
	CreatedAt               string                 `json:"CreatedAt" xml:"CreatedAt"`
	Tags                    map[string]interface{} `json:"Tags" xml:"Tags"`
	SubjectKeyIdentifier    string                 `json:"SubjectKeyIdentifier" xml:"SubjectKeyIdentifier"`
	ExportablePrivateKey    bool                   `json:"ExportablePrivateKey" xml:"ExportablePrivateKey"`
	Issuer                  string                 `json:"Issuer" xml:"Issuer"`
	SignatureAlgorithm      string                 `json:"SignatureAlgorithm" xml:"SignatureAlgorithm"`
	NotAfter                string                 `json:"NotAfter" xml:"NotAfter"`
	Arn                     string                 `json:"Arn" xml:"Arn"`
	CertificateId           string                 `json:"CertificateId" xml:"CertificateId"`
	RequestId               string                 `json:"RequestId" xml:"RequestId"`
	KeySpec                 string                 `json:"KeySpec" xml:"KeySpec"`
	ProtectionLevel         string                 `json:"ProtectionLevel" xml:"ProtectionLevel"`
	SubjectPublicKey        string                 `json:"SubjectPublicKey" xml:"SubjectPublicKey"`
	Subject                 string                 `json:"Subject" xml:"Subject"`
	NotBefore               string                 `json:"NotBefore" xml:"NotBefore"`
	UpdatedAt               string                 `json:"UpdatedAt" xml:"UpdatedAt"`
	SubjectAlternativeNames []string               `json:"SubjectAlternativeNames" xml:"SubjectAlternativeNames"`
}

DescribeCertificateResponse is the response struct for api DescribeCertificate

func CreateDescribeCertificateResponse added in v1.61.701

func CreateDescribeCertificateResponse() (response *DescribeCertificateResponse)

CreateDescribeCertificateResponse creates a response to parse from DescribeCertificate response

type DescribeKeyRequest

type DescribeKeyRequest struct {
	*requests.RpcRequest
	KeyId string `position:"Query" name:"KeyId"`
}

DescribeKeyRequest is the request struct for api DescribeKey

func CreateDescribeKeyRequest

func CreateDescribeKeyRequest() (request *DescribeKeyRequest)

CreateDescribeKeyRequest creates a request to invoke DescribeKey API

type DescribeKeyResponse

type DescribeKeyResponse struct {
	*responses.BaseResponse
	RequestId   string      `json:"RequestId" xml:"RequestId"`
	KeyMetadata KeyMetadata `json:"KeyMetadata" xml:"KeyMetadata"`
}

DescribeKeyResponse is the response struct for api DescribeKey

func CreateDescribeKeyResponse

func CreateDescribeKeyResponse() (response *DescribeKeyResponse)

CreateDescribeKeyResponse creates a response to parse from DescribeKey response

type DescribeKeyVersionRequest

type DescribeKeyVersionRequest struct {
	*requests.RpcRequest
	KeyVersionId string `position:"Query" name:"KeyVersionId"`
	KeyId        string `position:"Query" name:"KeyId"`
}

DescribeKeyVersionRequest is the request struct for api DescribeKeyVersion

func CreateDescribeKeyVersionRequest

func CreateDescribeKeyVersionRequest() (request *DescribeKeyVersionRequest)

CreateDescribeKeyVersionRequest creates a request to invoke DescribeKeyVersion API

type DescribeKeyVersionResponse

type DescribeKeyVersionResponse struct {
	*responses.BaseResponse
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	KeyVersion KeyVersion `json:"KeyVersion" xml:"KeyVersion"`
}

DescribeKeyVersionResponse is the response struct for api DescribeKeyVersion

func CreateDescribeKeyVersionResponse

func CreateDescribeKeyVersionResponse() (response *DescribeKeyVersionResponse)

CreateDescribeKeyVersionResponse creates a response to parse from DescribeKeyVersion response

type DescribeRegionsRequest

type DescribeRegionsRequest struct {
	*requests.RpcRequest
}

DescribeRegionsRequest is the request struct for api DescribeRegions

func CreateDescribeRegionsRequest

func CreateDescribeRegionsRequest() (request *DescribeRegionsRequest)

CreateDescribeRegionsRequest creates a request to invoke DescribeRegions API

type DescribeRegionsResponse

type DescribeRegionsResponse struct {
	*responses.BaseResponse
	RequestId string  `json:"RequestId" xml:"RequestId"`
	Regions   Regions `json:"Regions" xml:"Regions"`
}

DescribeRegionsResponse is the response struct for api DescribeRegions

func CreateDescribeRegionsResponse

func CreateDescribeRegionsResponse() (response *DescribeRegionsResponse)

CreateDescribeRegionsResponse creates a response to parse from DescribeRegions response

type DescribeSecretRequest added in v1.61.16

type DescribeSecretRequest struct {
	*requests.RpcRequest
	SecretName string `position:"Query" name:"SecretName"`
	FetchTags  string `position:"Query" name:"FetchTags"`
}

DescribeSecretRequest is the request struct for api DescribeSecret

func CreateDescribeSecretRequest added in v1.61.16

func CreateDescribeSecretRequest() (request *DescribeSecretRequest)

CreateDescribeSecretRequest creates a request to invoke DescribeSecret API

type DescribeSecretResponse added in v1.61.16

type DescribeSecretResponse struct {
	*responses.BaseResponse
	UpdateTime        string               `json:"UpdateTime" xml:"UpdateTime"`
	CreateTime        string               `json:"CreateTime" xml:"CreateTime"`
	NextRotationDate  string               `json:"NextRotationDate" xml:"NextRotationDate"`
	EncryptionKeyId   string               `json:"EncryptionKeyId" xml:"EncryptionKeyId"`
	RotationInterval  string               `json:"RotationInterval" xml:"RotationInterval"`
	Arn               string               `json:"Arn" xml:"Arn"`
	ExtendedConfig    string               `json:"ExtendedConfig" xml:"ExtendedConfig"`
	LastRotationDate  string               `json:"LastRotationDate" xml:"LastRotationDate"`
	RequestId         string               `json:"RequestId" xml:"RequestId"`
	Description       string               `json:"Description" xml:"Description"`
	SecretName        string               `json:"SecretName" xml:"SecretName"`
	AutomaticRotation string               `json:"AutomaticRotation" xml:"AutomaticRotation"`
	SecretType        string               `json:"SecretType" xml:"SecretType"`
	PlannedDeleteTime string               `json:"PlannedDeleteTime" xml:"PlannedDeleteTime"`
	DKMSInstanceId    string               `json:"DKMSInstanceId" xml:"DKMSInstanceId"`
	Tags              TagsInDescribeSecret `json:"Tags" xml:"Tags"`
}

DescribeSecretResponse is the response struct for api DescribeSecret

func CreateDescribeSecretResponse added in v1.61.16

func CreateDescribeSecretResponse() (response *DescribeSecretResponse)

CreateDescribeSecretResponse creates a response to parse from DescribeSecret response

type DisableKeyRequest

type DisableKeyRequest struct {
	*requests.RpcRequest
	KeyId string `position:"Query" name:"KeyId"`
}

DisableKeyRequest is the request struct for api DisableKey

func CreateDisableKeyRequest

func CreateDisableKeyRequest() (request *DisableKeyRequest)

CreateDisableKeyRequest creates a request to invoke DisableKey API

type DisableKeyResponse

type DisableKeyResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DisableKeyResponse is the response struct for api DisableKey

func CreateDisableKeyResponse

func CreateDisableKeyResponse() (response *DisableKeyResponse)

CreateDisableKeyResponse creates a response to parse from DisableKey response

type EnableKeyRequest

type EnableKeyRequest struct {
	*requests.RpcRequest
	KeyId string `position:"Query" name:"KeyId"`
}

EnableKeyRequest is the request struct for api EnableKey

func CreateEnableKeyRequest

func CreateEnableKeyRequest() (request *EnableKeyRequest)

CreateEnableKeyRequest creates a request to invoke EnableKey API

type EnableKeyResponse

type EnableKeyResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

EnableKeyResponse is the response struct for api EnableKey

func CreateEnableKeyResponse

func CreateEnableKeyResponse() (response *EnableKeyResponse)

CreateEnableKeyResponse creates a response to parse from EnableKey response

type EncryptRequest

type EncryptRequest struct {
	*requests.RpcRequest
	EncryptionContext string `position:"Query" name:"EncryptionContext"`
	KeyId             string `position:"Query" name:"KeyId"`
	Plaintext         string `position:"Query" name:"Plaintext"`
}

EncryptRequest is the request struct for api Encrypt

func CreateEncryptRequest

func CreateEncryptRequest() (request *EncryptRequest)

CreateEncryptRequest creates a request to invoke Encrypt API

type EncryptResponse

type EncryptResponse struct {
	*responses.BaseResponse
	KeyVersionId   string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId          string `json:"KeyId" xml:"KeyId"`
	CiphertextBlob string `json:"CiphertextBlob" xml:"CiphertextBlob"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
}

EncryptResponse is the response struct for api Encrypt

func CreateEncryptResponse

func CreateEncryptResponse() (response *EncryptResponse)

CreateEncryptResponse creates a response to parse from Encrypt response

type ExportDataKeyRequest added in v1.61.342

type ExportDataKeyRequest struct {
	*requests.RpcRequest
	EncryptionContext string `position:"Query" name:"EncryptionContext"`
	WrappingAlgorithm string `position:"Query" name:"WrappingAlgorithm"`
	CiphertextBlob    string `position:"Query" name:"CiphertextBlob"`
	PublicKeyBlob     string `position:"Query" name:"PublicKeyBlob"`
	WrappingKeySpec   string `position:"Query" name:"WrappingKeySpec"`
}

ExportDataKeyRequest is the request struct for api ExportDataKey

func CreateExportDataKeyRequest added in v1.61.342

func CreateExportDataKeyRequest() (request *ExportDataKeyRequest)

CreateExportDataKeyRequest creates a request to invoke ExportDataKey API

type ExportDataKeyResponse added in v1.61.342

type ExportDataKeyResponse struct {
	*responses.BaseResponse
	KeyVersionId    string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId           string `json:"KeyId" xml:"KeyId"`
	RequestId       string `json:"RequestId" xml:"RequestId"`
	ExportedDataKey string `json:"ExportedDataKey" xml:"ExportedDataKey"`
}

ExportDataKeyResponse is the response struct for api ExportDataKey

func CreateExportDataKeyResponse added in v1.61.342

func CreateExportDataKeyResponse() (response *ExportDataKeyResponse)

CreateExportDataKeyResponse creates a response to parse from ExportDataKey response

type GenerateAndExportDataKeyRequest added in v1.61.342

type GenerateAndExportDataKeyRequest struct {
	*requests.RpcRequest
	EncryptionContext string           `position:"Query" name:"EncryptionContext"`
	KeyId             string           `position:"Query" name:"KeyId"`
	KeySpec           string           `position:"Query" name:"KeySpec"`
	NumberOfBytes     requests.Integer `position:"Query" name:"NumberOfBytes"`
	WrappingAlgorithm string           `position:"Query" name:"WrappingAlgorithm"`
	PublicKeyBlob     string           `position:"Query" name:"PublicKeyBlob"`
	WrappingKeySpec   string           `position:"Query" name:"WrappingKeySpec"`
}

GenerateAndExportDataKeyRequest is the request struct for api GenerateAndExportDataKey

func CreateGenerateAndExportDataKeyRequest added in v1.61.342

func CreateGenerateAndExportDataKeyRequest() (request *GenerateAndExportDataKeyRequest)

CreateGenerateAndExportDataKeyRequest creates a request to invoke GenerateAndExportDataKey API

type GenerateAndExportDataKeyResponse added in v1.61.342

type GenerateAndExportDataKeyResponse struct {
	*responses.BaseResponse
	KeyVersionId    string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId           string `json:"KeyId" xml:"KeyId"`
	CiphertextBlob  string `json:"CiphertextBlob" xml:"CiphertextBlob"`
	RequestId       string `json:"RequestId" xml:"RequestId"`
	ExportedDataKey string `json:"ExportedDataKey" xml:"ExportedDataKey"`
}

GenerateAndExportDataKeyResponse is the response struct for api GenerateAndExportDataKey

func CreateGenerateAndExportDataKeyResponse added in v1.61.342

func CreateGenerateAndExportDataKeyResponse() (response *GenerateAndExportDataKeyResponse)

CreateGenerateAndExportDataKeyResponse creates a response to parse from GenerateAndExportDataKey response

type GenerateDataKeyRequest

type GenerateDataKeyRequest struct {
	*requests.RpcRequest
	EncryptionContext string           `position:"Query" name:"EncryptionContext"`
	KeyId             string           `position:"Query" name:"KeyId"`
	KeySpec           string           `position:"Query" name:"KeySpec"`
	NumberOfBytes     requests.Integer `position:"Query" name:"NumberOfBytes"`
}

GenerateDataKeyRequest is the request struct for api GenerateDataKey

func CreateGenerateDataKeyRequest

func CreateGenerateDataKeyRequest() (request *GenerateDataKeyRequest)

CreateGenerateDataKeyRequest creates a request to invoke GenerateDataKey API

type GenerateDataKeyResponse

type GenerateDataKeyResponse struct {
	*responses.BaseResponse
	KeyVersionId   string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId          string `json:"KeyId" xml:"KeyId"`
	CiphertextBlob string `json:"CiphertextBlob" xml:"CiphertextBlob"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Plaintext      string `json:"Plaintext" xml:"Plaintext"`
}

GenerateDataKeyResponse is the response struct for api GenerateDataKey

func CreateGenerateDataKeyResponse

func CreateGenerateDataKeyResponse() (response *GenerateDataKeyResponse)

CreateGenerateDataKeyResponse creates a response to parse from GenerateDataKey response

type GenerateDataKeyWithoutPlaintextRequest

type GenerateDataKeyWithoutPlaintextRequest struct {
	*requests.RpcRequest
	EncryptionContext string           `position:"Query" name:"EncryptionContext"`
	KeyId             string           `position:"Query" name:"KeyId"`
	KeySpec           string           `position:"Query" name:"KeySpec"`
	NumberOfBytes     requests.Integer `position:"Query" name:"NumberOfBytes"`
}

GenerateDataKeyWithoutPlaintextRequest is the request struct for api GenerateDataKeyWithoutPlaintext

func CreateGenerateDataKeyWithoutPlaintextRequest

func CreateGenerateDataKeyWithoutPlaintextRequest() (request *GenerateDataKeyWithoutPlaintextRequest)

CreateGenerateDataKeyWithoutPlaintextRequest creates a request to invoke GenerateDataKeyWithoutPlaintext API

type GenerateDataKeyWithoutPlaintextResponse

type GenerateDataKeyWithoutPlaintextResponse struct {
	*responses.BaseResponse
	KeyVersionId   string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId          string `json:"KeyId" xml:"KeyId"`
	CiphertextBlob string `json:"CiphertextBlob" xml:"CiphertextBlob"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
}

GenerateDataKeyWithoutPlaintextResponse is the response struct for api GenerateDataKeyWithoutPlaintext

func CreateGenerateDataKeyWithoutPlaintextResponse

func CreateGenerateDataKeyWithoutPlaintextResponse() (response *GenerateDataKeyWithoutPlaintextResponse)

CreateGenerateDataKeyWithoutPlaintextResponse creates a response to parse from GenerateDataKeyWithoutPlaintext response

type GetCertificateRequest added in v1.61.701

type GetCertificateRequest struct {
	*requests.RpcRequest
	CertificateId string `position:"Query" name:"CertificateId"`
}

GetCertificateRequest is the request struct for api GetCertificate

func CreateGetCertificateRequest added in v1.61.701

func CreateGetCertificateRequest() (request *GetCertificateRequest)

CreateGetCertificateRequest creates a request to invoke GetCertificate API

type GetCertificateResponse added in v1.61.701

type GetCertificateResponse struct {
	*responses.BaseResponse
	CertificateChain string `json:"CertificateChain" xml:"CertificateChain"`
	Certificate      string `json:"Certificate" xml:"Certificate"`
	RequestId        string `json:"RequestId" xml:"RequestId"`
	CertificateId    string `json:"CertificateId" xml:"CertificateId"`
	Csr              string `json:"Csr" xml:"Csr"`
}

GetCertificateResponse is the response struct for api GetCertificate

func CreateGetCertificateResponse added in v1.61.701

func CreateGetCertificateResponse() (response *GetCertificateResponse)

CreateGetCertificateResponse creates a response to parse from GetCertificate response

type GetParametersForImportRequest

type GetParametersForImportRequest struct {
	*requests.RpcRequest
	KeyId             string `position:"Query" name:"KeyId"`
	WrappingAlgorithm string `position:"Query" name:"WrappingAlgorithm"`
	WrappingKeySpec   string `position:"Query" name:"WrappingKeySpec"`
}

GetParametersForImportRequest is the request struct for api GetParametersForImport

func CreateGetParametersForImportRequest

func CreateGetParametersForImportRequest() (request *GetParametersForImportRequest)

CreateGetParametersForImportRequest creates a request to invoke GetParametersForImport API

type GetParametersForImportResponse

type GetParametersForImportResponse struct {
	*responses.BaseResponse
	KeyId           string `json:"KeyId" xml:"KeyId"`
	ImportToken     string `json:"ImportToken" xml:"ImportToken"`
	RequestId       string `json:"RequestId" xml:"RequestId"`
	TokenExpireTime string `json:"TokenExpireTime" xml:"TokenExpireTime"`
	PublicKey       string `json:"PublicKey" xml:"PublicKey"`
}

GetParametersForImportResponse is the response struct for api GetParametersForImport

func CreateGetParametersForImportResponse

func CreateGetParametersForImportResponse() (response *GetParametersForImportResponse)

CreateGetParametersForImportResponse creates a response to parse from GetParametersForImport response

type GetPublicKeyRequest added in v1.60.310

type GetPublicKeyRequest struct {
	*requests.RpcRequest
	KeyVersionId string `position:"Query" name:"KeyVersionId"`
	KeyId        string `position:"Query" name:"KeyId"`
}

GetPublicKeyRequest is the request struct for api GetPublicKey

func CreateGetPublicKeyRequest added in v1.60.310

func CreateGetPublicKeyRequest() (request *GetPublicKeyRequest)

CreateGetPublicKeyRequest creates a request to invoke GetPublicKey API

type GetPublicKeyResponse added in v1.60.310

type GetPublicKeyResponse struct {
	*responses.BaseResponse
	KeyVersionId string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId        string `json:"KeyId" xml:"KeyId"`
	RequestId    string `json:"RequestId" xml:"RequestId"`
	PublicKey    string `json:"PublicKey" xml:"PublicKey"`
}

GetPublicKeyResponse is the response struct for api GetPublicKey

func CreateGetPublicKeyResponse added in v1.60.310

func CreateGetPublicKeyResponse() (response *GetPublicKeyResponse)

CreateGetPublicKeyResponse creates a response to parse from GetPublicKey response

type GetRandomPasswordRequest added in v1.61.16

type GetRandomPasswordRequest struct {
	*requests.RpcRequest
	ExcludeLowercase        string `position:"Query" name:"ExcludeLowercase"`
	ExcludeCharacters       string `position:"Query" name:"ExcludeCharacters"`
	PasswordLength          string `position:"Query" name:"PasswordLength"`
	ExcludePunctuation      string `position:"Query" name:"ExcludePunctuation"`
	ExcludeUppercase        string `position:"Query" name:"ExcludeUppercase"`
	RequireEachIncludedType string `position:"Query" name:"RequireEachIncludedType"`
	ExcludeNumbers          string `position:"Query" name:"ExcludeNumbers"`
}

GetRandomPasswordRequest is the request struct for api GetRandomPassword

func CreateGetRandomPasswordRequest added in v1.61.16

func CreateGetRandomPasswordRequest() (request *GetRandomPasswordRequest)

CreateGetRandomPasswordRequest creates a request to invoke GetRandomPassword API

type GetRandomPasswordResponse added in v1.61.16

type GetRandomPasswordResponse struct {
	*responses.BaseResponse
	RandomPassword string `json:"RandomPassword" xml:"RandomPassword"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
}

GetRandomPasswordResponse is the response struct for api GetRandomPassword

func CreateGetRandomPasswordResponse added in v1.61.16

func CreateGetRandomPasswordResponse() (response *GetRandomPasswordResponse)

CreateGetRandomPasswordResponse creates a response to parse from GetRandomPassword response

type GetSecretValueRequest added in v1.61.16

type GetSecretValueRequest struct {
	*requests.RpcRequest
	VersionId           string           `position:"Query" name:"VersionId"`
	VersionStage        string           `position:"Query" name:"VersionStage"`
	SecretName          string           `position:"Query" name:"SecretName"`
	FetchExtendedConfig requests.Boolean `position:"Query" name:"FetchExtendedConfig"`
}

GetSecretValueRequest is the request struct for api GetSecretValue

func CreateGetSecretValueRequest added in v1.61.16

func CreateGetSecretValueRequest() (request *GetSecretValueRequest)

CreateGetSecretValueRequest creates a request to invoke GetSecretValue API

type GetSecretValueResponse added in v1.61.16

type GetSecretValueResponse struct {
	*responses.BaseResponse
	SecretDataType    string                        `json:"SecretDataType" xml:"SecretDataType"`
	CreateTime        string                        `json:"CreateTime" xml:"CreateTime"`
	VersionId         string                        `json:"VersionId" xml:"VersionId"`
	NextRotationDate  string                        `json:"NextRotationDate" xml:"NextRotationDate"`
	SecretData        string                        `json:"SecretData" xml:"SecretData"`
	RotationInterval  string                        `json:"RotationInterval" xml:"RotationInterval"`
	ExtendedConfig    string                        `json:"ExtendedConfig" xml:"ExtendedConfig"`
	LastRotationDate  string                        `json:"LastRotationDate" xml:"LastRotationDate"`
	RequestId         string                        `json:"RequestId" xml:"RequestId"`
	SecretName        string                        `json:"SecretName" xml:"SecretName"`
	AutomaticRotation string                        `json:"AutomaticRotation" xml:"AutomaticRotation"`
	SecretType        string                        `json:"SecretType" xml:"SecretType"`
	VersionStages     VersionStagesInGetSecretValue `json:"VersionStages" xml:"VersionStages"`
}

GetSecretValueResponse is the response struct for api GetSecretValue

func CreateGetSecretValueResponse added in v1.61.16

func CreateGetSecretValueResponse() (response *GetSecretValueResponse)

CreateGetSecretValueResponse creates a response to parse from GetSecretValue response

type ImportKeyMaterialRequest

type ImportKeyMaterialRequest struct {
	*requests.RpcRequest
	ImportToken           string           `position:"Query" name:"ImportToken"`
	EncryptedKeyMaterial  string           `position:"Query" name:"EncryptedKeyMaterial"`
	KeyMaterialExpireUnix requests.Integer `position:"Query" name:"KeyMaterialExpireUnix"`
	KeyId                 string           `position:"Query" name:"KeyId"`
}

ImportKeyMaterialRequest is the request struct for api ImportKeyMaterial

func CreateImportKeyMaterialRequest

func CreateImportKeyMaterialRequest() (request *ImportKeyMaterialRequest)

CreateImportKeyMaterialRequest creates a request to invoke ImportKeyMaterial API

type ImportKeyMaterialResponse

type ImportKeyMaterialResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

ImportKeyMaterialResponse is the response struct for api ImportKeyMaterial

func CreateImportKeyMaterialResponse

func CreateImportKeyMaterialResponse() (response *ImportKeyMaterialResponse)

CreateImportKeyMaterialResponse creates a response to parse from ImportKeyMaterial response

type Key

type Key struct {
	KeyId  string `json:"KeyId" xml:"KeyId"`
	KeyArn string `json:"KeyArn" xml:"KeyArn"`
}

Key is a nested struct in kms response

type KeyMetadata

type KeyMetadata struct {
	NextRotationDate              string `json:"NextRotationDate" xml:"NextRotationDate"`
	ProtectionLevel               string `json:"ProtectionLevel" xml:"ProtectionLevel"`
	KeySpec                       string `json:"KeySpec" xml:"KeySpec"`
	DeleteDate                    string `json:"DeleteDate" xml:"DeleteDate"`
	KeyUsage                      string `json:"KeyUsage" xml:"KeyUsage"`
	AutomaticRotation             string `json:"AutomaticRotation" xml:"AutomaticRotation"`
	DKMSInstanceId                string `json:"DKMSInstanceId" xml:"DKMSInstanceId"`
	LastRotationDate              string `json:"LastRotationDate" xml:"LastRotationDate"`
	RotationInterval              string `json:"RotationInterval" xml:"RotationInterval"`
	MaterialExpireTime            string `json:"MaterialExpireTime" xml:"MaterialExpireTime"`
	PrimaryKeyVersion             string `json:"PrimaryKeyVersion" xml:"PrimaryKeyVersion"`
	DeletionProtection            string `json:"DeletionProtection" xml:"DeletionProtection"`
	Arn                           string `json:"Arn" xml:"Arn"`
	KeyState                      string `json:"KeyState" xml:"KeyState"`
	CreationDate                  string `json:"CreationDate" xml:"CreationDate"`
	Creator                       string `json:"Creator" xml:"Creator"`
	Origin                        string `json:"Origin" xml:"Origin"`
	KeyId                         string `json:"KeyId" xml:"KeyId"`
	Description                   string `json:"Description" xml:"Description"`
	DeletionProtectionDescription string `json:"DeletionProtectionDescription" xml:"DeletionProtectionDescription"`
}

KeyMetadata is a nested struct in kms response

type KeyVersion

type KeyVersion struct {
	CreationDate string `json:"CreationDate" xml:"CreationDate"`
	KeyVersionId string `json:"KeyVersionId" xml:"KeyVersionId"`
	KeyId        string `json:"KeyId" xml:"KeyId"`
}

KeyVersion is a nested struct in kms response

type KeyVersions

type KeyVersions struct {
	KeyVersion []KeyVersion `json:"KeyVersion" xml:"KeyVersion"`
}

KeyVersions is a nested struct in kms response

type Keys

type Keys struct {
	Key []Key `json:"Key" xml:"Key"`
}

Keys is a nested struct in kms response

type ListAliasesByKeyIdRequest

type ListAliasesByKeyIdRequest struct {
	*requests.RpcRequest
	PageSize   requests.Integer `position:"Query" name:"PageSize"`
	KeyId      string           `position:"Query" name:"KeyId"`
	PageNumber requests.Integer `position:"Query" name:"PageNumber"`
}

ListAliasesByKeyIdRequest is the request struct for api ListAliasesByKeyId

func CreateListAliasesByKeyIdRequest

func CreateListAliasesByKeyIdRequest() (request *ListAliasesByKeyIdRequest)

CreateListAliasesByKeyIdRequest creates a request to invoke ListAliasesByKeyId API

type ListAliasesByKeyIdResponse

type ListAliasesByKeyIdResponse struct {
	*responses.BaseResponse
	RequestId  string                      `json:"RequestId" xml:"RequestId"`
	PageNumber int                         `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                         `json:"PageSize" xml:"PageSize"`
	TotalCount int                         `json:"TotalCount" xml:"TotalCount"`
	Aliases    AliasesInListAliasesByKeyId `json:"Aliases" xml:"Aliases"`
}

ListAliasesByKeyIdResponse is the response struct for api ListAliasesByKeyId

func CreateListAliasesByKeyIdResponse

func CreateListAliasesByKeyIdResponse() (response *ListAliasesByKeyIdResponse)

CreateListAliasesByKeyIdResponse creates a response to parse from ListAliasesByKeyId response

type ListAliasesRequest

type ListAliasesRequest struct {
	*requests.RpcRequest
	PageSize   requests.Integer `position:"Query" name:"PageSize"`
	PageNumber requests.Integer `position:"Query" name:"PageNumber"`
}

ListAliasesRequest is the request struct for api ListAliases

func CreateListAliasesRequest

func CreateListAliasesRequest() (request *ListAliasesRequest)

CreateListAliasesRequest creates a request to invoke ListAliases API

type ListAliasesResponse

type ListAliasesResponse struct {
	*responses.BaseResponse
	RequestId  string               `json:"RequestId" xml:"RequestId"`
	PageNumber int                  `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                  `json:"PageSize" xml:"PageSize"`
	TotalCount int                  `json:"TotalCount" xml:"TotalCount"`
	Aliases    AliasesInListAliases `json:"Aliases" xml:"Aliases"`
}

ListAliasesResponse is the response struct for api ListAliases

func CreateListAliasesResponse

func CreateListAliasesResponse() (response *ListAliasesResponse)

CreateListAliasesResponse creates a response to parse from ListAliases response

type ListKeyVersionsRequest

type ListKeyVersionsRequest struct {
	*requests.RpcRequest
	PageSize   requests.Integer `position:"Query" name:"PageSize"`
	KeyId      string           `position:"Query" name:"KeyId"`
	PageNumber requests.Integer `position:"Query" name:"PageNumber"`
}

ListKeyVersionsRequest is the request struct for api ListKeyVersions

func CreateListKeyVersionsRequest

func CreateListKeyVersionsRequest() (request *ListKeyVersionsRequest)

CreateListKeyVersionsRequest creates a request to invoke ListKeyVersions API

type ListKeyVersionsResponse

type ListKeyVersionsResponse struct {
	*responses.BaseResponse
	PageSize    int         `json:"PageSize" xml:"PageSize"`
	RequestId   string      `json:"RequestId" xml:"RequestId"`
	PageNumber  int         `json:"PageNumber" xml:"PageNumber"`
	TotalCount  int         `json:"TotalCount" xml:"TotalCount"`
	KeyVersions KeyVersions `json:"KeyVersions" xml:"KeyVersions"`
}

ListKeyVersionsResponse is the response struct for api ListKeyVersions

func CreateListKeyVersionsResponse

func CreateListKeyVersionsResponse() (response *ListKeyVersionsResponse)

CreateListKeyVersionsResponse creates a response to parse from ListKeyVersions response

type ListKeysRequest

type ListKeysRequest struct {
	*requests.RpcRequest
	PageSize   requests.Integer `position:"Query" name:"PageSize"`
	Filters    string           `position:"Query" name:"Filters"`
	PageNumber requests.Integer `position:"Query" name:"PageNumber"`
}

ListKeysRequest is the request struct for api ListKeys

func CreateListKeysRequest

func CreateListKeysRequest() (request *ListKeysRequest)

CreateListKeysRequest creates a request to invoke ListKeys API

type ListKeysResponse

type ListKeysResponse struct {
	*responses.BaseResponse
	PageNumber int    `json:"PageNumber" xml:"PageNumber"`
	PageSize   int    `json:"PageSize" xml:"PageSize"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
	TotalCount int    `json:"TotalCount" xml:"TotalCount"`
	Keys       Keys   `json:"Keys" xml:"Keys"`
}

ListKeysResponse is the response struct for api ListKeys

func CreateListKeysResponse

func CreateListKeysResponse() (response *ListKeysResponse)

CreateListKeysResponse creates a response to parse from ListKeys response

type ListResourceTagsRequest

type ListResourceTagsRequest struct {
	*requests.RpcRequest
	KeyId string `position:"Query" name:"KeyId"`
}

ListResourceTagsRequest is the request struct for api ListResourceTags

func CreateListResourceTagsRequest

func CreateListResourceTagsRequest() (request *ListResourceTagsRequest)

CreateListResourceTagsRequest creates a request to invoke ListResourceTags API

type ListResourceTagsResponse

type ListResourceTagsResponse struct {
	*responses.BaseResponse
	RequestId string                 `json:"RequestId" xml:"RequestId"`
	Tags      TagsInListResourceTags `json:"Tags" xml:"Tags"`
}

ListResourceTagsResponse is the response struct for api ListResourceTags

func CreateListResourceTagsResponse

func CreateListResourceTagsResponse() (response *ListResourceTagsResponse)

CreateListResourceTagsResponse creates a response to parse from ListResourceTags response

type ListSecretVersionIdsRequest added in v1.61.16

type ListSecretVersionIdsRequest struct {
	*requests.RpcRequest
	IncludeDeprecated string           `position:"Query" name:"IncludeDeprecated"`
	PageSize          requests.Integer `position:"Query" name:"PageSize"`
	SecretName        string           `position:"Query" name:"SecretName"`
	PageNumber        requests.Integer `position:"Query" name:"PageNumber"`
}

ListSecretVersionIdsRequest is the request struct for api ListSecretVersionIds

func CreateListSecretVersionIdsRequest added in v1.61.16

func CreateListSecretVersionIdsRequest() (request *ListSecretVersionIdsRequest)

CreateListSecretVersionIdsRequest creates a request to invoke ListSecretVersionIds API

type ListSecretVersionIdsResponse added in v1.61.16

type ListSecretVersionIdsResponse struct {
	*responses.BaseResponse
	SecretName string     `json:"SecretName" xml:"SecretName"`
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	PageSize   int        `json:"PageSize" xml:"PageSize"`
	PageNumber int        `json:"PageNumber" xml:"PageNumber"`
	TotalCount int        `json:"TotalCount" xml:"TotalCount"`
	VersionIds VersionIds `json:"VersionIds" xml:"VersionIds"`
}

ListSecretVersionIdsResponse is the response struct for api ListSecretVersionIds

func CreateListSecretVersionIdsResponse added in v1.61.16

func CreateListSecretVersionIdsResponse() (response *ListSecretVersionIdsResponse)

CreateListSecretVersionIdsResponse creates a response to parse from ListSecretVersionIds response

type ListSecretsRequest added in v1.61.16

type ListSecretsRequest struct {
	*requests.RpcRequest
	PageSize   requests.Integer `position:"Query" name:"PageSize"`
	Filters    string           `position:"Query" name:"Filters"`
	FetchTags  string           `position:"Query" name:"FetchTags"`
	PageNumber requests.Integer `position:"Query" name:"PageNumber"`
}

ListSecretsRequest is the request struct for api ListSecrets

func CreateListSecretsRequest added in v1.61.16

func CreateListSecretsRequest() (request *ListSecretsRequest)

CreateListSecretsRequest creates a request to invoke ListSecrets API

type ListSecretsResponse added in v1.61.16

type ListSecretsResponse struct {
	*responses.BaseResponse
	PageNumber int        `json:"PageNumber" xml:"PageNumber"`
	PageSize   int        `json:"PageSize" xml:"PageSize"`
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	TotalCount int        `json:"TotalCount" xml:"TotalCount"`
	SecretList SecretList `json:"SecretList" xml:"SecretList"`
}

ListSecretsResponse is the response struct for api ListSecrets

func CreateListSecretsResponse added in v1.61.16

func CreateListSecretsResponse() (response *ListSecretsResponse)

CreateListSecretsResponse creates a response to parse from ListSecrets response

type OpenKmsServiceRequest added in v1.61.535

type OpenKmsServiceRequest struct {
	*requests.RpcRequest
}

OpenKmsServiceRequest is the request struct for api OpenKmsService

func CreateOpenKmsServiceRequest added in v1.61.535

func CreateOpenKmsServiceRequest() (request *OpenKmsServiceRequest)

CreateOpenKmsServiceRequest creates a request to invoke OpenKmsService API

type OpenKmsServiceResponse added in v1.61.535

type OpenKmsServiceResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

OpenKmsServiceResponse is the response struct for api OpenKmsService

func CreateOpenKmsServiceResponse added in v1.61.535

func CreateOpenKmsServiceResponse() (response *OpenKmsServiceResponse)

CreateOpenKmsServiceResponse creates a response to parse from OpenKmsService response

type PutSecretValueRequest added in v1.61.16

type PutSecretValueRequest struct {
	*requests.RpcRequest
	VersionId      string `position:"Query" name:"VersionId"`
	VersionStages  string `position:"Query" name:"VersionStages"`
	SecretData     string `position:"Query" name:"SecretData"`
	SecretName     string `position:"Query" name:"SecretName"`
	SecretDataType string `position:"Query" name:"SecretDataType"`
}

PutSecretValueRequest is the request struct for api PutSecretValue

func CreatePutSecretValueRequest added in v1.61.16

func CreatePutSecretValueRequest() (request *PutSecretValueRequest)

CreatePutSecretValueRequest creates a request to invoke PutSecretValue API

type PutSecretValueResponse added in v1.61.16

type PutSecretValueResponse struct {
	*responses.BaseResponse
	SecretName    string                        `json:"SecretName" xml:"SecretName"`
	VersionId     string                        `json:"VersionId" xml:"VersionId"`
	RequestId     string                        `json:"RequestId" xml:"RequestId"`
	VersionStages VersionStagesInPutSecretValue `json:"VersionStages" xml:"VersionStages"`
}

PutSecretValueResponse is the response struct for api PutSecretValue

func CreatePutSecretValueResponse added in v1.61.16

func CreatePutSecretValueResponse() (response *PutSecretValueResponse)

CreatePutSecretValueResponse creates a response to parse from PutSecretValue response

type ReEncryptRequest added in v1.61.342

type ReEncryptRequest struct {
	*requests.RpcRequest
	DestinationEncryptionContext string `position:"Query" name:"DestinationEncryptionContext"`
	SourceEncryptionAlgorithm    string `position:"Query" name:"SourceEncryptionAlgorithm"`
	SourceKeyVersionId           string `position:"Query" name:"SourceKeyVersionId"`
	DestinationKeyId             string `position:"Query" name:"DestinationKeyId"`
	SourceKeyId                  string `position:"Query" name:"SourceKeyId"`
	SourceEncryptionContext      string `position:"Query" name:"SourceEncryptionContext"`
	CiphertextBlob               string `position:"Query" name:"CiphertextBlob"`
}

ReEncryptRequest is the request struct for api ReEncrypt

func CreateReEncryptRequest added in v1.61.342

func CreateReEncryptRequest() (request *ReEncryptRequest)

CreateReEncryptRequest creates a request to invoke ReEncrypt API

type ReEncryptResponse added in v1.61.342

type ReEncryptResponse struct {
	*responses.BaseResponse
	KeyId          string `json:"KeyId" xml:"KeyId"`
	KeyVersionId   string `json:"KeyVersionId" xml:"KeyVersionId"`
	CiphertextBlob string `json:"CiphertextBlob" xml:"CiphertextBlob"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
}

ReEncryptResponse is the response struct for api ReEncrypt

func CreateReEncryptResponse added in v1.61.342

func CreateReEncryptResponse() (response *ReEncryptResponse)

CreateReEncryptResponse creates a response to parse from ReEncrypt response

type Region

type Region struct {
	RegionId string `json:"RegionId" xml:"RegionId"`
}

Region is a nested struct in kms response

type Regions

type Regions struct {
	Region []Region `json:"Region" xml:"Region"`
}

Regions is a nested struct in kms response

type RestoreSecretRequest added in v1.61.16

type RestoreSecretRequest struct {
	*requests.RpcRequest
	SecretName string `position:"Query" name:"SecretName"`
}

RestoreSecretRequest is the request struct for api RestoreSecret

func CreateRestoreSecretRequest added in v1.61.16

func CreateRestoreSecretRequest() (request *RestoreSecretRequest)

CreateRestoreSecretRequest creates a request to invoke RestoreSecret API

type RestoreSecretResponse added in v1.61.16

type RestoreSecretResponse struct {
	*responses.BaseResponse
	SecretName string `json:"SecretName" xml:"SecretName"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
}

RestoreSecretResponse is the response struct for api RestoreSecret

func CreateRestoreSecretResponse added in v1.61.16

func CreateRestoreSecretResponse() (response *RestoreSecretResponse)

CreateRestoreSecretResponse creates a response to parse from RestoreSecret response

type RotateSecretRequest added in v1.61.780

type RotateSecretRequest struct {
	*requests.RpcRequest
	VersionId  string `position:"Query" name:"VersionId"`
	SecretName string `position:"Query" name:"SecretName"`
}

RotateSecretRequest is the request struct for api RotateSecret

func CreateRotateSecretRequest added in v1.61.780

func CreateRotateSecretRequest() (request *RotateSecretRequest)

CreateRotateSecretRequest creates a request to invoke RotateSecret API

type RotateSecretResponse added in v1.61.780

type RotateSecretResponse struct {
	*responses.BaseResponse
	VersionId  string `json:"VersionId" xml:"VersionId"`
	SecretName string `json:"SecretName" xml:"SecretName"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
	Arn        string `json:"Arn" xml:"Arn"`
}

RotateSecretResponse is the response struct for api RotateSecret

func CreateRotateSecretResponse added in v1.61.780

func CreateRotateSecretResponse() (response *RotateSecretResponse)

CreateRotateSecretResponse creates a response to parse from RotateSecret response

type ScheduleKeyDeletionRequest

type ScheduleKeyDeletionRequest struct {
	*requests.RpcRequest
	PendingWindowInDays requests.Integer `position:"Query" name:"PendingWindowInDays"`
	KeyId               string           `position:"Query" name:"KeyId"`
}

ScheduleKeyDeletionRequest is the request struct for api ScheduleKeyDeletion

func CreateScheduleKeyDeletionRequest

func CreateScheduleKeyDeletionRequest() (request *ScheduleKeyDeletionRequest)

CreateScheduleKeyDeletionRequest creates a request to invoke ScheduleKeyDeletion API

type ScheduleKeyDeletionResponse

type ScheduleKeyDeletionResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

ScheduleKeyDeletionResponse is the response struct for api ScheduleKeyDeletion

func CreateScheduleKeyDeletionResponse

func CreateScheduleKeyDeletionResponse() (response *ScheduleKeyDeletionResponse)

CreateScheduleKeyDeletionResponse creates a response to parse from ScheduleKeyDeletion response

type Secret added in v1.61.16

type Secret struct {
	SecretName        string            `json:"SecretName" xml:"SecretName"`
	UpdateTime        string            `json:"UpdateTime" xml:"UpdateTime"`
	SecretType        string            `json:"SecretType" xml:"SecretType"`
	PlannedDeleteTime string            `json:"PlannedDeleteTime" xml:"PlannedDeleteTime"`
	CreateTime        string            `json:"CreateTime" xml:"CreateTime"`
	Tags              TagsInListSecrets `json:"Tags" xml:"Tags"`
}

Secret is a nested struct in kms response

type SecretList added in v1.61.16

type SecretList struct {
	Secret []Secret `json:"Secret" xml:"Secret"`
}

SecretList is a nested struct in kms response

type SetDeletionProtectionRequest added in v1.61.1118

type SetDeletionProtectionRequest struct {
	*requests.RpcRequest
	EnableDeletionProtection      requests.Boolean `position:"Query" name:"EnableDeletionProtection"`
	ProtectedResourceArn          string           `position:"Query" name:"ProtectedResourceArn"`
	DeletionProtectionDescription string           `position:"Query" name:"DeletionProtectionDescription"`
}

SetDeletionProtectionRequest is the request struct for api SetDeletionProtection

func CreateSetDeletionProtectionRequest added in v1.61.1118

func CreateSetDeletionProtectionRequest() (request *SetDeletionProtectionRequest)

CreateSetDeletionProtectionRequest creates a request to invoke SetDeletionProtection API

type SetDeletionProtectionResponse added in v1.61.1118

type SetDeletionProtectionResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

SetDeletionProtectionResponse is the response struct for api SetDeletionProtection

func CreateSetDeletionProtectionResponse added in v1.61.1118

func CreateSetDeletionProtectionResponse() (response *SetDeletionProtectionResponse)

CreateSetDeletionProtectionResponse creates a response to parse from SetDeletionProtection response

type SubjectAlternativeNames added in v1.61.701

type SubjectAlternativeNames struct {
	SubjectAlternativeName []string `json:"SubjectAlternativeName" xml:"SubjectAlternativeName"`
}

SubjectAlternativeNames is a nested struct in kms response

type Tag

type Tag struct {
	TagValue string `json:"TagValue" xml:"TagValue"`
	TagKey   string `json:"TagKey" xml:"TagKey"`
	KeyId    string `json:"KeyId" xml:"KeyId"`
}

Tag is a nested struct in kms response

type TagResourceRequest

type TagResourceRequest struct {
	*requests.RpcRequest
	CertificateId string `position:"Query" name:"CertificateId"`
	KeyId         string `position:"Query" name:"KeyId"`
	SecretName    string `position:"Query" name:"SecretName"`
	Tags          string `position:"Query" name:"Tags"`
}

TagResourceRequest is the request struct for api TagResource

func CreateTagResourceRequest

func CreateTagResourceRequest() (request *TagResourceRequest)

CreateTagResourceRequest creates a request to invoke TagResource API

type TagResourceResponse

type TagResourceResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

TagResourceResponse is the response struct for api TagResource

func CreateTagResourceResponse

func CreateTagResourceResponse() (response *TagResourceResponse)

CreateTagResourceResponse creates a response to parse from TagResource response

type TagsInDescribeSecret added in v1.61.16

type TagsInDescribeSecret struct {
	Tag []Tag `json:"Tag" xml:"Tag"`
}

TagsInDescribeSecret is a nested struct in kms response

type TagsInListResourceTags added in v1.61.16

type TagsInListResourceTags struct {
	Tag []Tag `json:"Tag" xml:"Tag"`
}

TagsInListResourceTags is a nested struct in kms response

type TagsInListSecrets added in v1.61.16

type TagsInListSecrets struct {
	Tag []Tag `json:"Tag" xml:"Tag"`
}

TagsInListSecrets is a nested struct in kms response

type UntagResourceRequest

type UntagResourceRequest struct {
	*requests.RpcRequest
	CertificateId string `position:"Query" name:"CertificateId"`
	TagKeys       string `position:"Query" name:"TagKeys"`
	KeyId         string `position:"Query" name:"KeyId"`
	SecretName    string `position:"Query" name:"SecretName"`
}

UntagResourceRequest is the request struct for api UntagResource

func CreateUntagResourceRequest

func CreateUntagResourceRequest() (request *UntagResourceRequest)

CreateUntagResourceRequest creates a request to invoke UntagResource API

type UntagResourceResponse

type UntagResourceResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UntagResourceResponse is the response struct for api UntagResource

func CreateUntagResourceResponse

func CreateUntagResourceResponse() (response *UntagResourceResponse)

CreateUntagResourceResponse creates a response to parse from UntagResource response

type UpdateAliasRequest

type UpdateAliasRequest struct {
	*requests.RpcRequest
	AliasName string `position:"Query" name:"AliasName"`
	KeyId     string `position:"Query" name:"KeyId"`
}

UpdateAliasRequest is the request struct for api UpdateAlias

func CreateUpdateAliasRequest

func CreateUpdateAliasRequest() (request *UpdateAliasRequest)

CreateUpdateAliasRequest creates a request to invoke UpdateAlias API

type UpdateAliasResponse

type UpdateAliasResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateAliasResponse is the response struct for api UpdateAlias

func CreateUpdateAliasResponse

func CreateUpdateAliasResponse() (response *UpdateAliasResponse)

CreateUpdateAliasResponse creates a response to parse from UpdateAlias response

type UpdateCertificateStatusRequest added in v1.61.701

type UpdateCertificateStatusRequest struct {
	*requests.RpcRequest
	CertificateId string `position:"Query" name:"CertificateId"`
	Status        string `position:"Query" name:"Status"`
}

UpdateCertificateStatusRequest is the request struct for api UpdateCertificateStatus

func CreateUpdateCertificateStatusRequest added in v1.61.701

func CreateUpdateCertificateStatusRequest() (request *UpdateCertificateStatusRequest)

CreateUpdateCertificateStatusRequest creates a request to invoke UpdateCertificateStatus API

type UpdateCertificateStatusResponse added in v1.61.701

type UpdateCertificateStatusResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateCertificateStatusResponse is the response struct for api UpdateCertificateStatus

func CreateUpdateCertificateStatusResponse added in v1.61.701

func CreateUpdateCertificateStatusResponse() (response *UpdateCertificateStatusResponse)

CreateUpdateCertificateStatusResponse creates a response to parse from UpdateCertificateStatus response

type UpdateKeyDescriptionRequest

type UpdateKeyDescriptionRequest struct {
	*requests.RpcRequest
	KeyId       string `position:"Query" name:"KeyId"`
	Description string `position:"Query" name:"Description"`
}

UpdateKeyDescriptionRequest is the request struct for api UpdateKeyDescription

func CreateUpdateKeyDescriptionRequest

func CreateUpdateKeyDescriptionRequest() (request *UpdateKeyDescriptionRequest)

CreateUpdateKeyDescriptionRequest creates a request to invoke UpdateKeyDescription API

type UpdateKeyDescriptionResponse

type UpdateKeyDescriptionResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateKeyDescriptionResponse is the response struct for api UpdateKeyDescription

func CreateUpdateKeyDescriptionResponse

func CreateUpdateKeyDescriptionResponse() (response *UpdateKeyDescriptionResponse)

CreateUpdateKeyDescriptionResponse creates a response to parse from UpdateKeyDescription response

type UpdateRotationPolicyRequest

type UpdateRotationPolicyRequest struct {
	*requests.RpcRequest
	KeyId                   string           `position:"Query" name:"KeyId"`
	RotationInterval        string           `position:"Query" name:"RotationInterval"`
	EnableAutomaticRotation requests.Boolean `position:"Query" name:"EnableAutomaticRotation"`
}

UpdateRotationPolicyRequest is the request struct for api UpdateRotationPolicy

func CreateUpdateRotationPolicyRequest

func CreateUpdateRotationPolicyRequest() (request *UpdateRotationPolicyRequest)

CreateUpdateRotationPolicyRequest creates a request to invoke UpdateRotationPolicy API

type UpdateRotationPolicyResponse

type UpdateRotationPolicyResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateRotationPolicyResponse is the response struct for api UpdateRotationPolicy

func CreateUpdateRotationPolicyResponse

func CreateUpdateRotationPolicyResponse() (response *UpdateRotationPolicyResponse)

CreateUpdateRotationPolicyResponse creates a response to parse from UpdateRotationPolicy response

type UpdateSecretRequest added in v1.61.16

type UpdateSecretRequest struct {
	*requests.RpcRequest
	Description              string `position:"Query" name:"Description"`
	SecretName               string `position:"Query" name:"SecretName"`
	ExtendedConfigCustomData string `position:"Query" name:"ExtendedConfig.CustomData"`
}

UpdateSecretRequest is the request struct for api UpdateSecret

func CreateUpdateSecretRequest added in v1.61.16

func CreateUpdateSecretRequest() (request *UpdateSecretRequest)

CreateUpdateSecretRequest creates a request to invoke UpdateSecret API

type UpdateSecretResponse added in v1.61.16

type UpdateSecretResponse struct {
	*responses.BaseResponse
	SecretName string `json:"SecretName" xml:"SecretName"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
}

UpdateSecretResponse is the response struct for api UpdateSecret

func CreateUpdateSecretResponse added in v1.61.16

func CreateUpdateSecretResponse() (response *UpdateSecretResponse)

CreateUpdateSecretResponse creates a response to parse from UpdateSecret response

type UpdateSecretRotationPolicyRequest added in v1.61.780

type UpdateSecretRotationPolicyRequest struct {
	*requests.RpcRequest
	RotationInterval        string           `position:"Query" name:"RotationInterval"`
	SecretName              string           `position:"Query" name:"SecretName"`
	EnableAutomaticRotation requests.Boolean `position:"Query" name:"EnableAutomaticRotation"`
}

UpdateSecretRotationPolicyRequest is the request struct for api UpdateSecretRotationPolicy

func CreateUpdateSecretRotationPolicyRequest added in v1.61.780

func CreateUpdateSecretRotationPolicyRequest() (request *UpdateSecretRotationPolicyRequest)

CreateUpdateSecretRotationPolicyRequest creates a request to invoke UpdateSecretRotationPolicy API

type UpdateSecretRotationPolicyResponse added in v1.61.780

type UpdateSecretRotationPolicyResponse struct {
	*responses.BaseResponse
	SecretName string `json:"SecretName" xml:"SecretName"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
}

UpdateSecretRotationPolicyResponse is the response struct for api UpdateSecretRotationPolicy

func CreateUpdateSecretRotationPolicyResponse added in v1.61.780

func CreateUpdateSecretRotationPolicyResponse() (response *UpdateSecretRotationPolicyResponse)

CreateUpdateSecretRotationPolicyResponse creates a response to parse from UpdateSecretRotationPolicy response

type UpdateSecretVersionStageRequest added in v1.61.16

type UpdateSecretVersionStageRequest struct {
	*requests.RpcRequest
	RemoveFromVersion string `position:"Query" name:"RemoveFromVersion"`
	MoveToVersion     string `position:"Query" name:"MoveToVersion"`
	VersionStage      string `position:"Query" name:"VersionStage"`
	SecretName        string `position:"Query" name:"SecretName"`
}

UpdateSecretVersionStageRequest is the request struct for api UpdateSecretVersionStage

func CreateUpdateSecretVersionStageRequest added in v1.61.16

func CreateUpdateSecretVersionStageRequest() (request *UpdateSecretVersionStageRequest)

CreateUpdateSecretVersionStageRequest creates a request to invoke UpdateSecretVersionStage API

type UpdateSecretVersionStageResponse added in v1.61.16

type UpdateSecretVersionStageResponse struct {
	*responses.BaseResponse
	SecretName string `json:"SecretName" xml:"SecretName"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
}

UpdateSecretVersionStageResponse is the response struct for api UpdateSecretVersionStage

func CreateUpdateSecretVersionStageResponse added in v1.61.16

func CreateUpdateSecretVersionStageResponse() (response *UpdateSecretVersionStageResponse)

CreateUpdateSecretVersionStageResponse creates a response to parse from UpdateSecretVersionStage response

type UploadCertificateRequest added in v1.61.701

type UploadCertificateRequest struct {
	*requests.RpcRequest
	CertificateId    string `position:"Query" name:"CertificateId"`
	Certificate      string `position:"Query" name:"Certificate"`
	CertificateChain string `position:"Query" name:"CertificateChain"`
}

UploadCertificateRequest is the request struct for api UploadCertificate

func CreateUploadCertificateRequest added in v1.61.701

func CreateUploadCertificateRequest() (request *UploadCertificateRequest)

CreateUploadCertificateRequest creates a request to invoke UploadCertificate API

type UploadCertificateResponse added in v1.61.701

type UploadCertificateResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UploadCertificateResponse is the response struct for api UploadCertificate

func CreateUploadCertificateResponse added in v1.61.701

func CreateUploadCertificateResponse() (response *UploadCertificateResponse)

CreateUploadCertificateResponse creates a response to parse from UploadCertificate response

type VersionId added in v1.61.16

type VersionId struct {
	VersionId     string                              `json:"VersionId" xml:"VersionId"`
	CreateTime    string                              `json:"CreateTime" xml:"CreateTime"`
	VersionStages VersionStagesInListSecretVersionIds `json:"VersionStages" xml:"VersionStages"`
}

VersionId is a nested struct in kms response

type VersionIds added in v1.61.16

type VersionIds struct {
	VersionId []VersionId `json:"VersionId" xml:"VersionId"`
}

VersionIds is a nested struct in kms response

type VersionStagesInGetSecretValue added in v1.61.16

type VersionStagesInGetSecretValue struct {
	VersionStage []string `json:"VersionStage" xml:"VersionStage"`
}

VersionStagesInGetSecretValue is a nested struct in kms response

type VersionStagesInListSecretVersionIds added in v1.61.16

type VersionStagesInListSecretVersionIds struct {
	VersionStage []string `json:"VersionStage" xml:"VersionStage"`
}

VersionStagesInListSecretVersionIds is a nested struct in kms response

type VersionStagesInPutSecretValue added in v1.61.16

type VersionStagesInPutSecretValue struct {
	VersionStage []string `json:"VersionStage" xml:"VersionStage"`
}

VersionStagesInPutSecretValue is a nested struct in kms response

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL