repo_name stringlengths 1 52 | repo_creator stringclasses 6
values | programming_language stringclasses 4
values | code stringlengths 0 9.68M | num_lines int64 1 234k |
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the tags for an Amazon Web Services resource. This is a paginated
// operation, which means that each response might contain only a subset of all the
// tags. When the response contains only a subset of tags, it includes a NextToken
// value. Use this value in a subsequent ListTagsForResource request to get more
// tags. When you receive a response with no NextToken (or an empty or null value),
// that means there are no more tags to get. Cross-account use: This operation
// can't be used across different Amazon Web Services accounts. Related operations:
//
// - TagResource
// - UntagResource
func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) {
if params == nil {
params = &ListTagsForResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTagsForResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTagsForResourceInput struct {
// The KeyARN of the key whose tags you are getting.
//
// This member is required.
ResourceArn *string
// Use this parameter to specify the maximum number of items to return. When this
// value is present, Amazon Web Services Payment Cryptography does not return more
// than the specified number of items, but it might return fewer.
MaxResults *int32
// Use this parameter in a subsequent request after you receive a response with
// truncated results. Set it to the value of NextToken from the truncated response
// you just received.
NextToken *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The list of tags associated with a ResourceArn . Each tag will list the
// key-value pair contained within that tag.
//
// This member is required.
Tags []types.Tag
// The token for the next set of results, or an empty or null value if there are
// no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson10_serializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListTagsForResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTagsForResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListTagsForResourceAPIClient is a client that implements the
// ListTagsForResource operation.
type ListTagsForResourceAPIClient interface {
ListTagsForResource(context.Context, *ListTagsForResourceInput, ...func(*Options)) (*ListTagsForResourceOutput, error)
}
var _ ListTagsForResourceAPIClient = (*Client)(nil)
// ListTagsForResourcePaginatorOptions is the paginator options for
// ListTagsForResource
type ListTagsForResourcePaginatorOptions struct {
// Use this parameter to specify the maximum number of items to return. When this
// value is present, Amazon Web Services Payment Cryptography does not return more
// than the specified number of items, but it might return fewer.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListTagsForResourcePaginator is a paginator for ListTagsForResource
type ListTagsForResourcePaginator struct {
options ListTagsForResourcePaginatorOptions
client ListTagsForResourceAPIClient
params *ListTagsForResourceInput
nextToken *string
firstPage bool
}
// NewListTagsForResourcePaginator returns a new ListTagsForResourcePaginator
func NewListTagsForResourcePaginator(client ListTagsForResourceAPIClient, params *ListTagsForResourceInput, optFns ...func(*ListTagsForResourcePaginatorOptions)) *ListTagsForResourcePaginator {
if params == nil {
params = &ListTagsForResourceInput{}
}
options := ListTagsForResourcePaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListTagsForResourcePaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListTagsForResourcePaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListTagsForResource page.
func (p *ListTagsForResourcePaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListTagsForResource(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListTagsForResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "ListTagsForResource",
}
}
| 245 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Cancels a scheduled key deletion during the waiting period. Use this operation
// to restore a Key that is scheduled for deletion. During the waiting period, the
// KeyState is DELETE_PENDING and deletePendingTimestamp contains the date and
// time after which the Key will be deleted. After Key is restored, the KeyState
// is CREATE_COMPLETE , and the value for deletePendingTimestamp is removed.
// Cross-account use: This operation can't be used across different Amazon Web
// Services accounts. Related operations:
// - DeleteKey
// - StartKeyUsage
// - StopKeyUsage
func (c *Client) RestoreKey(ctx context.Context, params *RestoreKeyInput, optFns ...func(*Options)) (*RestoreKeyOutput, error) {
if params == nil {
params = &RestoreKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RestoreKey", params, optFns, c.addOperationRestoreKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RestoreKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type RestoreKeyInput struct {
// The KeyARN of the key to be restored within Amazon Web Services Payment
// Cryptography.
//
// This member is required.
KeyIdentifier *string
noSmithyDocumentSerde
}
type RestoreKeyOutput struct {
// The key material of the restored key. The KeyState will change to
// CREATE_COMPLETE and value for DeletePendingTimestamp gets removed.
//
// This member is required.
Key *types.Key
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRestoreKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson10_serializeOpRestoreKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpRestoreKey{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpRestoreKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRestoreKey(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opRestoreKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "RestoreKey",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Enables an Amazon Web Services Payment Cryptography key, which makes it active
// for cryptographic operations within Amazon Web Services Payment Cryptography
// Cross-account use: This operation can't be used across different Amazon Web
// Services accounts. Related operations:
// - StopKeyUsage
func (c *Client) StartKeyUsage(ctx context.Context, params *StartKeyUsageInput, optFns ...func(*Options)) (*StartKeyUsageOutput, error) {
if params == nil {
params = &StartKeyUsageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartKeyUsage", params, optFns, c.addOperationStartKeyUsageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartKeyUsageOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartKeyUsageInput struct {
// The KeyArn of the key.
//
// This member is required.
KeyIdentifier *string
noSmithyDocumentSerde
}
type StartKeyUsageOutput struct {
// The KeyARN of the Amazon Web Services Payment Cryptography key activated for
// use.
//
// This member is required.
Key *types.Key
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartKeyUsageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson10_serializeOpStartKeyUsage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpStartKeyUsage{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpStartKeyUsageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartKeyUsage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opStartKeyUsage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "StartKeyUsage",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disables an Amazon Web Services Payment Cryptography key, which makes it
// inactive within Amazon Web Services Payment Cryptography. You can use this
// operation instead of DeleteKey to deactivate a key. You can enable the key in
// the future by calling StartKeyUsage . Cross-account use: This operation can't be
// used across different Amazon Web Services accounts. Related operations:
// - DeleteKey
// - StartKeyUsage
func (c *Client) StopKeyUsage(ctx context.Context, params *StopKeyUsageInput, optFns ...func(*Options)) (*StopKeyUsageOutput, error) {
if params == nil {
params = &StopKeyUsageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopKeyUsage", params, optFns, c.addOperationStopKeyUsageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopKeyUsageOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopKeyUsageInput struct {
// The KeyArn of the key.
//
// This member is required.
KeyIdentifier *string
noSmithyDocumentSerde
}
type StopKeyUsageOutput struct {
// The KeyARN of the key.
//
// This member is required.
Key *types.Key
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopKeyUsageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson10_serializeOpStopKeyUsage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpStopKeyUsage{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpStopKeyUsageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopKeyUsage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opStopKeyUsage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "StopKeyUsage",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds or edits tags on an Amazon Web Services Payment Cryptography key. Tagging
// or untagging an Amazon Web Services Payment Cryptography key can allow or deny
// permission to the key. Each tag consists of a tag key and a tag value, both of
// which are case-sensitive strings. The tag value can be an empty (null) string.
// To add a tag, specify a new tag key and a tag value. To edit a tag, specify an
// existing tag key and a new tag value. You can also add tags to an Amazon Web
// Services Payment Cryptography key when you create it with CreateKey .
// Cross-account use: This operation can't be used across different Amazon Web
// Services accounts. Related operations:
// - ListTagsForResource
// - UntagResource
func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) {
if params == nil {
params = &TagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type TagResourceInput struct {
// The KeyARN of the key whose tags are being updated.
//
// This member is required.
ResourceArn *string
// One or more tags. Each tag consists of a tag key and a tag value. The tag value
// can be an empty (null) string. You can't have more than one tag on an Amazon Web
// Services Payment Cryptography key with the same tag key. If you specify an
// existing tag key with a different tag value, Amazon Web Services Payment
// Cryptography replaces the current tag value with the new one. Don't include
// confidential or sensitive information in this field. This field may be displayed
// in plaintext in CloudTrail logs and other output. To use this parameter, you
// must have TagResource permission in an IAM policy. Don't include confidential
// or sensitive information in this field. This field may be displayed in plaintext
// in CloudTrail logs and other output.
//
// This member is required.
Tags []types.Tag
noSmithyDocumentSerde
}
type TagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson10_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpTagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opTagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "TagResource",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a tag from an Amazon Web Services Payment Cryptography key. Tagging or
// untagging an Amazon Web Services Payment Cryptography key can allow or deny
// permission to the key. Cross-account use: This operation can't be used across
// different Amazon Web Services accounts. Related operations:
// - ListTagsForResource
// - TagResource
func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) {
if params == nil {
params = &UntagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UntagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UntagResourceInput struct {
// The KeyARN of the key whose tags are being removed.
//
// This member is required.
ResourceArn *string
// One or more tag keys. Don't include the tag values. If the Amazon Web Services
// Payment Cryptography key doesn't have the specified tag key, Amazon Web Services
// Payment Cryptography doesn't throw an exception or return a response. To confirm
// that the operation succeeded, use the ListTagsForResource operation.
//
// This member is required.
TagKeys []string
noSmithyDocumentSerde
}
type UntagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson10_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUntagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUntagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUntagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "UntagResource",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Associates an existing Amazon Web Services Payment Cryptography alias with a
// different key. Each alias is associated with only one Amazon Web Services
// Payment Cryptography key at a time, although a key can have multiple aliases.
// The alias and the Amazon Web Services Payment Cryptography key must be in the
// same Amazon Web Services account and Amazon Web Services Region Cross-account
// use: This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - CreateAlias
// - DeleteAlias
// - GetAlias
// - ListAliases
func (c *Client) UpdateAlias(ctx context.Context, params *UpdateAliasInput, optFns ...func(*Options)) (*UpdateAliasOutput, error) {
if params == nil {
params = &UpdateAliasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateAlias", params, optFns, c.addOperationUpdateAliasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateAliasOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateAliasInput struct {
// The alias whose associated key is changing.
//
// This member is required.
AliasName *string
// The KeyARN for the key that you are updating or removing from the alias.
KeyArn *string
noSmithyDocumentSerde
}
type UpdateAliasOutput struct {
// The alias name.
//
// This member is required.
Alias *types.Alias
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateAliasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson10_serializeOpUpdateAlias{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson10_deserializeOpUpdateAlias{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUpdateAliasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateAlias(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUpdateAlias(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "UpdateAlias",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"strings"
)
type awsAwsjson10_deserializeOpCreateAlias struct {
}
func (*awsAwsjson10_deserializeOpCreateAlias) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorCreateAlias(response, &metadata)
}
output := &CreateAliasOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateAliasOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpCreateKey struct {
}
func (*awsAwsjson10_deserializeOpCreateKey) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpCreateKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorCreateKey(response, &metadata)
}
output := &CreateKeyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentCreateKeyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorCreateKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteAlias struct {
}
func (*awsAwsjson10_deserializeOpDeleteAlias) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorDeleteAlias(response, &metadata)
}
output := &DeleteAliasOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteAliasOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpDeleteKey struct {
}
func (*awsAwsjson10_deserializeOpDeleteKey) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpDeleteKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorDeleteKey(response, &metadata)
}
output := &DeleteKeyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentDeleteKeyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorDeleteKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpExportKey struct {
}
func (*awsAwsjson10_deserializeOpExportKey) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpExportKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorExportKey(response, &metadata)
}
output := &ExportKeyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentExportKeyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorExportKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpGetAlias struct {
}
func (*awsAwsjson10_deserializeOpGetAlias) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpGetAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorGetAlias(response, &metadata)
}
output := &GetAliasOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentGetAliasOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorGetAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpGetKey struct {
}
func (*awsAwsjson10_deserializeOpGetKey) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpGetKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorGetKey(response, &metadata)
}
output := &GetKeyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentGetKeyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorGetKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpGetParametersForExport struct {
}
func (*awsAwsjson10_deserializeOpGetParametersForExport) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpGetParametersForExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorGetParametersForExport(response, &metadata)
}
output := &GetParametersForExportOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentGetParametersForExportOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorGetParametersForExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpGetParametersForImport struct {
}
func (*awsAwsjson10_deserializeOpGetParametersForImport) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpGetParametersForImport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorGetParametersForImport(response, &metadata)
}
output := &GetParametersForImportOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentGetParametersForImportOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorGetParametersForImport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpGetPublicKeyCertificate struct {
}
func (*awsAwsjson10_deserializeOpGetPublicKeyCertificate) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpGetPublicKeyCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorGetPublicKeyCertificate(response, &metadata)
}
output := &GetPublicKeyCertificateOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentGetPublicKeyCertificateOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorGetPublicKeyCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpImportKey struct {
}
func (*awsAwsjson10_deserializeOpImportKey) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpImportKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorImportKey(response, &metadata)
}
output := &ImportKeyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentImportKeyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorImportKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListAliases struct {
}
func (*awsAwsjson10_deserializeOpListAliases) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListAliases) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorListAliases(response, &metadata)
}
output := &ListAliasesOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListAliasesOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListAliases(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListKeys struct {
}
func (*awsAwsjson10_deserializeOpListKeys) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorListKeys(response, &metadata)
}
output := &ListKeysOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListKeysOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpListTagsForResource struct {
}
func (*awsAwsjson10_deserializeOpListTagsForResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorListTagsForResource(response, &metadata)
}
output := &ListTagsForResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpRestoreKey struct {
}
func (*awsAwsjson10_deserializeOpRestoreKey) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpRestoreKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorRestoreKey(response, &metadata)
}
output := &RestoreKeyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentRestoreKeyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorRestoreKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpStartKeyUsage struct {
}
func (*awsAwsjson10_deserializeOpStartKeyUsage) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpStartKeyUsage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorStartKeyUsage(response, &metadata)
}
output := &StartKeyUsageOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentStartKeyUsageOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorStartKeyUsage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpStopKeyUsage struct {
}
func (*awsAwsjson10_deserializeOpStopKeyUsage) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpStopKeyUsage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorStopKeyUsage(response, &metadata)
}
output := &StopKeyUsageOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentStopKeyUsageOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorStopKeyUsage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpTagResource struct {
}
func (*awsAwsjson10_deserializeOpTagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorTagResource(response, &metadata)
}
output := &TagResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentTagResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsAwsjson10_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpUntagResource struct {
}
func (*awsAwsjson10_deserializeOpUntagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorUntagResource(response, &metadata)
}
output := &UntagResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentUntagResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson10_deserializeOpUpdateAlias struct {
}
func (*awsAwsjson10_deserializeOpUpdateAlias) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson10_deserializeOpUpdateAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson10_deserializeOpErrorUpdateAlias(response, &metadata)
}
output := &UpdateAliasOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson10_deserializeOpDocumentUpdateAliasOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson10_deserializeOpErrorUpdateAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsAwsjson10_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsAwsjson10_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsAwsjson10_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson10_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsAwsjson10_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsAwsjson10_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsAwsjson10_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsAwsjson10_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.AccessDeniedException{}
err := awsAwsjson10_deserializeDocumentAccessDeniedException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ConflictException{}
err := awsAwsjson10_deserializeDocumentConflictException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InternalServerException{}
err := awsAwsjson10_deserializeDocumentInternalServerException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ResourceNotFoundException{}
err := awsAwsjson10_deserializeDocumentResourceNotFoundException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ServiceQuotaExceededException{}
err := awsAwsjson10_deserializeDocumentServiceQuotaExceededException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ServiceUnavailableException{}
err := awsAwsjson10_deserializeDocumentServiceUnavailableException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ThrottlingException{}
err := awsAwsjson10_deserializeDocumentThrottlingException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ValidationException{}
err := awsAwsjson10_deserializeDocumentValidationException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson10_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AccessDeniedException
if *v == nil {
sv = &types.AccessDeniedException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentAlias(v **types.Alias, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Alias
if *v == nil {
sv = &types.Alias{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AliasName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AliasName to be of type string, got %T instead", value)
}
sv.AliasName = ptr.String(jtv)
}
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentAliases(v *[]types.Alias, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.Alias
if *v == nil {
cv = []types.Alias{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Alias
destAddr := &col
if err := awsAwsjson10_deserializeDocumentAlias(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ConflictException
if *v == nil {
sv = &types.ConflictException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InternalServerException
if *v == nil {
sv = &types.InternalServerException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentKey(v **types.Key, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Key
if *v == nil {
sv = &types.Key{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CreateTimestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreateTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DeletePendingTimestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DeletePendingTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "DeleteTimestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DeleteTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "Enabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Enabled = ptr.Bool(jtv)
}
case "Exportable":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Exportable = ptr.Bool(jtv)
}
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyAttributes":
if err := awsAwsjson10_deserializeDocumentKeyAttributes(&sv.KeyAttributes, value); err != nil {
return err
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
case "KeyCheckValueAlgorithm":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValueAlgorithm to be of type string, got %T instead", value)
}
sv.KeyCheckValueAlgorithm = types.KeyCheckValueAlgorithm(jtv)
}
case "KeyOrigin":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyOrigin to be of type string, got %T instead", value)
}
sv.KeyOrigin = types.KeyOrigin(jtv)
}
case "KeyState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyState to be of type string, got %T instead", value)
}
sv.KeyState = types.KeyState(jtv)
}
case "UsageStartTimestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UsageStartTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "UsageStopTimestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UsageStopTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentKeyAttributes(v **types.KeyAttributes, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.KeyAttributes
if *v == nil {
sv = &types.KeyAttributes{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyAlgorithm":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value)
}
sv.KeyAlgorithm = types.KeyAlgorithm(jtv)
}
case "KeyClass":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyClass to be of type string, got %T instead", value)
}
sv.KeyClass = types.KeyClass(jtv)
}
case "KeyModesOfUse":
if err := awsAwsjson10_deserializeDocumentKeyModesOfUse(&sv.KeyModesOfUse, value); err != nil {
return err
}
case "KeyUsage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyUsage to be of type string, got %T instead", value)
}
sv.KeyUsage = types.KeyUsage(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentKeyModesOfUse(v **types.KeyModesOfUse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.KeyModesOfUse
if *v == nil {
sv = &types.KeyModesOfUse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Decrypt":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.Decrypt = jtv
}
case "DeriveKey":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.DeriveKey = jtv
}
case "Encrypt":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.Encrypt = jtv
}
case "Generate":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.Generate = jtv
}
case "NoRestrictions":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.NoRestrictions = jtv
}
case "Sign":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.Sign = jtv
}
case "Unwrap":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.Unwrap = jtv
}
case "Verify":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.Verify = jtv
}
case "Wrap":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected PrimitiveBoolean to be of type *bool, got %T instead", value)
}
sv.Wrap = jtv
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentKeySummary(v **types.KeySummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.KeySummary
if *v == nil {
sv = &types.KeySummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Enabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Enabled = ptr.Bool(jtv)
}
case "Exportable":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Exportable = ptr.Bool(jtv)
}
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyAttributes":
if err := awsAwsjson10_deserializeDocumentKeyAttributes(&sv.KeyAttributes, value); err != nil {
return err
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
case "KeyState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyState to be of type string, got %T instead", value)
}
sv.KeyState = types.KeyState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentKeySummaryList(v *[]types.KeySummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.KeySummary
if *v == nil {
cv = []types.KeySummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.KeySummary
destAddr := &col
if err := awsAwsjson10_deserializeDocumentKeySummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceNotFoundException
if *v == nil {
sv = &types.ResourceNotFoundException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ServiceQuotaExceededException
if *v == nil {
sv = &types.ServiceQuotaExceededException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ServiceUnavailableException
if *v == nil {
sv = &types.ServiceUnavailableException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentTag(v **types.Tag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Tag
if *v == nil {
sv = &types.Tag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
}
sv.Key = ptr.String(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentTags(v *[]types.Tag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.Tag
if *v == nil {
cv = []types.Tag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Tag
destAddr := &col
if err := awsAwsjson10_deserializeDocumentTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson10_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThrottlingException
if *v == nil {
sv = &types.ThrottlingException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ValidationException
if *v == nil {
sv = &types.ValidationException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeDocumentWrappedKey(v **types.WrappedKey, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.WrappedKey
if *v == nil {
sv = &types.WrappedKey{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyMaterial":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyMaterial to be of type string, got %T instead", value)
}
sv.KeyMaterial = ptr.String(jtv)
}
case "WrappedKeyMaterialFormat":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected WrappedKeyMaterialFormat to be of type string, got %T instead", value)
}
sv.WrappedKeyMaterialFormat = types.WrappedKeyMaterialFormat(jtv)
}
case "WrappingKeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.WrappingKeyArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateAliasOutput(v **CreateAliasOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateAliasOutput
if *v == nil {
sv = &CreateAliasOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Alias":
if err := awsAwsjson10_deserializeDocumentAlias(&sv.Alias, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentCreateKeyOutput(v **CreateKeyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateKeyOutput
if *v == nil {
sv = &CreateKeyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if err := awsAwsjson10_deserializeDocumentKey(&sv.Key, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteAliasOutput(v **DeleteAliasOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteAliasOutput
if *v == nil {
sv = &DeleteAliasOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentDeleteKeyOutput(v **DeleteKeyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteKeyOutput
if *v == nil {
sv = &DeleteKeyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if err := awsAwsjson10_deserializeDocumentKey(&sv.Key, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentExportKeyOutput(v **ExportKeyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ExportKeyOutput
if *v == nil {
sv = &ExportKeyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "WrappedKey":
if err := awsAwsjson10_deserializeDocumentWrappedKey(&sv.WrappedKey, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentGetAliasOutput(v **GetAliasOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetAliasOutput
if *v == nil {
sv = &GetAliasOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Alias":
if err := awsAwsjson10_deserializeDocumentAlias(&sv.Alias, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentGetKeyOutput(v **GetKeyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetKeyOutput
if *v == nil {
sv = &GetKeyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if err := awsAwsjson10_deserializeDocumentKey(&sv.Key, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentGetParametersForExportOutput(v **GetParametersForExportOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetParametersForExportOutput
if *v == nil {
sv = &GetParametersForExportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ExportToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExportTokenId to be of type string, got %T instead", value)
}
sv.ExportToken = ptr.String(jtv)
}
case "ParametersValidUntilTimestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ParametersValidUntilTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "SigningKeyAlgorithm":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value)
}
sv.SigningKeyAlgorithm = types.KeyAlgorithm(jtv)
}
case "SigningKeyCertificate":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value)
}
sv.SigningKeyCertificate = ptr.String(jtv)
}
case "SigningKeyCertificateChain":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value)
}
sv.SigningKeyCertificateChain = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentGetParametersForImportOutput(v **GetParametersForImportOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetParametersForImportOutput
if *v == nil {
sv = &GetParametersForImportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ImportToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ImportTokenId to be of type string, got %T instead", value)
}
sv.ImportToken = ptr.String(jtv)
}
case "ParametersValidUntilTimestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ParametersValidUntilTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "WrappingKeyAlgorithm":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value)
}
sv.WrappingKeyAlgorithm = types.KeyAlgorithm(jtv)
}
case "WrappingKeyCertificate":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value)
}
sv.WrappingKeyCertificate = ptr.String(jtv)
}
case "WrappingKeyCertificateChain":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value)
}
sv.WrappingKeyCertificateChain = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentGetPublicKeyCertificateOutput(v **GetPublicKeyCertificateOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetPublicKeyCertificateOutput
if *v == nil {
sv = &GetPublicKeyCertificateOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyCertificate":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value)
}
sv.KeyCertificate = ptr.String(jtv)
}
case "KeyCertificateChain":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CertificateType to be of type string, got %T instead", value)
}
sv.KeyCertificateChain = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentImportKeyOutput(v **ImportKeyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ImportKeyOutput
if *v == nil {
sv = &ImportKeyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if err := awsAwsjson10_deserializeDocumentKey(&sv.Key, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListAliasesOutput(v **ListAliasesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListAliasesOutput
if *v == nil {
sv = &ListAliasesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Aliases":
if err := awsAwsjson10_deserializeDocumentAliases(&sv.Aliases, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListKeysOutput(v **ListKeysOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListKeysOutput
if *v == nil {
sv = &ListKeysOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Keys":
if err := awsAwsjson10_deserializeDocumentKeySummaryList(&sv.Keys, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListTagsForResourceOutput
if *v == nil {
sv = &ListTagsForResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Tags":
if err := awsAwsjson10_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentRestoreKeyOutput(v **RestoreKeyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *RestoreKeyOutput
if *v == nil {
sv = &RestoreKeyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if err := awsAwsjson10_deserializeDocumentKey(&sv.Key, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentStartKeyUsageOutput(v **StartKeyUsageOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *StartKeyUsageOutput
if *v == nil {
sv = &StartKeyUsageOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if err := awsAwsjson10_deserializeDocumentKey(&sv.Key, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentStopKeyUsageOutput(v **StopKeyUsageOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *StopKeyUsageOutput
if *v == nil {
sv = &StopKeyUsageOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if err := awsAwsjson10_deserializeDocumentKey(&sv.Key, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *TagResourceOutput
if *v == nil {
sv = &TagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UntagResourceOutput
if *v == nil {
sv = &UntagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson10_deserializeOpDocumentUpdateAliasOutput(v **UpdateAliasOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateAliasOutput
if *v == nil {
sv = &UpdateAliasOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Alias":
if err := awsAwsjson10_deserializeDocumentAlias(&sv.Alias, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 4,742 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/paymentcryptography/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// EndpointResolverFunc is a helper utility that wraps a function so it satisfies
// the EndpointResolver interface. This is useful when you want to add additional
// endpoint resolving logic, or stub out specific endpoints with custom values.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// EndpointResolverFromURL returns an EndpointResolver configured using the
// provided endpoint url. By default, the resolved endpoint resolver uses the
// client region as signing region, and the endpoint source is set to
// EndpointSourceCustom.You can provide functional options to configure endpoint
// values for the resolved endpoint.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "payment-cryptography"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package paymentcryptography
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.0.2"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"path"
)
type awsAwsjson10_serializeOpCreateAlias struct {
}
func (*awsAwsjson10_serializeOpCreateAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpCreateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.CreateAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentCreateAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpCreateKey struct {
}
func (*awsAwsjson10_serializeOpCreateKey) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpCreateKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*CreateKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.CreateKey")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentCreateKeyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpDeleteAlias struct {
}
func (*awsAwsjson10_serializeOpDeleteAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpDeleteAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.DeleteAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentDeleteAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpDeleteKey struct {
}
func (*awsAwsjson10_serializeOpDeleteKey) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpDeleteKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DeleteKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.DeleteKey")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentDeleteKeyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpExportKey struct {
}
func (*awsAwsjson10_serializeOpExportKey) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpExportKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ExportKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.ExportKey")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentExportKeyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpGetAlias struct {
}
func (*awsAwsjson10_serializeOpGetAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpGetAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.GetAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentGetAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpGetKey struct {
}
func (*awsAwsjson10_serializeOpGetKey) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpGetKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.GetKey")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentGetKeyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpGetParametersForExport struct {
}
func (*awsAwsjson10_serializeOpGetParametersForExport) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpGetParametersForExport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetParametersForExportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.GetParametersForExport")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentGetParametersForExportInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpGetParametersForImport struct {
}
func (*awsAwsjson10_serializeOpGetParametersForImport) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpGetParametersForImport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetParametersForImportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.GetParametersForImport")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentGetParametersForImportInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpGetPublicKeyCertificate struct {
}
func (*awsAwsjson10_serializeOpGetPublicKeyCertificate) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpGetPublicKeyCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GetPublicKeyCertificateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.GetPublicKeyCertificate")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentGetPublicKeyCertificateInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpImportKey struct {
}
func (*awsAwsjson10_serializeOpImportKey) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpImportKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ImportKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.ImportKey")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentImportKeyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpListAliases struct {
}
func (*awsAwsjson10_serializeOpListAliases) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpListAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListAliasesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.ListAliases")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentListAliasesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpListKeys struct {
}
func (*awsAwsjson10_serializeOpListKeys) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpListKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListKeysInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.ListKeys")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentListKeysInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpListTagsForResource struct {
}
func (*awsAwsjson10_serializeOpListTagsForResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ListTagsForResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.ListTagsForResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpRestoreKey struct {
}
func (*awsAwsjson10_serializeOpRestoreKey) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpRestoreKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*RestoreKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.RestoreKey")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentRestoreKeyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpStartKeyUsage struct {
}
func (*awsAwsjson10_serializeOpStartKeyUsage) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpStartKeyUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StartKeyUsageInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.StartKeyUsage")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentStartKeyUsageInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpStopKeyUsage struct {
}
func (*awsAwsjson10_serializeOpStopKeyUsage) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpStopKeyUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*StopKeyUsageInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.StopKeyUsage")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentStopKeyUsageInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpTagResource struct {
}
func (*awsAwsjson10_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*TagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.TagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpUntagResource struct {
}
func (*awsAwsjson10_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UntagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.UntagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson10_serializeOpUpdateAlias struct {
}
func (*awsAwsjson10_serializeOpUpdateAlias) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson10_serializeOpUpdateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UpdateAliasInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.0")
httpBindingEncoder.SetHeader("X-Amz-Target").String("PaymentCryptographyControlPlane.UpdateAlias")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson10_serializeOpDocumentUpdateAliasInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsAwsjson10_serializeDocumentExportKeyMaterial(v types.ExportKeyMaterial, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.ExportKeyMaterialMemberTr31KeyBlock:
av := object.Key("Tr31KeyBlock")
if err := awsAwsjson10_serializeDocumentExportTr31KeyBlock(&uv.Value, av); err != nil {
return err
}
case *types.ExportKeyMaterialMemberTr34KeyBlock:
av := object.Key("Tr34KeyBlock")
if err := awsAwsjson10_serializeDocumentExportTr34KeyBlock(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsAwsjson10_serializeDocumentExportTr31KeyBlock(v *types.ExportTr31KeyBlock, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.WrappingKeyIdentifier != nil {
ok := object.Key("WrappingKeyIdentifier")
ok.String(*v.WrappingKeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeDocumentExportTr34KeyBlock(v *types.ExportTr34KeyBlock, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CertificateAuthorityPublicKeyIdentifier != nil {
ok := object.Key("CertificateAuthorityPublicKeyIdentifier")
ok.String(*v.CertificateAuthorityPublicKeyIdentifier)
}
if v.ExportToken != nil {
ok := object.Key("ExportToken")
ok.String(*v.ExportToken)
}
if len(v.KeyBlockFormat) > 0 {
ok := object.Key("KeyBlockFormat")
ok.String(string(v.KeyBlockFormat))
}
if v.RandomNonce != nil {
ok := object.Key("RandomNonce")
ok.String(*v.RandomNonce)
}
if v.WrappingKeyCertificate != nil {
ok := object.Key("WrappingKeyCertificate")
ok.String(*v.WrappingKeyCertificate)
}
return nil
}
func awsAwsjson10_serializeDocumentImportKeyMaterial(v types.ImportKeyMaterial, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.ImportKeyMaterialMemberRootCertificatePublicKey:
av := object.Key("RootCertificatePublicKey")
if err := awsAwsjson10_serializeDocumentRootCertificatePublicKey(&uv.Value, av); err != nil {
return err
}
case *types.ImportKeyMaterialMemberTr31KeyBlock:
av := object.Key("Tr31KeyBlock")
if err := awsAwsjson10_serializeDocumentImportTr31KeyBlock(&uv.Value, av); err != nil {
return err
}
case *types.ImportKeyMaterialMemberTr34KeyBlock:
av := object.Key("Tr34KeyBlock")
if err := awsAwsjson10_serializeDocumentImportTr34KeyBlock(&uv.Value, av); err != nil {
return err
}
case *types.ImportKeyMaterialMemberTrustedCertificatePublicKey:
av := object.Key("TrustedCertificatePublicKey")
if err := awsAwsjson10_serializeDocumentTrustedCertificatePublicKey(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsAwsjson10_serializeDocumentImportTr31KeyBlock(v *types.ImportTr31KeyBlock, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.WrappedKeyBlock != nil {
ok := object.Key("WrappedKeyBlock")
ok.String(*v.WrappedKeyBlock)
}
if v.WrappingKeyIdentifier != nil {
ok := object.Key("WrappingKeyIdentifier")
ok.String(*v.WrappingKeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeDocumentImportTr34KeyBlock(v *types.ImportTr34KeyBlock, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CertificateAuthorityPublicKeyIdentifier != nil {
ok := object.Key("CertificateAuthorityPublicKeyIdentifier")
ok.String(*v.CertificateAuthorityPublicKeyIdentifier)
}
if v.ImportToken != nil {
ok := object.Key("ImportToken")
ok.String(*v.ImportToken)
}
if len(v.KeyBlockFormat) > 0 {
ok := object.Key("KeyBlockFormat")
ok.String(string(v.KeyBlockFormat))
}
if v.RandomNonce != nil {
ok := object.Key("RandomNonce")
ok.String(*v.RandomNonce)
}
if v.SigningKeyCertificate != nil {
ok := object.Key("SigningKeyCertificate")
ok.String(*v.SigningKeyCertificate)
}
if v.WrappedKeyBlock != nil {
ok := object.Key("WrappedKeyBlock")
ok.String(*v.WrappedKeyBlock)
}
return nil
}
func awsAwsjson10_serializeDocumentKeyAttributes(v *types.KeyAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.KeyAlgorithm) > 0 {
ok := object.Key("KeyAlgorithm")
ok.String(string(v.KeyAlgorithm))
}
if len(v.KeyClass) > 0 {
ok := object.Key("KeyClass")
ok.String(string(v.KeyClass))
}
if v.KeyModesOfUse != nil {
ok := object.Key("KeyModesOfUse")
if err := awsAwsjson10_serializeDocumentKeyModesOfUse(v.KeyModesOfUse, ok); err != nil {
return err
}
}
if len(v.KeyUsage) > 0 {
ok := object.Key("KeyUsage")
ok.String(string(v.KeyUsage))
}
return nil
}
func awsAwsjson10_serializeDocumentKeyModesOfUse(v *types.KeyModesOfUse, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Decrypt {
ok := object.Key("Decrypt")
ok.Boolean(v.Decrypt)
}
if v.DeriveKey {
ok := object.Key("DeriveKey")
ok.Boolean(v.DeriveKey)
}
if v.Encrypt {
ok := object.Key("Encrypt")
ok.Boolean(v.Encrypt)
}
if v.Generate {
ok := object.Key("Generate")
ok.Boolean(v.Generate)
}
if v.NoRestrictions {
ok := object.Key("NoRestrictions")
ok.Boolean(v.NoRestrictions)
}
if v.Sign {
ok := object.Key("Sign")
ok.Boolean(v.Sign)
}
if v.Unwrap {
ok := object.Key("Unwrap")
ok.Boolean(v.Unwrap)
}
if v.Verify {
ok := object.Key("Verify")
ok.Boolean(v.Verify)
}
if v.Wrap {
ok := object.Key("Wrap")
ok.Boolean(v.Wrap)
}
return nil
}
func awsAwsjson10_serializeDocumentRootCertificatePublicKey(v *types.RootCertificatePublicKey, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyAttributes != nil {
ok := object.Key("KeyAttributes")
if err := awsAwsjson10_serializeDocumentKeyAttributes(v.KeyAttributes, ok); err != nil {
return err
}
}
if v.PublicKeyCertificate != nil {
ok := object.Key("PublicKeyCertificate")
ok.String(*v.PublicKeyCertificate)
}
return nil
}
func awsAwsjson10_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Key != nil {
ok := object.Key("Key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsAwsjson10_serializeDocumentTagKeys(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson10_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson10_serializeDocumentTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson10_serializeDocumentTrustedCertificatePublicKey(v *types.TrustedCertificatePublicKey, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CertificateAuthorityPublicKeyIdentifier != nil {
ok := object.Key("CertificateAuthorityPublicKeyIdentifier")
ok.String(*v.CertificateAuthorityPublicKeyIdentifier)
}
if v.KeyAttributes != nil {
ok := object.Key("KeyAttributes")
if err := awsAwsjson10_serializeDocumentKeyAttributes(v.KeyAttributes, ok); err != nil {
return err
}
}
if v.PublicKeyCertificate != nil {
ok := object.Key("PublicKeyCertificate")
ok.String(*v.PublicKeyCertificate)
}
return nil
}
func awsAwsjson10_serializeOpDocumentCreateAliasInput(v *CreateAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasName != nil {
ok := object.Key("AliasName")
ok.String(*v.AliasName)
}
if v.KeyArn != nil {
ok := object.Key("KeyArn")
ok.String(*v.KeyArn)
}
return nil
}
func awsAwsjson10_serializeOpDocumentCreateKeyInput(v *CreateKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Enabled != nil {
ok := object.Key("Enabled")
ok.Boolean(*v.Enabled)
}
if v.Exportable != nil {
ok := object.Key("Exportable")
ok.Boolean(*v.Exportable)
}
if v.KeyAttributes != nil {
ok := object.Key("KeyAttributes")
if err := awsAwsjson10_serializeDocumentKeyAttributes(v.KeyAttributes, ok); err != nil {
return err
}
}
if len(v.KeyCheckValueAlgorithm) > 0 {
ok := object.Key("KeyCheckValueAlgorithm")
ok.String(string(v.KeyCheckValueAlgorithm))
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson10_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson10_serializeOpDocumentDeleteAliasInput(v *DeleteAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasName != nil {
ok := object.Key("AliasName")
ok.String(*v.AliasName)
}
return nil
}
func awsAwsjson10_serializeOpDocumentDeleteKeyInput(v *DeleteKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeleteKeyInDays != nil {
ok := object.Key("DeleteKeyInDays")
ok.Integer(*v.DeleteKeyInDays)
}
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeOpDocumentExportKeyInput(v *ExportKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ExportKeyIdentifier != nil {
ok := object.Key("ExportKeyIdentifier")
ok.String(*v.ExportKeyIdentifier)
}
if v.KeyMaterial != nil {
ok := object.Key("KeyMaterial")
if err := awsAwsjson10_serializeDocumentExportKeyMaterial(v.KeyMaterial, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson10_serializeOpDocumentGetAliasInput(v *GetAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasName != nil {
ok := object.Key("AliasName")
ok.String(*v.AliasName)
}
return nil
}
func awsAwsjson10_serializeOpDocumentGetKeyInput(v *GetKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeOpDocumentGetParametersForExportInput(v *GetParametersForExportInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.KeyMaterialType) > 0 {
ok := object.Key("KeyMaterialType")
ok.String(string(v.KeyMaterialType))
}
if len(v.SigningKeyAlgorithm) > 0 {
ok := object.Key("SigningKeyAlgorithm")
ok.String(string(v.SigningKeyAlgorithm))
}
return nil
}
func awsAwsjson10_serializeOpDocumentGetParametersForImportInput(v *GetParametersForImportInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.KeyMaterialType) > 0 {
ok := object.Key("KeyMaterialType")
ok.String(string(v.KeyMaterialType))
}
if len(v.WrappingKeyAlgorithm) > 0 {
ok := object.Key("WrappingKeyAlgorithm")
ok.String(string(v.WrappingKeyAlgorithm))
}
return nil
}
func awsAwsjson10_serializeOpDocumentGetPublicKeyCertificateInput(v *GetPublicKeyCertificateInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeOpDocumentImportKeyInput(v *ImportKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Enabled != nil {
ok := object.Key("Enabled")
ok.Boolean(*v.Enabled)
}
if len(v.KeyCheckValueAlgorithm) > 0 {
ok := object.Key("KeyCheckValueAlgorithm")
ok.String(string(v.KeyCheckValueAlgorithm))
}
if v.KeyMaterial != nil {
ok := object.Key("KeyMaterial")
if err := awsAwsjson10_serializeDocumentImportKeyMaterial(v.KeyMaterial, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson10_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson10_serializeOpDocumentListAliasesInput(v *ListAliasesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson10_serializeOpDocumentListKeysInput(v *ListKeysInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.KeyState) > 0 {
ok := object.Key("KeyState")
ok.String(string(v.KeyState))
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson10_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
return nil
}
func awsAwsjson10_serializeOpDocumentRestoreKeyInput(v *RestoreKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeOpDocumentStartKeyUsageInput(v *StartKeyUsageInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeOpDocumentStopKeyUsageInput(v *StopKeyUsageInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
return nil
}
func awsAwsjson10_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson10_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson10_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.TagKeys != nil {
ok := object.Key("TagKeys")
if err := awsAwsjson10_serializeDocumentTagKeys(v.TagKeys, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson10_serializeOpDocumentUpdateAliasInput(v *UpdateAliasInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AliasName != nil {
ok := object.Key("AliasName")
ok.String(*v.AliasName)
}
if v.KeyArn != nil {
ok := object.Key("KeyArn")
ok.String(*v.KeyArn)
}
return nil
}
| 1,793 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptography
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpCreateAlias struct {
}
func (*validateOpCreateAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateKey struct {
}
func (*validateOpCreateKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAlias struct {
}
func (*validateOpDeleteAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteKey struct {
}
func (*validateOpDeleteKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpExportKey struct {
}
func (*validateOpExportKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpExportKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ExportKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpExportKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetAlias struct {
}
func (*validateOpGetAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetKey struct {
}
func (*validateOpGetKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetParametersForExport struct {
}
func (*validateOpGetParametersForExport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetParametersForExport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetParametersForExportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetParametersForExportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetParametersForImport struct {
}
func (*validateOpGetParametersForImport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetParametersForImport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetParametersForImportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetParametersForImportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPublicKeyCertificate struct {
}
func (*validateOpGetPublicKeyCertificate) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPublicKeyCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPublicKeyCertificateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPublicKeyCertificateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpImportKey struct {
}
func (*validateOpImportKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpImportKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ImportKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpImportKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListTagsForResource struct {
}
func (*validateOpListTagsForResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListTagsForResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListTagsForResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRestoreKey struct {
}
func (*validateOpRestoreKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRestoreKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RestoreKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRestoreKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartKeyUsage struct {
}
func (*validateOpStartKeyUsage) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartKeyUsage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartKeyUsageInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartKeyUsageInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopKeyUsage struct {
}
func (*validateOpStopKeyUsage) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopKeyUsage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopKeyUsageInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopKeyUsageInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpTagResource struct {
}
func (*validateOpTagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*TagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpTagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUntagResource struct {
}
func (*validateOpUntagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UntagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUntagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateAlias struct {
}
func (*validateOpUpdateAlias) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateAliasInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateAliasInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpCreateAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateAlias{}, middleware.After)
}
func addOpCreateKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateKey{}, middleware.After)
}
func addOpDeleteAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAlias{}, middleware.After)
}
func addOpDeleteKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteKey{}, middleware.After)
}
func addOpExportKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpExportKey{}, middleware.After)
}
func addOpGetAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetAlias{}, middleware.After)
}
func addOpGetKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetKey{}, middleware.After)
}
func addOpGetParametersForExportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetParametersForExport{}, middleware.After)
}
func addOpGetParametersForImportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetParametersForImport{}, middleware.After)
}
func addOpGetPublicKeyCertificateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPublicKeyCertificate{}, middleware.After)
}
func addOpImportKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpImportKey{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpRestoreKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRestoreKey{}, middleware.After)
}
func addOpStartKeyUsageValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartKeyUsage{}, middleware.After)
}
func addOpStopKeyUsageValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopKeyUsage{}, middleware.After)
}
func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}
func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}
func addOpUpdateAliasValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateAlias{}, middleware.After)
}
func validateExportKeyMaterial(v types.ExportKeyMaterial) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportKeyMaterial"}
switch uv := v.(type) {
case *types.ExportKeyMaterialMemberTr31KeyBlock:
if err := validateExportTr31KeyBlock(&uv.Value); err != nil {
invalidParams.AddNested("[Tr31KeyBlock]", err.(smithy.InvalidParamsError))
}
case *types.ExportKeyMaterialMemberTr34KeyBlock:
if err := validateExportTr34KeyBlock(&uv.Value); err != nil {
invalidParams.AddNested("[Tr34KeyBlock]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateExportTr31KeyBlock(v *types.ExportTr31KeyBlock) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportTr31KeyBlock"}
if v.WrappingKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("WrappingKeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateExportTr34KeyBlock(v *types.ExportTr34KeyBlock) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportTr34KeyBlock"}
if v.CertificateAuthorityPublicKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityPublicKeyIdentifier"))
}
if v.WrappingKeyCertificate == nil {
invalidParams.Add(smithy.NewErrParamRequired("WrappingKeyCertificate"))
}
if v.ExportToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ExportToken"))
}
if len(v.KeyBlockFormat) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("KeyBlockFormat"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateImportKeyMaterial(v types.ImportKeyMaterial) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ImportKeyMaterial"}
switch uv := v.(type) {
case *types.ImportKeyMaterialMemberRootCertificatePublicKey:
if err := validateRootCertificatePublicKey(&uv.Value); err != nil {
invalidParams.AddNested("[RootCertificatePublicKey]", err.(smithy.InvalidParamsError))
}
case *types.ImportKeyMaterialMemberTr31KeyBlock:
if err := validateImportTr31KeyBlock(&uv.Value); err != nil {
invalidParams.AddNested("[Tr31KeyBlock]", err.(smithy.InvalidParamsError))
}
case *types.ImportKeyMaterialMemberTr34KeyBlock:
if err := validateImportTr34KeyBlock(&uv.Value); err != nil {
invalidParams.AddNested("[Tr34KeyBlock]", err.(smithy.InvalidParamsError))
}
case *types.ImportKeyMaterialMemberTrustedCertificatePublicKey:
if err := validateTrustedCertificatePublicKey(&uv.Value); err != nil {
invalidParams.AddNested("[TrustedCertificatePublicKey]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateImportTr31KeyBlock(v *types.ImportTr31KeyBlock) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ImportTr31KeyBlock"}
if v.WrappingKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("WrappingKeyIdentifier"))
}
if v.WrappedKeyBlock == nil {
invalidParams.Add(smithy.NewErrParamRequired("WrappedKeyBlock"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateImportTr34KeyBlock(v *types.ImportTr34KeyBlock) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ImportTr34KeyBlock"}
if v.CertificateAuthorityPublicKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityPublicKeyIdentifier"))
}
if v.SigningKeyCertificate == nil {
invalidParams.Add(smithy.NewErrParamRequired("SigningKeyCertificate"))
}
if v.ImportToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ImportToken"))
}
if v.WrappedKeyBlock == nil {
invalidParams.Add(smithy.NewErrParamRequired("WrappedKeyBlock"))
}
if len(v.KeyBlockFormat) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("KeyBlockFormat"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateKeyAttributes(v *types.KeyAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "KeyAttributes"}
if len(v.KeyUsage) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("KeyUsage"))
}
if len(v.KeyClass) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("KeyClass"))
}
if len(v.KeyAlgorithm) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("KeyAlgorithm"))
}
if v.KeyModesOfUse == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyModesOfUse"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRootCertificatePublicKey(v *types.RootCertificatePublicKey) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RootCertificatePublicKey"}
if v.KeyAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyAttributes"))
} else if v.KeyAttributes != nil {
if err := validateKeyAttributes(v.KeyAttributes); err != nil {
invalidParams.AddNested("KeyAttributes", err.(smithy.InvalidParamsError))
}
}
if v.PublicKeyCertificate == nil {
invalidParams.Add(smithy.NewErrParamRequired("PublicKeyCertificate"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTag(v *types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tag"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTags(v []types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tags"}
for i := range v {
if err := validateTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTrustedCertificatePublicKey(v *types.TrustedCertificatePublicKey) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TrustedCertificatePublicKey"}
if v.KeyAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyAttributes"))
} else if v.KeyAttributes != nil {
if err := validateKeyAttributes(v.KeyAttributes); err != nil {
invalidParams.AddNested("KeyAttributes", err.(smithy.InvalidParamsError))
}
}
if v.PublicKeyCertificate == nil {
invalidParams.Add(smithy.NewErrParamRequired("PublicKeyCertificate"))
}
if v.CertificateAuthorityPublicKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityPublicKeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateAliasInput(v *CreateAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateAliasInput"}
if v.AliasName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateKeyInput(v *CreateKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateKeyInput"}
if v.KeyAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyAttributes"))
} else if v.KeyAttributes != nil {
if err := validateKeyAttributes(v.KeyAttributes); err != nil {
invalidParams.AddNested("KeyAttributes", err.(smithy.InvalidParamsError))
}
}
if v.Exportable == nil {
invalidParams.Add(smithy.NewErrParamRequired("Exportable"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAliasInput(v *DeleteAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAliasInput"}
if v.AliasName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteKeyInput(v *DeleteKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteKeyInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpExportKeyInput(v *ExportKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportKeyInput"}
if v.KeyMaterial == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyMaterial"))
} else if v.KeyMaterial != nil {
if err := validateExportKeyMaterial(v.KeyMaterial); err != nil {
invalidParams.AddNested("KeyMaterial", err.(smithy.InvalidParamsError))
}
}
if v.ExportKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ExportKeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetAliasInput(v *GetAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetAliasInput"}
if v.AliasName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetKeyInput(v *GetKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetKeyInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetParametersForExportInput(v *GetParametersForExportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetParametersForExportInput"}
if len(v.KeyMaterialType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("KeyMaterialType"))
}
if len(v.SigningKeyAlgorithm) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("SigningKeyAlgorithm"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetParametersForImportInput(v *GetParametersForImportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetParametersForImportInput"}
if len(v.KeyMaterialType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("KeyMaterialType"))
}
if len(v.WrappingKeyAlgorithm) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("WrappingKeyAlgorithm"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPublicKeyCertificateInput(v *GetPublicKeyCertificateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPublicKeyCertificateInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpImportKeyInput(v *ImportKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ImportKeyInput"}
if v.KeyMaterial == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyMaterial"))
} else if v.KeyMaterial != nil {
if err := validateImportKeyMaterial(v.KeyMaterial); err != nil {
invalidParams.AddNested("KeyMaterial", err.(smithy.InvalidParamsError))
}
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRestoreKeyInput(v *RestoreKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RestoreKeyInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartKeyUsageInput(v *StartKeyUsageInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartKeyUsageInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopKeyUsageInput(v *StopKeyUsageInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopKeyUsageInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTagResourceInput(v *TagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
} else if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUntagResourceInput(v *UntagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.TagKeys == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateAliasInput(v *UpdateAliasInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateAliasInput"}
if v.AliasName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 1,003 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver Payment Cryptography endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "controlplane.payment-cryptography.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "controlplane.payment-cryptography.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "controlplane.payment-cryptography.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "controlplane.payment-cryptography.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "controlplane.payment-cryptography.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "controlplane.payment-cryptography.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "controlplane.payment-cryptography.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "controlplane.payment-cryptography.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "controlplane.payment-cryptography.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "controlplane.payment-cryptography-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "controlplane.payment-cryptography.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 297 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type KeyAlgorithm string
// Enum values for KeyAlgorithm
const (
KeyAlgorithmTdes2key KeyAlgorithm = "TDES_2KEY"
KeyAlgorithmTdes3key KeyAlgorithm = "TDES_3KEY"
KeyAlgorithmAes128 KeyAlgorithm = "AES_128"
KeyAlgorithmAes192 KeyAlgorithm = "AES_192"
KeyAlgorithmAes256 KeyAlgorithm = "AES_256"
KeyAlgorithmRsa2048 KeyAlgorithm = "RSA_2048"
KeyAlgorithmRsa3072 KeyAlgorithm = "RSA_3072"
KeyAlgorithmRsa4096 KeyAlgorithm = "RSA_4096"
)
// Values returns all known values for KeyAlgorithm. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (KeyAlgorithm) Values() []KeyAlgorithm {
return []KeyAlgorithm{
"TDES_2KEY",
"TDES_3KEY",
"AES_128",
"AES_192",
"AES_256",
"RSA_2048",
"RSA_3072",
"RSA_4096",
}
}
type KeyCheckValueAlgorithm string
// Enum values for KeyCheckValueAlgorithm
const (
KeyCheckValueAlgorithmCmac KeyCheckValueAlgorithm = "CMAC"
KeyCheckValueAlgorithmAnsiX924 KeyCheckValueAlgorithm = "ANSI_X9_24"
)
// Values returns all known values for KeyCheckValueAlgorithm. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (KeyCheckValueAlgorithm) Values() []KeyCheckValueAlgorithm {
return []KeyCheckValueAlgorithm{
"CMAC",
"ANSI_X9_24",
}
}
type KeyClass string
// Enum values for KeyClass
const (
KeyClassSymmetricKey KeyClass = "SYMMETRIC_KEY"
KeyClassAsymmetricKeyPair KeyClass = "ASYMMETRIC_KEY_PAIR"
KeyClassPrivateKey KeyClass = "PRIVATE_KEY"
KeyClassPublicKey KeyClass = "PUBLIC_KEY"
)
// Values returns all known values for KeyClass. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (KeyClass) Values() []KeyClass {
return []KeyClass{
"SYMMETRIC_KEY",
"ASYMMETRIC_KEY_PAIR",
"PRIVATE_KEY",
"PUBLIC_KEY",
}
}
type KeyMaterialType string
// Enum values for KeyMaterialType
const (
KeyMaterialTypeTr34KeyBlock KeyMaterialType = "TR34_KEY_BLOCK"
KeyMaterialTypeTr31KeyBlock KeyMaterialType = "TR31_KEY_BLOCK"
KeyMaterialTypeRootPublicKeyCertificate KeyMaterialType = "ROOT_PUBLIC_KEY_CERTIFICATE"
KeyMaterialTypeTrustedPublicKeyCertificate KeyMaterialType = "TRUSTED_PUBLIC_KEY_CERTIFICATE"
)
// Values returns all known values for KeyMaterialType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (KeyMaterialType) Values() []KeyMaterialType {
return []KeyMaterialType{
"TR34_KEY_BLOCK",
"TR31_KEY_BLOCK",
"ROOT_PUBLIC_KEY_CERTIFICATE",
"TRUSTED_PUBLIC_KEY_CERTIFICATE",
}
}
type KeyOrigin string
// Enum values for KeyOrigin
const (
KeyOriginExternal KeyOrigin = "EXTERNAL"
KeyOriginAwsPaymentCryptography KeyOrigin = "AWS_PAYMENT_CRYPTOGRAPHY"
)
// Values returns all known values for KeyOrigin. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (KeyOrigin) Values() []KeyOrigin {
return []KeyOrigin{
"EXTERNAL",
"AWS_PAYMENT_CRYPTOGRAPHY",
}
}
type KeyState string
// Enum values for KeyState
const (
KeyStateCreateInProgress KeyState = "CREATE_IN_PROGRESS"
KeyStateCreateComplete KeyState = "CREATE_COMPLETE"
KeyStateDeletePending KeyState = "DELETE_PENDING"
KeyStateDeleteComplete KeyState = "DELETE_COMPLETE"
)
// Values returns all known values for KeyState. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (KeyState) Values() []KeyState {
return []KeyState{
"CREATE_IN_PROGRESS",
"CREATE_COMPLETE",
"DELETE_PENDING",
"DELETE_COMPLETE",
}
}
type KeyUsage string
// Enum values for KeyUsage
const (
KeyUsageTr31B0BaseDerivationKey KeyUsage = "TR31_B0_BASE_DERIVATION_KEY"
KeyUsageTr31C0CardVerificationKey KeyUsage = "TR31_C0_CARD_VERIFICATION_KEY"
KeyUsageTr31D0SymmetricDataEncryptionKey KeyUsage = "TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY"
KeyUsageTr31D1AsymmetricKeyForDataEncryption KeyUsage = "TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION"
KeyUsageTr31E0EmvMkeyAppCryptograms KeyUsage = "TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS"
KeyUsageTr31E1EmvMkeyConfidentiality KeyUsage = "TR31_E1_EMV_MKEY_CONFIDENTIALITY"
KeyUsageTr31E2EmvMkeyIntegrity KeyUsage = "TR31_E2_EMV_MKEY_INTEGRITY"
KeyUsageTr31E4EmvMkeyDynamicNumbers KeyUsage = "TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS"
KeyUsageTr31E5EmvMkeyCardPersonalization KeyUsage = "TR31_E5_EMV_MKEY_CARD_PERSONALIZATION"
KeyUsageTr31E6EmvMkeyOther KeyUsage = "TR31_E6_EMV_MKEY_OTHER"
KeyUsageTr31K0KeyEncryptionKey KeyUsage = "TR31_K0_KEY_ENCRYPTION_KEY"
KeyUsageTr31K1KeyBlockProtectionKey KeyUsage = "TR31_K1_KEY_BLOCK_PROTECTION_KEY"
KeyUsageTr31K3AsymmetricKeyForKeyAgreement KeyUsage = "TR31_K3_ASYMMETRIC_KEY_FOR_KEY_AGREEMENT"
KeyUsageTr31M3Iso97973MacKey KeyUsage = "TR31_M3_ISO_9797_3_MAC_KEY"
KeyUsageTr31M6Iso97975CmacKey KeyUsage = "TR31_M6_ISO_9797_5_CMAC_KEY"
KeyUsageTr31M7HmacKey KeyUsage = "TR31_M7_HMAC_KEY"
KeyUsageTr31P0PinEncryptionKey KeyUsage = "TR31_P0_PIN_ENCRYPTION_KEY"
KeyUsageTr31P1PinGenerationKey KeyUsage = "TR31_P1_PIN_GENERATION_KEY"
KeyUsageTr31S0AsymmetricKeyForDigitalSignature KeyUsage = "TR31_S0_ASYMMETRIC_KEY_FOR_DIGITAL_SIGNATURE"
KeyUsageTr31V1Ibm3624PinVerificationKey KeyUsage = "TR31_V1_IBM3624_PIN_VERIFICATION_KEY"
KeyUsageTr31V2VisaPinVerificationKey KeyUsage = "TR31_V2_VISA_PIN_VERIFICATION_KEY"
KeyUsageTr31K2Tr34AsymmetricKey KeyUsage = "TR31_K2_TR34_ASYMMETRIC_KEY"
)
// Values returns all known values for KeyUsage. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (KeyUsage) Values() []KeyUsage {
return []KeyUsage{
"TR31_B0_BASE_DERIVATION_KEY",
"TR31_C0_CARD_VERIFICATION_KEY",
"TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY",
"TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION",
"TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS",
"TR31_E1_EMV_MKEY_CONFIDENTIALITY",
"TR31_E2_EMV_MKEY_INTEGRITY",
"TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS",
"TR31_E5_EMV_MKEY_CARD_PERSONALIZATION",
"TR31_E6_EMV_MKEY_OTHER",
"TR31_K0_KEY_ENCRYPTION_KEY",
"TR31_K1_KEY_BLOCK_PROTECTION_KEY",
"TR31_K3_ASYMMETRIC_KEY_FOR_KEY_AGREEMENT",
"TR31_M3_ISO_9797_3_MAC_KEY",
"TR31_M6_ISO_9797_5_CMAC_KEY",
"TR31_M7_HMAC_KEY",
"TR31_P0_PIN_ENCRYPTION_KEY",
"TR31_P1_PIN_GENERATION_KEY",
"TR31_S0_ASYMMETRIC_KEY_FOR_DIGITAL_SIGNATURE",
"TR31_V1_IBM3624_PIN_VERIFICATION_KEY",
"TR31_V2_VISA_PIN_VERIFICATION_KEY",
"TR31_K2_TR34_ASYMMETRIC_KEY",
}
}
type Tr34KeyBlockFormat string
// Enum values for Tr34KeyBlockFormat
const (
Tr34KeyBlockFormatX9Tr342012 Tr34KeyBlockFormat = "X9_TR34_2012"
)
// Values returns all known values for Tr34KeyBlockFormat. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (Tr34KeyBlockFormat) Values() []Tr34KeyBlockFormat {
return []Tr34KeyBlockFormat{
"X9_TR34_2012",
}
}
type WrappedKeyMaterialFormat string
// Enum values for WrappedKeyMaterialFormat
const (
WrappedKeyMaterialFormatKeyCryptogram WrappedKeyMaterialFormat = "KEY_CRYPTOGRAM"
WrappedKeyMaterialFormatTr31KeyBlock WrappedKeyMaterialFormat = "TR31_KEY_BLOCK"
WrappedKeyMaterialFormatTr34KeyBlock WrappedKeyMaterialFormat = "TR34_KEY_BLOCK"
)
// Values returns all known values for WrappedKeyMaterialFormat. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (WrappedKeyMaterialFormat) Values() []WrappedKeyMaterialFormat {
return []WrappedKeyMaterialFormat{
"KEY_CRYPTOGRAM",
"TR31_KEY_BLOCK",
"TR34_KEY_BLOCK",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// You do not have sufficient access to perform this action.
type AccessDeniedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AccessDeniedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AccessDeniedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AccessDeniedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AccessDeniedException"
}
return *e.ErrorCodeOverride
}
func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// This request can cause an inconsistent state for the resource.
type ConflictException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ConflictException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ConflictException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ConflictException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ConflictException"
}
return *e.ErrorCodeOverride
}
func (e *ConflictException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request processing has failed because of an unknown error, exception, or
// failure.
type InternalServerException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalServerException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServerException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServerException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServerException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The request was denied due to an invalid resource error.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// This request would cause a service quota to be exceeded.
type ServiceQuotaExceededException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceQuotaExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceQuotaExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceQuotaExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceQuotaExceededException"
}
return *e.ErrorCodeOverride
}
func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The service cannot complete the request.
type ServiceUnavailableException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceUnavailableException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceUnavailableException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceUnavailableException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceUnavailableException"
}
return *e.ErrorCodeOverride
}
func (e *ServiceUnavailableException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The request was denied due to request throttling.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ThrottlingException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ThrottlingException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ThrottlingException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ThrottlingException"
}
return *e.ErrorCodeOverride
}
func (e *ThrottlingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request was denied due to an invalid request error.
type ValidationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ValidationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationException"
}
return *e.ErrorCodeOverride
}
func (e *ValidationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 220 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types_test
import (
"fmt"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
)
func ExampleExportKeyMaterial_outputUsage() {
var union types.ExportKeyMaterial
// type switches can be used to check the union value
switch v := union.(type) {
case *types.ExportKeyMaterialMemberTr31KeyBlock:
_ = v.Value // Value is types.ExportTr31KeyBlock
case *types.ExportKeyMaterialMemberTr34KeyBlock:
_ = v.Value // Value is types.ExportTr34KeyBlock
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.ExportTr34KeyBlock
var _ *types.ExportTr31KeyBlock
func ExampleImportKeyMaterial_outputUsage() {
var union types.ImportKeyMaterial
// type switches can be used to check the union value
switch v := union.(type) {
case *types.ImportKeyMaterialMemberRootCertificatePublicKey:
_ = v.Value // Value is types.RootCertificatePublicKey
case *types.ImportKeyMaterialMemberTr31KeyBlock:
_ = v.Value // Value is types.ImportTr31KeyBlock
case *types.ImportKeyMaterialMemberTr34KeyBlock:
_ = v.Value // Value is types.ImportTr34KeyBlock
case *types.ImportKeyMaterialMemberTrustedCertificatePublicKey:
_ = v.Value // Value is types.TrustedCertificatePublicKey
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.RootCertificatePublicKey
var _ *types.TrustedCertificatePublicKey
var _ *types.ImportTr34KeyBlock
var _ *types.ImportTr31KeyBlock
| 61 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "Payment Cryptography Data"
const ServiceAPIVersion = "2022-02-03"
// Client provides the API client to make operations call for Payment Cryptography
// Data Plane.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "paymentcryptographydata", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 435 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Decrypts ciphertext data to plaintext using symmetric, asymmetric, or DUKPT
// data encryption key. For more information, see Decrypt data (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/decrypt-data.html)
// in the Amazon Web Services Payment Cryptography User Guide. You can use an
// encryption key generated within Amazon Web Services Payment Cryptography, or you
// can import your own encryption key by calling ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// . For this operation, the key must have KeyModesOfUse set to Decrypt . In
// asymmetric decryption, Amazon Web Services Payment Cryptography decrypts the
// ciphertext using the private component of the asymmetric encryption key pair.
// For data encryption outside of Amazon Web Services Payment Cryptography, you can
// export the public component of the asymmetric key pair by calling
// GetPublicCertificate (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_GetPublicKeyCertificate.html)
// . For symmetric and DUKPT decryption, Amazon Web Services Payment Cryptography
// supports TDES and AES algorithms. For asymmetric decryption, Amazon Web
// Services Payment Cryptography supports RSA . When you use DUKPT, for TDES
// algorithm, the ciphertext data length must be a multiple of 16 bytes. For AES
// algorithm, the ciphertext data length must be a multiple of 32 bytes. For
// information about valid keys for this operation, see Understanding key
// attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - EncryptData
// - GetPublicCertificate (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_GetPublicKeyCertificate.html)
// - ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
func (c *Client) DecryptData(ctx context.Context, params *DecryptDataInput, optFns ...func(*Options)) (*DecryptDataOutput, error) {
if params == nil {
params = &DecryptDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DecryptData", params, optFns, c.addOperationDecryptDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DecryptDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type DecryptDataInput struct {
// The ciphertext to decrypt.
//
// This member is required.
CipherText *string
// The encryption key type and attributes for ciphertext decryption.
//
// This member is required.
DecryptionAttributes types.EncryptionDecryptionAttributes
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses for ciphertext decryption.
//
// This member is required.
KeyIdentifier *string
noSmithyDocumentSerde
}
type DecryptDataOutput struct {
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses for ciphertext decryption.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// The decrypted plaintext data.
//
// This member is required.
PlainText *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDecryptDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDecryptData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDecryptData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDecryptDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDecryptData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDecryptData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "DecryptData",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Encrypts plaintext data to ciphertext using symmetric, asymmetric, or DUKPT
// data encryption key. For more information, see Encrypt data (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/encrypt-data.html)
// in the Amazon Web Services Payment Cryptography User Guide. You can generate an
// encryption key within Amazon Web Services Payment Cryptography by calling
// CreateKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)
// . You can import your own encryption key by calling ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// . For this operation, the key must have KeyModesOfUse set to Encrypt . In
// asymmetric encryption, plaintext is encrypted using public component. You can
// import the public component of an asymmetric key pair created outside Amazon Web
// Services Payment Cryptography by calling ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// ). for symmetric and DUKPT encryption, Amazon Web Services Payment Cryptography
// supports TDES and AES algorithms. For asymmetric encryption, Amazon Web
// Services Payment Cryptography supports RSA . To encrypt using DUKPT, you must
// already have a DUKPT key in your account with KeyModesOfUse set to DeriveKey ,
// or you can generate a new DUKPT key by calling CreateKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)
// . For information about valid keys for this operation, see Understanding key
// attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - DecryptData
// - GetPublicCertificate (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_GetPublicKeyCertificate.html)
// - ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// - ReEncryptData
func (c *Client) EncryptData(ctx context.Context, params *EncryptDataInput, optFns ...func(*Options)) (*EncryptDataOutput, error) {
if params == nil {
params = &EncryptDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "EncryptData", params, optFns, c.addOperationEncryptDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*EncryptDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type EncryptDataInput struct {
// The encryption key type and attributes for plaintext encryption.
//
// This member is required.
EncryptionAttributes types.EncryptionDecryptionAttributes
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses for plaintext encryption.
//
// This member is required.
KeyIdentifier *string
// The plaintext to be encrypted.
//
// This member is required.
PlainText *string
noSmithyDocumentSerde
}
type EncryptDataOutput struct {
// The encrypted ciphertext.
//
// This member is required.
CipherText *string
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses for plaintext encryption.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationEncryptDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpEncryptData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpEncryptData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpEncryptDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opEncryptData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opEncryptData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "EncryptData",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Generates card-related validation data using algorithms such as Card
// Verification Values (CVV/CVV2), Dynamic Card Verification Values (dCVV/dCVV2),
// or Card Security Codes (CSC). For more information, see Generate card data (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/generate-card-data.html)
// in the Amazon Web Services Payment Cryptography User Guide. This operation
// generates a CVV or CSC value that is printed on a payment credit or debit card
// during card production. The CVV or CSC, PAN (Primary Account Number) and
// expiration date of the card are required to check its validity during
// transaction processing. To begin this operation, a CVK (Card Verification Key)
// encryption key is required. You can use CreateKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)
// or ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// to establish a CVK within Amazon Web Services Payment Cryptography. The
// KeyModesOfUse should be set to Generate and Verify for a CVK encryption key.
// For information about valid keys for this operation, see Understanding key
// attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// - VerifyCardValidationData
func (c *Client) GenerateCardValidationData(ctx context.Context, params *GenerateCardValidationDataInput, optFns ...func(*Options)) (*GenerateCardValidationDataOutput, error) {
if params == nil {
params = &GenerateCardValidationDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GenerateCardValidationData", params, optFns, c.addOperationGenerateCardValidationDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GenerateCardValidationDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type GenerateCardValidationDataInput struct {
// The algorithm for generating CVV or CSC values for the card within Amazon Web
// Services Payment Cryptography.
//
// This member is required.
GenerationAttributes types.CardGenerationAttributes
// The keyARN of the CVK encryption key that Amazon Web Services Payment
// Cryptography uses to generate card data.
//
// This member is required.
KeyIdentifier *string
// The Primary Account Number (PAN), a unique identifier for a payment credit or
// debit card that associates the card with a specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
// The length of the CVV or CSC to be generated. The default value is 3.
ValidationDataLength *int32
noSmithyDocumentSerde
}
type GenerateCardValidationDataOutput struct {
// The keyARN of the CVK encryption key that Amazon Web Services Payment
// Cryptography uses to generate CVV or CSC.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// The CVV or CSC value that Amazon Web Services Payment Cryptography generates
// for the card.
//
// This member is required.
ValidationData *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGenerateCardValidationDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGenerateCardValidationData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGenerateCardValidationData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGenerateCardValidationDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGenerateCardValidationData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGenerateCardValidationData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "GenerateCardValidationData",
}
}
| 179 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Generates a Message Authentication Code (MAC) cryptogram within Amazon Web
// Services Payment Cryptography. You can use this operation when keys won't be
// shared but mutual data is present on both ends for validation. In this case,
// known data values are used to generate a MAC on both ends for comparision
// without sending or receiving data in ciphertext or plaintext. You can use this
// operation to generate a DUPKT, HMAC or EMV MAC by setting generation attributes
// and algorithm to the associated values. The MAC generation encryption key must
// have valid values for KeyUsage such as TR31_M7_HMAC_KEY for HMAC generation,
// and they key must have KeyModesOfUse set to Generate and Verify . For
// information about valid keys for this operation, see Understanding key
// attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - VerifyMac
func (c *Client) GenerateMac(ctx context.Context, params *GenerateMacInput, optFns ...func(*Options)) (*GenerateMacOutput, error) {
if params == nil {
params = &GenerateMacInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GenerateMac", params, optFns, c.addOperationGenerateMacMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GenerateMacOutput)
out.ResultMetadata = metadata
return out, nil
}
type GenerateMacInput struct {
// The attributes and data values to use for MAC generation within Amazon Web
// Services Payment Cryptography.
//
// This member is required.
GenerationAttributes types.MacAttributes
// The keyARN of the MAC generation encryption key.
//
// This member is required.
KeyIdentifier *string
// The data for which a MAC is under generation.
//
// This member is required.
MessageData *string
// The length of a MAC under generation.
MacLength *int32
noSmithyDocumentSerde
}
type GenerateMacOutput struct {
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses for MAC generation.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// The MAC cryptogram generated within Amazon Web Services Payment Cryptography.
//
// This member is required.
Mac *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGenerateMacMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGenerateMac{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGenerateMac{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGenerateMacValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGenerateMac(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGenerateMac(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "GenerateMac",
}
}
| 172 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Generates pin-related data such as PIN, PIN Verification Value (PVV), PIN
// Block, and PIN Offset during new card issuance or reissuance. For more
// information, see Generate PIN data (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/generate-pin-data.html)
// in the Amazon Web Services Payment Cryptography User Guide. PIN data is never
// transmitted in clear to or from Amazon Web Services Payment Cryptography. This
// operation generates PIN, PVV, or PIN Offset and then encrypts it using Pin
// Encryption Key (PEK) to create an EncryptedPinBlock for transmission from
// Amazon Web Services Payment Cryptography. This operation uses a separate Pin
// Verification Key (PVK) for VISA PVV generation. For information about valid keys
// for this operation, see Understanding key attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - GenerateCardValidationData
// - TranslatePinData
// - VerifyPinData
func (c *Client) GeneratePinData(ctx context.Context, params *GeneratePinDataInput, optFns ...func(*Options)) (*GeneratePinDataOutput, error) {
if params == nil {
params = &GeneratePinDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GeneratePinData", params, optFns, c.addOperationGeneratePinDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GeneratePinDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type GeneratePinDataInput struct {
// The keyARN of the PEK that Amazon Web Services Payment Cryptography uses to
// encrypt the PIN Block.
//
// This member is required.
EncryptionKeyIdentifier *string
// The attributes and values to use for PIN, PVV, or PIN Offset generation.
//
// This member is required.
GenerationAttributes types.PinGenerationAttributes
// The keyARN of the PEK that Amazon Web Services Payment Cryptography uses for
// pin data generation.
//
// This member is required.
GenerationKeyIdentifier *string
// The PIN encoding format for pin data generation as specified in ISO 9564.
// Amazon Web Services Payment Cryptography supports ISO_Format_0 and ISO_Format_3
// . The ISO_Format_0 PIN block format is equivalent to the ANSI X9.8, VISA-1, and
// ECI-1 PIN block formats. It is similar to a VISA-4 PIN block format. It supports
// a PIN from 4 to 12 digits in length. The ISO_Format_3 PIN block format is the
// same as ISO_Format_0 except that the fill digits are random values from 10 to
// 15.
//
// This member is required.
PinBlockFormat types.PinBlockFormatForPinData
// The Primary Account Number (PAN), a unique identifier for a payment credit or
// debit card that associates the card with a specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
// The length of PIN under generation.
PinDataLength *int32
noSmithyDocumentSerde
}
type GeneratePinDataOutput struct {
// The PIN block encrypted under PEK from Amazon Web Services Payment
// Cryptography. The encrypted PIN block is a composite of PAN (Primary Account
// Number) and PIN (Personal Identification Number), generated in accordance with
// ISO 9564 standard.
//
// This member is required.
EncryptedPinBlock *string
// The keyARN of the PEK that Amazon Web Services Payment Cryptography uses for
// encrypted pin block generation.
//
// This member is required.
EncryptionKeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
EncryptionKeyCheckValue *string
// The keyARN of the pin data generation key that Amazon Web Services Payment
// Cryptography uses for PIN, PVV or PIN Offset generation.
//
// This member is required.
GenerationKeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
GenerationKeyCheckValue *string
// The attributes and values Amazon Web Services Payment Cryptography uses for pin
// data generation.
//
// This member is required.
PinData types.PinData
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGeneratePinDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGeneratePinData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGeneratePinData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGeneratePinDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGeneratePinData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGeneratePinData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "GeneratePinData",
}
}
| 216 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Re-encrypt ciphertext using DUKPT, Symmetric and Asymmetric Data Encryption
// Keys. You can either generate an encryption key within Amazon Web Services
// Payment Cryptography by calling CreateKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)
// or import your own encryption key by calling ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// . The KeyArn for use with this operation must be in a compatible key state with
// KeyModesOfUse set to Encrypt . In asymmetric encryption, ciphertext is encrypted
// using public component (imported by calling ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// ) of the asymmetric key pair created outside of Amazon Web Services Payment
// Cryptography. For symmetric and DUKPT encryption, Amazon Web Services Payment
// Cryptography supports TDES and AES algorithms. For asymmetric encryption,
// Amazon Web Services Payment Cryptography supports RSA . To encrypt using DUKPT,
// a DUKPT key must already exist within your account with KeyModesOfUse set to
// DeriveKey or a new DUKPT can be generated by calling CreateKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)
// . For information about valid keys for this operation, see Understanding key
// attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - DecryptData
// - EncryptData
// - GetPublicCertificate (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_GetPublicKeyCertificate.html)
// - ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
func (c *Client) ReEncryptData(ctx context.Context, params *ReEncryptDataInput, optFns ...func(*Options)) (*ReEncryptDataOutput, error) {
if params == nil {
params = &ReEncryptDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ReEncryptData", params, optFns, c.addOperationReEncryptDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ReEncryptDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type ReEncryptDataInput struct {
// Ciphertext to be encrypted. The minimum allowed length is 16 bytes and maximum
// allowed length is 4096 bytes.
//
// This member is required.
CipherText *string
// The attributes and values for incoming ciphertext.
//
// This member is required.
IncomingEncryptionAttributes types.ReEncryptionAttributes
// The keyARN of the encryption key of incoming ciphertext data.
//
// This member is required.
IncomingKeyIdentifier *string
// The attributes and values for outgoing ciphertext data after encryption by
// Amazon Web Services Payment Cryptography.
//
// This member is required.
OutgoingEncryptionAttributes types.ReEncryptionAttributes
// The keyARN of the encryption key of outgoing ciphertext data after encryption
// by Amazon Web Services Payment Cryptography.
//
// This member is required.
OutgoingKeyIdentifier *string
noSmithyDocumentSerde
}
type ReEncryptDataOutput struct {
// The encrypted ciphertext.
//
// This member is required.
CipherText *string
// The keyARN (Amazon Resource Name) of the encryption key that Amazon Web
// Services Payment Cryptography uses for plaintext encryption.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationReEncryptDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpReEncryptData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpReEncryptData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpReEncryptDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opReEncryptData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opReEncryptData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "ReEncryptData",
}
}
| 188 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Translates encrypted PIN block from and to ISO 9564 formats 0,1,3,4. For more
// information, see Translate PIN data (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/translate-pin-data.html)
// in the Amazon Web Services Payment Cryptography User Guide. PIN block
// translation involves changing the encrytion of PIN block from one encryption key
// to another encryption key and changing PIN block format from one to another
// without PIN block data leaving Amazon Web Services Payment Cryptography. The
// encryption key transformation can be from PEK (Pin Encryption Key) to BDK (Base
// Derivation Key) for DUKPT or from BDK for DUKPT to PEK. Amazon Web Services
// Payment Cryptography supports TDES and AES key derivation type for DUKPT
// tranlations. You can use this operation for P2PE (Point to Point Encryption) use
// cases where the encryption keys should change but the processing system either
// does not need to, or is not permitted to, decrypt the data. The allowed
// combinations of PIN block format translations are guided by PCI. It is important
// to note that not all encrypted PIN block formats (example, format 1) require PAN
// (Primary Account Number) as input. And as such, PIN block format that requires
// PAN (example, formats 0,3,4) cannot be translated to a format (format 1) that
// does not require a PAN for generation. For information about valid keys for this
// operation, see Understanding key attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. At this time, Amazon
// Web Services Payment Cryptography does not support translations to PIN format 4.
// Cross-account use: This operation can't be used across different Amazon Web
// Services accounts. Related operations:
// - GeneratePinData
// - VerifyPinData
func (c *Client) TranslatePinData(ctx context.Context, params *TranslatePinDataInput, optFns ...func(*Options)) (*TranslatePinDataOutput, error) {
if params == nil {
params = &TranslatePinDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TranslatePinData", params, optFns, c.addOperationTranslatePinDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TranslatePinDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type TranslatePinDataInput struct {
// The encrypted PIN block data that Amazon Web Services Payment Cryptography
// translates.
//
// This member is required.
EncryptedPinBlock *string
// The keyARN of the encryption key under which incoming PIN block data is
// encrypted. This key type can be PEK or BDK.
//
// This member is required.
IncomingKeyIdentifier *string
// The format of the incoming PIN block data for tranlation within Amazon Web
// Services Payment Cryptography.
//
// This member is required.
IncomingTranslationAttributes types.TranslationIsoFormats
// The keyARN of the encryption key for encrypting outgoing PIN block data. This
// key type can be PEK or BDK.
//
// This member is required.
OutgoingKeyIdentifier *string
// The format of the outgoing PIN block data after tranlation by Amazon Web
// Services Payment Cryptography.
//
// This member is required.
OutgoingTranslationAttributes types.TranslationIsoFormats
// The attributes and values to use for incoming DUKPT encryption key for PIN
// block tranlation.
IncomingDukptAttributes *types.DukptDerivationAttributes
// The attributes and values to use for outgoing DUKPT encryption key after PIN
// block translation.
OutgoingDukptAttributes *types.DukptDerivationAttributes
noSmithyDocumentSerde
}
type TranslatePinDataOutput struct {
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses to encrypt outgoing PIN block data after translation.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// The ougoing encrypted PIN block data after tranlation.
//
// This member is required.
PinBlock *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTranslatePinDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpTranslatePinData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpTranslatePinData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpTranslatePinDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTranslatePinData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opTranslatePinData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "TranslatePinData",
}
}
| 200 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Verifies Authorization Request Cryptogram (ARQC) for a EMV chip payment card
// authorization. For more information, see Verify auth request cryptogram (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/data-operations.verifyauthrequestcryptogram.html)
// in the Amazon Web Services Payment Cryptography User Guide. ARQC generation is
// done outside of Amazon Web Services Payment Cryptography and is typically
// generated on a point of sale terminal for an EMV chip card to obtain payment
// authorization during transaction time. For ARQC verification, you must first
// import the ARQC generated outside of Amazon Web Services Payment Cryptography by
// calling ImportKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_ImportKey.html)
// . This operation uses the imported ARQC and an major encryption key (DUKPT)
// created by calling CreateKey (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_CreateKey.html)
// to either provide a boolean ARQC verification result or provide an APRC
// (Authorization Response Cryptogram) response using Method 1 or Method 2. The
// ARPC_METHOD_1 uses AuthResponseCode to generate ARPC and ARPC_METHOD_2 uses
// CardStatusUpdate to generate ARPC. For information about valid keys for this
// operation, see Understanding key attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - VerifyCardValidationData
// - VerifyPinData
func (c *Client) VerifyAuthRequestCryptogram(ctx context.Context, params *VerifyAuthRequestCryptogramInput, optFns ...func(*Options)) (*VerifyAuthRequestCryptogramOutput, error) {
if params == nil {
params = &VerifyAuthRequestCryptogramInput{}
}
result, metadata, err := c.invokeOperation(ctx, "VerifyAuthRequestCryptogram", params, optFns, c.addOperationVerifyAuthRequestCryptogramMiddlewares)
if err != nil {
return nil, err
}
out := result.(*VerifyAuthRequestCryptogramOutput)
out.ResultMetadata = metadata
return out, nil
}
type VerifyAuthRequestCryptogramInput struct {
// The auth request cryptogram imported into Amazon Web Services Payment
// Cryptography for ARQC verification using a major encryption key and transaction
// data.
//
// This member is required.
AuthRequestCryptogram *string
// The keyARN of the major encryption key that Amazon Web Services Payment
// Cryptography uses for ARQC verification.
//
// This member is required.
KeyIdentifier *string
// The method to use when deriving the major encryption key for ARQC verification
// within Amazon Web Services Payment Cryptography. The same key derivation mode
// was used for ARQC generation outside of Amazon Web Services Payment
// Cryptography.
//
// This member is required.
MajorKeyDerivationMode types.MajorKeyDerivationMode
// The attributes and values to use for deriving a session key for ARQC
// verification within Amazon Web Services Payment Cryptography. The same
// attributes were used for ARQC generation outside of Amazon Web Services Payment
// Cryptography.
//
// This member is required.
SessionKeyDerivationAttributes types.SessionKeyDerivation
// The transaction data that Amazon Web Services Payment Cryptography uses for
// ARQC verification. The same transaction is used for ARQC generation outside of
// Amazon Web Services Payment Cryptography.
//
// This member is required.
TransactionData *string
// The attributes and values for auth request cryptogram verification. These
// parameters are required in case using ARPC Method 1 or Method 2 for ARQC
// verification.
AuthResponseAttributes types.CryptogramAuthResponse
noSmithyDocumentSerde
}
type VerifyAuthRequestCryptogramOutput struct {
// The keyARN of the major encryption key that Amazon Web Services Payment
// Cryptography uses for ARQC verification.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// The result for ARQC verification or ARPC generation within Amazon Web Services
// Payment Cryptography.
AuthResponseValue *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationVerifyAuthRequestCryptogramMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpVerifyAuthRequestCryptogram{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpVerifyAuthRequestCryptogram{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpVerifyAuthRequestCryptogramValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opVerifyAuthRequestCryptogram(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opVerifyAuthRequestCryptogram(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "VerifyAuthRequestCryptogram",
}
}
| 198 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Verifies card-related validation data using algorithms such as Card
// Verification Values (CVV/CVV2), Dynamic Card Verification Values (dCVV/dCVV2)
// and Card Security Codes (CSC). For more information, see Verify card data (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/verify-card-data.html)
// in the Amazon Web Services Payment Cryptography User Guide. This operation
// validates the CVV or CSC codes that is printed on a payment credit or debit card
// during card payment transaction. The input values are typically provided as part
// of an inbound transaction to an issuer or supporting platform partner. Amazon
// Web Services Payment Cryptography uses CVV or CSC, PAN (Primary Account Number)
// and expiration date of the card to check its validity during transaction
// processing. In this operation, the CVK (Card Verification Key) encryption key
// for use with card data verification is same as the one in used for
// GenerateCardValidationData . For information about valid keys for this
// operation, see Understanding key attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - GenerateCardValidationData
// - VerifyAuthRequestCryptogram
// - VerifyPinData
func (c *Client) VerifyCardValidationData(ctx context.Context, params *VerifyCardValidationDataInput, optFns ...func(*Options)) (*VerifyCardValidationDataOutput, error) {
if params == nil {
params = &VerifyCardValidationDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "VerifyCardValidationData", params, optFns, c.addOperationVerifyCardValidationDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*VerifyCardValidationDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type VerifyCardValidationDataInput struct {
// The keyARN of the CVK encryption key that Amazon Web Services Payment
// Cryptography uses to verify card data.
//
// This member is required.
KeyIdentifier *string
// The Primary Account Number (PAN), a unique identifier for a payment credit or
// debit card that associates the card with a specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
// The CVV or CSC value for use for card data verification within Amazon Web
// Services Payment Cryptography.
//
// This member is required.
ValidationData *string
// The algorithm to use for verification of card data within Amazon Web Services
// Payment Cryptography.
//
// This member is required.
VerificationAttributes types.CardVerificationAttributes
noSmithyDocumentSerde
}
type VerifyCardValidationDataOutput struct {
// The keyARN of the CVK encryption key that Amazon Web Services Payment
// Cryptography uses to verify CVV or CSC.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationVerifyCardValidationDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpVerifyCardValidationData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpVerifyCardValidationData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpVerifyCardValidationDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opVerifyCardValidationData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opVerifyCardValidationData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "VerifyCardValidationData",
}
}
| 176 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Verifies a Message Authentication Code (MAC). You can use this operation when
// keys won't be shared but mutual data is present on both ends for validation. In
// this case, known data values are used to generate a MAC on both ends for
// verification without sending or receiving data in ciphertext or plaintext. You
// can use this operation to verify a DUPKT, HMAC or EMV MAC by setting generation
// attributes and algorithm to the associated values. Use the same encryption key
// for MAC verification as you use for GenerateMac . For information about valid
// keys for this operation, see Understanding key attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - GenerateMac
func (c *Client) VerifyMac(ctx context.Context, params *VerifyMacInput, optFns ...func(*Options)) (*VerifyMacOutput, error) {
if params == nil {
params = &VerifyMacInput{}
}
result, metadata, err := c.invokeOperation(ctx, "VerifyMac", params, optFns, c.addOperationVerifyMacMiddlewares)
if err != nil {
return nil, err
}
out := result.(*VerifyMacOutput)
out.ResultMetadata = metadata
return out, nil
}
type VerifyMacInput struct {
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses to verify MAC data.
//
// This member is required.
KeyIdentifier *string
// The MAC being verified.
//
// This member is required.
Mac *string
// The data on for which MAC is under verification.
//
// This member is required.
MessageData *string
// The attributes and data values to use for MAC verification within Amazon Web
// Services Payment Cryptography.
//
// This member is required.
VerificationAttributes types.MacAttributes
// The length of the MAC.
MacLength *int32
noSmithyDocumentSerde
}
type VerifyMacOutput struct {
// The keyARN of the encryption key that Amazon Web Services Payment Cryptography
// uses for MAC verification.
//
// This member is required.
KeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
KeyCheckValue *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationVerifyMacMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpVerifyMac{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpVerifyMac{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpVerifyMacValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opVerifyMac(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opVerifyMac(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "VerifyMac",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Verifies pin-related data such as PIN and PIN Offset using algorithms including
// VISA PVV and IBM3624. For more information, see Verify PIN data (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/verify-pin-data.html)
// in the Amazon Web Services Payment Cryptography User Guide. This operation
// verifies PIN data for user payment card. A card holder PIN data is never
// transmitted in clear to or from Amazon Web Services Payment Cryptography. This
// operation uses PIN Verification Key (PVK) for PIN or PIN Offset generation and
// then encrypts it using PIN Encryption Key (PEK) to create an EncryptedPinBlock
// for transmission from Amazon Web Services Payment Cryptography. For information
// about valid keys for this operation, see Understanding key attributes (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/keys-validattributes.html)
// and Key types for specific data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/crypto-ops-validkeys-ops.html)
// in the Amazon Web Services Payment Cryptography User Guide. Cross-account use:
// This operation can't be used across different Amazon Web Services accounts.
// Related operations:
// - GeneratePinData
// - TranslatePinData
func (c *Client) VerifyPinData(ctx context.Context, params *VerifyPinDataInput, optFns ...func(*Options)) (*VerifyPinDataOutput, error) {
if params == nil {
params = &VerifyPinDataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "VerifyPinData", params, optFns, c.addOperationVerifyPinDataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*VerifyPinDataOutput)
out.ResultMetadata = metadata
return out, nil
}
type VerifyPinDataInput struct {
// The encrypted PIN block data that Amazon Web Services Payment Cryptography
// verifies.
//
// This member is required.
EncryptedPinBlock *string
// The keyARN of the encryption key under which the PIN block data is encrypted.
// This key type can be PEK or BDK.
//
// This member is required.
EncryptionKeyIdentifier *string
// The PIN encoding format for pin data generation as specified in ISO 9564.
// Amazon Web Services Payment Cryptography supports ISO_Format_0 and ISO_Format_3
// . The ISO_Format_0 PIN block format is equivalent to the ANSI X9.8, VISA-1, and
// ECI-1 PIN block formats. It is similar to a VISA-4 PIN block format. It supports
// a PIN from 4 to 12 digits in length. The ISO_Format_3 PIN block format is the
// same as ISO_Format_0 except that the fill digits are random values from 10 to
// 15.
//
// This member is required.
PinBlockFormat types.PinBlockFormatForPinData
// The Primary Account Number (PAN), a unique identifier for a payment credit or
// debit card that associates the card with a specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
// The attributes and values for PIN data verification.
//
// This member is required.
VerificationAttributes types.PinVerificationAttributes
// The keyARN of the PIN verification key.
//
// This member is required.
VerificationKeyIdentifier *string
// The attributes and values for the DUKPT encrypted PIN block data.
DukptAttributes *types.DukptAttributes
// The length of PIN being verified.
PinDataLength *int32
noSmithyDocumentSerde
}
type VerifyPinDataOutput struct {
// The keyARN of the PEK that Amazon Web Services Payment Cryptography uses for
// encrypted pin block generation.
//
// This member is required.
EncryptionKeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
EncryptionKeyCheckValue *string
// The keyARN of the PIN encryption key that Amazon Web Services Payment
// Cryptography uses for PIN or PIN Offset verification.
//
// This member is required.
VerificationKeyArn *string
// The key check value (KCV) of the encryption key. The KCV is used to check if
// all parties holding a given key have the same key or to detect that a key has
// changed. Amazon Web Services Payment Cryptography calculates the KCV by using
// standard algorithms, typically by encrypting 8 or 16 bytes or "00" or "01" and
// then truncating the result to the first 3 bytes, or 6 hex digits, of the
// resulting cryptogram.
//
// This member is required.
VerificationKeyCheckValue *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationVerifyPinDataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpVerifyPinData{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpVerifyPinData{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpVerifyPinDataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opVerifyPinData(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opVerifyPinData(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "payment-cryptography",
OperationName: "VerifyPinData",
}
}
| 208 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"strings"
)
type awsRestjson1_deserializeOpDecryptData struct {
}
func (*awsRestjson1_deserializeOpDecryptData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDecryptData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorDecryptData(response, &metadata)
}
output := &DecryptDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentDecryptDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDecryptData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDecryptDataOutput(v **DecryptDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DecryptDataOutput
if *v == nil {
sv = &DecryptDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
case "PlainText":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HexEvenLengthBetween16And4096 to be of type string, got %T instead", value)
}
sv.PlainText = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpEncryptData struct {
}
func (*awsRestjson1_deserializeOpEncryptData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpEncryptData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorEncryptData(response, &metadata)
}
output := &EncryptDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentEncryptDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorEncryptData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentEncryptDataOutput(v **EncryptDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *EncryptDataOutput
if *v == nil {
sv = &EncryptDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CipherText":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HexEvenLengthBetween16And4096 to be of type string, got %T instead", value)
}
sv.CipherText = ptr.String(jtv)
}
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGenerateCardValidationData struct {
}
func (*awsRestjson1_deserializeOpGenerateCardValidationData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGenerateCardValidationData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGenerateCardValidationData(response, &metadata)
}
output := &GenerateCardValidationDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGenerateCardValidationDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGenerateCardValidationData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGenerateCardValidationDataOutput(v **GenerateCardValidationDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GenerateCardValidationDataOutput
if *v == nil {
sv = &GenerateCardValidationDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
case "ValidationData":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NumberLengthBetween3And5 to be of type string, got %T instead", value)
}
sv.ValidationData = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGenerateMac struct {
}
func (*awsRestjson1_deserializeOpGenerateMac) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGenerateMac) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGenerateMac(response, &metadata)
}
output := &GenerateMacOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGenerateMacOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGenerateMac(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGenerateMacOutput(v **GenerateMacOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GenerateMacOutput
if *v == nil {
sv = &GenerateMacOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
case "Mac":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HexLengthBetween4And128 to be of type string, got %T instead", value)
}
sv.Mac = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGeneratePinData struct {
}
func (*awsRestjson1_deserializeOpGeneratePinData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGeneratePinData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorGeneratePinData(response, &metadata)
}
output := &GeneratePinDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentGeneratePinDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGeneratePinData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGeneratePinDataOutput(v **GeneratePinDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GeneratePinDataOutput
if *v == nil {
sv = &GeneratePinDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EncryptedPinBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HexLengthBetween16And32 to be of type string, got %T instead", value)
}
sv.EncryptedPinBlock = ptr.String(jtv)
}
case "EncryptionKeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.EncryptionKeyArn = ptr.String(jtv)
}
case "EncryptionKeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.EncryptionKeyCheckValue = ptr.String(jtv)
}
case "GenerationKeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.GenerationKeyArn = ptr.String(jtv)
}
case "GenerationKeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.GenerationKeyCheckValue = ptr.String(jtv)
}
case "PinData":
if err := awsRestjson1_deserializeDocumentPinData(&sv.PinData, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpReEncryptData struct {
}
func (*awsRestjson1_deserializeOpReEncryptData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpReEncryptData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorReEncryptData(response, &metadata)
}
output := &ReEncryptDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentReEncryptDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorReEncryptData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentReEncryptDataOutput(v **ReEncryptDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ReEncryptDataOutput
if *v == nil {
sv = &ReEncryptDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CipherText":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HexEvenLengthBetween16And4096 to be of type string, got %T instead", value)
}
sv.CipherText = ptr.String(jtv)
}
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpTranslatePinData struct {
}
func (*awsRestjson1_deserializeOpTranslatePinData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpTranslatePinData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorTranslatePinData(response, &metadata)
}
output := &TranslatePinDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentTranslatePinDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorTranslatePinData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentTranslatePinDataOutput(v **TranslatePinDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *TranslatePinDataOutput
if *v == nil {
sv = &TranslatePinDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
case "PinBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HexLengthBetween16And32 to be of type string, got %T instead", value)
}
sv.PinBlock = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpVerifyAuthRequestCryptogram struct {
}
func (*awsRestjson1_deserializeOpVerifyAuthRequestCryptogram) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpVerifyAuthRequestCryptogram) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorVerifyAuthRequestCryptogram(response, &metadata)
}
output := &VerifyAuthRequestCryptogramOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentVerifyAuthRequestCryptogramOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorVerifyAuthRequestCryptogram(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
case strings.EqualFold("VerificationFailedException", errorCode):
return awsRestjson1_deserializeErrorVerificationFailedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentVerifyAuthRequestCryptogramOutput(v **VerifyAuthRequestCryptogramOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *VerifyAuthRequestCryptogramOutput
if *v == nil {
sv = &VerifyAuthRequestCryptogramOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AuthResponseValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected HexLengthBetween1And16 to be of type string, got %T instead", value)
}
sv.AuthResponseValue = ptr.String(jtv)
}
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpVerifyCardValidationData struct {
}
func (*awsRestjson1_deserializeOpVerifyCardValidationData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpVerifyCardValidationData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorVerifyCardValidationData(response, &metadata)
}
output := &VerifyCardValidationDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentVerifyCardValidationDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorVerifyCardValidationData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
case strings.EqualFold("VerificationFailedException", errorCode):
return awsRestjson1_deserializeErrorVerificationFailedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentVerifyCardValidationDataOutput(v **VerifyCardValidationDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *VerifyCardValidationDataOutput
if *v == nil {
sv = &VerifyCardValidationDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpVerifyMac struct {
}
func (*awsRestjson1_deserializeOpVerifyMac) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpVerifyMac) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorVerifyMac(response, &metadata)
}
output := &VerifyMacOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentVerifyMacOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorVerifyMac(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
case strings.EqualFold("VerificationFailedException", errorCode):
return awsRestjson1_deserializeErrorVerificationFailedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentVerifyMacOutput(v **VerifyMacOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *VerifyMacOutput
if *v == nil {
sv = &VerifyMacOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.KeyArn = ptr.String(jtv)
}
case "KeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.KeyCheckValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpVerifyPinData struct {
}
func (*awsRestjson1_deserializeOpVerifyPinData) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpVerifyPinData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorVerifyPinData(response, &metadata)
}
output := &VerifyPinDataOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentVerifyPinDataOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorVerifyPinData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
case strings.EqualFold("VerificationFailedException", errorCode):
return awsRestjson1_deserializeErrorVerificationFailedException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentVerifyPinDataOutput(v **VerifyPinDataOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *VerifyPinDataOutput
if *v == nil {
sv = &VerifyPinDataOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EncryptionKeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.EncryptionKeyArn = ptr.String(jtv)
}
case "EncryptionKeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.EncryptionKeyCheckValue = ptr.String(jtv)
}
case "VerificationKeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyArn to be of type string, got %T instead", value)
}
sv.VerificationKeyArn = ptr.String(jtv)
}
case "VerificationKeyCheckValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyCheckValue to be of type string, got %T instead", value)
}
sv.VerificationKeyCheckValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.AccessDeniedException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalServerException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceNotFoundException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ThrottlingException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentThrottlingException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ValidationException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentValidationException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorVerificationFailedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.VerificationFailedException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentVerificationFailedException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AccessDeniedException
if *v == nil {
sv = &types.AccessDeniedException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InternalServerException
if *v == nil {
sv = &types.InternalServerException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPinData(v *types.PinData, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var uv types.PinData
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "PinOffset":
var mv string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NumberLengthBetween4And12 to be of type string, got %T instead", value)
}
mv = jtv
}
uv = &types.PinDataMemberPinOffset{Value: mv}
break loop
case "VerificationValue":
var mv string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NumberLengthBetween4And12 to be of type string, got %T instead", value)
}
mv = jtv
}
uv = &types.PinDataMemberVerificationValue{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceNotFoundException
if *v == nil {
sv = &types.ResourceNotFoundException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThrottlingException
if *v == nil {
sv = &types.ThrottlingException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ValidationException
if *v == nil {
sv = &types.ValidationException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "fieldList":
if err := awsRestjson1_deserializeDocumentValidationExceptionFieldList(&sv.FieldList, value); err != nil {
return err
}
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentValidationExceptionField(v **types.ValidationExceptionField, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ValidationExceptionField
if *v == nil {
sv = &types.ValidationExceptionField{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "path":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Path = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentValidationExceptionFieldList(v *[]types.ValidationExceptionField, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.ValidationExceptionField
if *v == nil {
cv = []types.ValidationExceptionField{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ValidationExceptionField
destAddr := &col
if err := awsRestjson1_deserializeDocumentValidationExceptionField(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentVerificationFailedException(v **types.VerificationFailedException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.VerificationFailedException
if *v == nil {
sv = &types.VerificationFailedException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "Reason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VerificationFailedReason to be of type string, got %T instead", value)
}
sv.Reason = types.VerificationFailedReason(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 2,644 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package paymentcryptographydata provides the API client, operations, and
// parameter types for Payment Cryptography Data Plane.
//
// You use the Amazon Web Services Payment Cryptography Data Plane to manage how
// encryption keys are used for payment-related transaction processing and
// associated cryptographic operations. You can encrypt, decrypt, generate, verify,
// and translate payment-related cryptographic operations in Amazon Web Services
// Payment Cryptography. For more information, see Data operations (https://docs.aws.amazon.com/payment-cryptography/latest/userguide/data-operations.html)
// in the Amazon Web Services Payment Cryptography User Guide. To manage your
// encryption keys, you use the Amazon Web Services Payment Cryptography Control
// Plane (https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/Welcome.html)
// . You can create, import, export, share, manage, and delete keys. You can also
// manage Identity and Access Management (IAM) policies for keys.
package paymentcryptographydata
| 17 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// EndpointResolverFunc is a helper utility that wraps a function so it satisfies
// the EndpointResolver interface. This is useful when you want to add additional
// endpoint resolving logic, or stub out specific endpoints with custom values.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// EndpointResolverFromURL returns an EndpointResolver configured using the
// provided endpoint url. By default, the resolved endpoint resolver uses the
// client region as signing region, and the endpoint source is set to
// EndpointSourceCustom.You can provide functional options to configure endpoint
// values for the resolved endpoint.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "paymentcryptographydataplane"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package paymentcryptographydata
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.0.2"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
type awsRestjson1_serializeOpDecryptData struct {
}
func (*awsRestjson1_serializeOpDecryptData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDecryptData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*DecryptDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/keys/{KeyIdentifier}/decrypt")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDecryptDataInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDecryptDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsDecryptDataInput(v *DecryptDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.KeyIdentifier == nil || len(*v.KeyIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member KeyIdentifier must not be empty")}
}
if v.KeyIdentifier != nil {
if err := encoder.SetURI("KeyIdentifier").String(*v.KeyIdentifier); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentDecryptDataInput(v *DecryptDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CipherText != nil {
ok := object.Key("CipherText")
ok.String(*v.CipherText)
}
if v.DecryptionAttributes != nil {
ok := object.Key("DecryptionAttributes")
if err := awsRestjson1_serializeDocumentEncryptionDecryptionAttributes(v.DecryptionAttributes, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpEncryptData struct {
}
func (*awsRestjson1_serializeOpEncryptData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpEncryptData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*EncryptDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/keys/{KeyIdentifier}/encrypt")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsEncryptDataInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentEncryptDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsEncryptDataInput(v *EncryptDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.KeyIdentifier == nil || len(*v.KeyIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member KeyIdentifier must not be empty")}
}
if v.KeyIdentifier != nil {
if err := encoder.SetURI("KeyIdentifier").String(*v.KeyIdentifier); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentEncryptDataInput(v *EncryptDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EncryptionAttributes != nil {
ok := object.Key("EncryptionAttributes")
if err := awsRestjson1_serializeDocumentEncryptionDecryptionAttributes(v.EncryptionAttributes, ok); err != nil {
return err
}
}
if v.PlainText != nil {
ok := object.Key("PlainText")
ok.String(*v.PlainText)
}
return nil
}
type awsRestjson1_serializeOpGenerateCardValidationData struct {
}
func (*awsRestjson1_serializeOpGenerateCardValidationData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGenerateCardValidationData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GenerateCardValidationDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/cardvalidationdata/generate")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGenerateCardValidationDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGenerateCardValidationDataInput(v *GenerateCardValidationDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGenerateCardValidationDataInput(v *GenerateCardValidationDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GenerationAttributes != nil {
ok := object.Key("GenerationAttributes")
if err := awsRestjson1_serializeDocumentCardGenerationAttributes(v.GenerationAttributes, ok); err != nil {
return err
}
}
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
if v.ValidationDataLength != nil {
ok := object.Key("ValidationDataLength")
ok.Integer(*v.ValidationDataLength)
}
return nil
}
type awsRestjson1_serializeOpGenerateMac struct {
}
func (*awsRestjson1_serializeOpGenerateMac) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGenerateMac) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GenerateMacInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/mac/generate")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGenerateMacInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGenerateMacInput(v *GenerateMacInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGenerateMacInput(v *GenerateMacInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GenerationAttributes != nil {
ok := object.Key("GenerationAttributes")
if err := awsRestjson1_serializeDocumentMacAttributes(v.GenerationAttributes, ok); err != nil {
return err
}
}
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
if v.MacLength != nil {
ok := object.Key("MacLength")
ok.Integer(*v.MacLength)
}
if v.MessageData != nil {
ok := object.Key("MessageData")
ok.String(*v.MessageData)
}
return nil
}
type awsRestjson1_serializeOpGeneratePinData struct {
}
func (*awsRestjson1_serializeOpGeneratePinData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGeneratePinData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*GeneratePinDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/pindata/generate")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGeneratePinDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsGeneratePinDataInput(v *GeneratePinDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGeneratePinDataInput(v *GeneratePinDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EncryptionKeyIdentifier != nil {
ok := object.Key("EncryptionKeyIdentifier")
ok.String(*v.EncryptionKeyIdentifier)
}
if v.GenerationAttributes != nil {
ok := object.Key("GenerationAttributes")
if err := awsRestjson1_serializeDocumentPinGenerationAttributes(v.GenerationAttributes, ok); err != nil {
return err
}
}
if v.GenerationKeyIdentifier != nil {
ok := object.Key("GenerationKeyIdentifier")
ok.String(*v.GenerationKeyIdentifier)
}
if len(v.PinBlockFormat) > 0 {
ok := object.Key("PinBlockFormat")
ok.String(string(v.PinBlockFormat))
}
if v.PinDataLength != nil {
ok := object.Key("PinDataLength")
ok.Integer(*v.PinDataLength)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
return nil
}
type awsRestjson1_serializeOpReEncryptData struct {
}
func (*awsRestjson1_serializeOpReEncryptData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpReEncryptData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*ReEncryptDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/keys/{IncomingKeyIdentifier}/reencrypt")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsReEncryptDataInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentReEncryptDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsReEncryptDataInput(v *ReEncryptDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.IncomingKeyIdentifier == nil || len(*v.IncomingKeyIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member IncomingKeyIdentifier must not be empty")}
}
if v.IncomingKeyIdentifier != nil {
if err := encoder.SetURI("IncomingKeyIdentifier").String(*v.IncomingKeyIdentifier); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentReEncryptDataInput(v *ReEncryptDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CipherText != nil {
ok := object.Key("CipherText")
ok.String(*v.CipherText)
}
if v.IncomingEncryptionAttributes != nil {
ok := object.Key("IncomingEncryptionAttributes")
if err := awsRestjson1_serializeDocumentReEncryptionAttributes(v.IncomingEncryptionAttributes, ok); err != nil {
return err
}
}
if v.OutgoingEncryptionAttributes != nil {
ok := object.Key("OutgoingEncryptionAttributes")
if err := awsRestjson1_serializeDocumentReEncryptionAttributes(v.OutgoingEncryptionAttributes, ok); err != nil {
return err
}
}
if v.OutgoingKeyIdentifier != nil {
ok := object.Key("OutgoingKeyIdentifier")
ok.String(*v.OutgoingKeyIdentifier)
}
return nil
}
type awsRestjson1_serializeOpTranslatePinData struct {
}
func (*awsRestjson1_serializeOpTranslatePinData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpTranslatePinData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*TranslatePinDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/pindata/translate")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentTranslatePinDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsTranslatePinDataInput(v *TranslatePinDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentTranslatePinDataInput(v *TranslatePinDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EncryptedPinBlock != nil {
ok := object.Key("EncryptedPinBlock")
ok.String(*v.EncryptedPinBlock)
}
if v.IncomingDukptAttributes != nil {
ok := object.Key("IncomingDukptAttributes")
if err := awsRestjson1_serializeDocumentDukptDerivationAttributes(v.IncomingDukptAttributes, ok); err != nil {
return err
}
}
if v.IncomingKeyIdentifier != nil {
ok := object.Key("IncomingKeyIdentifier")
ok.String(*v.IncomingKeyIdentifier)
}
if v.IncomingTranslationAttributes != nil {
ok := object.Key("IncomingTranslationAttributes")
if err := awsRestjson1_serializeDocumentTranslationIsoFormats(v.IncomingTranslationAttributes, ok); err != nil {
return err
}
}
if v.OutgoingDukptAttributes != nil {
ok := object.Key("OutgoingDukptAttributes")
if err := awsRestjson1_serializeDocumentDukptDerivationAttributes(v.OutgoingDukptAttributes, ok); err != nil {
return err
}
}
if v.OutgoingKeyIdentifier != nil {
ok := object.Key("OutgoingKeyIdentifier")
ok.String(*v.OutgoingKeyIdentifier)
}
if v.OutgoingTranslationAttributes != nil {
ok := object.Key("OutgoingTranslationAttributes")
if err := awsRestjson1_serializeDocumentTranslationIsoFormats(v.OutgoingTranslationAttributes, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpVerifyAuthRequestCryptogram struct {
}
func (*awsRestjson1_serializeOpVerifyAuthRequestCryptogram) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpVerifyAuthRequestCryptogram) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*VerifyAuthRequestCryptogramInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/cryptogram/verify")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentVerifyAuthRequestCryptogramInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsVerifyAuthRequestCryptogramInput(v *VerifyAuthRequestCryptogramInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentVerifyAuthRequestCryptogramInput(v *VerifyAuthRequestCryptogramInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AuthRequestCryptogram != nil {
ok := object.Key("AuthRequestCryptogram")
ok.String(*v.AuthRequestCryptogram)
}
if v.AuthResponseAttributes != nil {
ok := object.Key("AuthResponseAttributes")
if err := awsRestjson1_serializeDocumentCryptogramAuthResponse(v.AuthResponseAttributes, ok); err != nil {
return err
}
}
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
if len(v.MajorKeyDerivationMode) > 0 {
ok := object.Key("MajorKeyDerivationMode")
ok.String(string(v.MajorKeyDerivationMode))
}
if v.SessionKeyDerivationAttributes != nil {
ok := object.Key("SessionKeyDerivationAttributes")
if err := awsRestjson1_serializeDocumentSessionKeyDerivation(v.SessionKeyDerivationAttributes, ok); err != nil {
return err
}
}
if v.TransactionData != nil {
ok := object.Key("TransactionData")
ok.String(*v.TransactionData)
}
return nil
}
type awsRestjson1_serializeOpVerifyCardValidationData struct {
}
func (*awsRestjson1_serializeOpVerifyCardValidationData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpVerifyCardValidationData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*VerifyCardValidationDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/cardvalidationdata/verify")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentVerifyCardValidationDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsVerifyCardValidationDataInput(v *VerifyCardValidationDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentVerifyCardValidationDataInput(v *VerifyCardValidationDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
if v.ValidationData != nil {
ok := object.Key("ValidationData")
ok.String(*v.ValidationData)
}
if v.VerificationAttributes != nil {
ok := object.Key("VerificationAttributes")
if err := awsRestjson1_serializeDocumentCardVerificationAttributes(v.VerificationAttributes, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpVerifyMac struct {
}
func (*awsRestjson1_serializeOpVerifyMac) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpVerifyMac) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*VerifyMacInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/mac/verify")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentVerifyMacInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsVerifyMacInput(v *VerifyMacInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentVerifyMacInput(v *VerifyMacInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KeyIdentifier != nil {
ok := object.Key("KeyIdentifier")
ok.String(*v.KeyIdentifier)
}
if v.Mac != nil {
ok := object.Key("Mac")
ok.String(*v.Mac)
}
if v.MacLength != nil {
ok := object.Key("MacLength")
ok.Integer(*v.MacLength)
}
if v.MessageData != nil {
ok := object.Key("MessageData")
ok.String(*v.MessageData)
}
if v.VerificationAttributes != nil {
ok := object.Key("VerificationAttributes")
if err := awsRestjson1_serializeDocumentMacAttributes(v.VerificationAttributes, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpVerifyPinData struct {
}
func (*awsRestjson1_serializeOpVerifyPinData) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpVerifyPinData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*VerifyPinDataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/pindata/verify")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentVerifyPinDataInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsVerifyPinDataInput(v *VerifyPinDataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentVerifyPinDataInput(v *VerifyPinDataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DukptAttributes != nil {
ok := object.Key("DukptAttributes")
if err := awsRestjson1_serializeDocumentDukptAttributes(v.DukptAttributes, ok); err != nil {
return err
}
}
if v.EncryptedPinBlock != nil {
ok := object.Key("EncryptedPinBlock")
ok.String(*v.EncryptedPinBlock)
}
if v.EncryptionKeyIdentifier != nil {
ok := object.Key("EncryptionKeyIdentifier")
ok.String(*v.EncryptionKeyIdentifier)
}
if len(v.PinBlockFormat) > 0 {
ok := object.Key("PinBlockFormat")
ok.String(string(v.PinBlockFormat))
}
if v.PinDataLength != nil {
ok := object.Key("PinDataLength")
ok.Integer(*v.PinDataLength)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
if v.VerificationAttributes != nil {
ok := object.Key("VerificationAttributes")
if err := awsRestjson1_serializeDocumentPinVerificationAttributes(v.VerificationAttributes, ok); err != nil {
return err
}
}
if v.VerificationKeyIdentifier != nil {
ok := object.Key("VerificationKeyIdentifier")
ok.String(*v.VerificationKeyIdentifier)
}
return nil
}
func awsRestjson1_serializeDocumentAmexCardSecurityCodeVersion1(v *types.AmexCardSecurityCodeVersion1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CardExpiryDate != nil {
ok := object.Key("CardExpiryDate")
ok.String(*v.CardExpiryDate)
}
return nil
}
func awsRestjson1_serializeDocumentAmexCardSecurityCodeVersion2(v *types.AmexCardSecurityCodeVersion2, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CardExpiryDate != nil {
ok := object.Key("CardExpiryDate")
ok.String(*v.CardExpiryDate)
}
if v.ServiceCode != nil {
ok := object.Key("ServiceCode")
ok.String(*v.ServiceCode)
}
return nil
}
func awsRestjson1_serializeDocumentAsymmetricEncryptionAttributes(v *types.AsymmetricEncryptionAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.PaddingType) > 0 {
ok := object.Key("PaddingType")
ok.String(string(v.PaddingType))
}
return nil
}
func awsRestjson1_serializeDocumentCardGenerationAttributes(v types.CardGenerationAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.CardGenerationAttributesMemberAmexCardSecurityCodeVersion1:
av := object.Key("AmexCardSecurityCodeVersion1")
if err := awsRestjson1_serializeDocumentAmexCardSecurityCodeVersion1(&uv.Value, av); err != nil {
return err
}
case *types.CardGenerationAttributesMemberAmexCardSecurityCodeVersion2:
av := object.Key("AmexCardSecurityCodeVersion2")
if err := awsRestjson1_serializeDocumentAmexCardSecurityCodeVersion2(&uv.Value, av); err != nil {
return err
}
case *types.CardGenerationAttributesMemberCardHolderVerificationValue:
av := object.Key("CardHolderVerificationValue")
if err := awsRestjson1_serializeDocumentCardHolderVerificationValue(&uv.Value, av); err != nil {
return err
}
case *types.CardGenerationAttributesMemberCardVerificationValue1:
av := object.Key("CardVerificationValue1")
if err := awsRestjson1_serializeDocumentCardVerificationValue1(&uv.Value, av); err != nil {
return err
}
case *types.CardGenerationAttributesMemberCardVerificationValue2:
av := object.Key("CardVerificationValue2")
if err := awsRestjson1_serializeDocumentCardVerificationValue2(&uv.Value, av); err != nil {
return err
}
case *types.CardGenerationAttributesMemberDynamicCardVerificationCode:
av := object.Key("DynamicCardVerificationCode")
if err := awsRestjson1_serializeDocumentDynamicCardVerificationCode(&uv.Value, av); err != nil {
return err
}
case *types.CardGenerationAttributesMemberDynamicCardVerificationValue:
av := object.Key("DynamicCardVerificationValue")
if err := awsRestjson1_serializeDocumentDynamicCardVerificationValue(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentCardHolderVerificationValue(v *types.CardHolderVerificationValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplicationTransactionCounter != nil {
ok := object.Key("ApplicationTransactionCounter")
ok.String(*v.ApplicationTransactionCounter)
}
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.UnpredictableNumber != nil {
ok := object.Key("UnpredictableNumber")
ok.String(*v.UnpredictableNumber)
}
return nil
}
func awsRestjson1_serializeDocumentCardVerificationAttributes(v types.CardVerificationAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.CardVerificationAttributesMemberAmexCardSecurityCodeVersion1:
av := object.Key("AmexCardSecurityCodeVersion1")
if err := awsRestjson1_serializeDocumentAmexCardSecurityCodeVersion1(&uv.Value, av); err != nil {
return err
}
case *types.CardVerificationAttributesMemberAmexCardSecurityCodeVersion2:
av := object.Key("AmexCardSecurityCodeVersion2")
if err := awsRestjson1_serializeDocumentAmexCardSecurityCodeVersion2(&uv.Value, av); err != nil {
return err
}
case *types.CardVerificationAttributesMemberCardHolderVerificationValue:
av := object.Key("CardHolderVerificationValue")
if err := awsRestjson1_serializeDocumentCardHolderVerificationValue(&uv.Value, av); err != nil {
return err
}
case *types.CardVerificationAttributesMemberCardVerificationValue1:
av := object.Key("CardVerificationValue1")
if err := awsRestjson1_serializeDocumentCardVerificationValue1(&uv.Value, av); err != nil {
return err
}
case *types.CardVerificationAttributesMemberCardVerificationValue2:
av := object.Key("CardVerificationValue2")
if err := awsRestjson1_serializeDocumentCardVerificationValue2(&uv.Value, av); err != nil {
return err
}
case *types.CardVerificationAttributesMemberDiscoverDynamicCardVerificationCode:
av := object.Key("DiscoverDynamicCardVerificationCode")
if err := awsRestjson1_serializeDocumentDiscoverDynamicCardVerificationCode(&uv.Value, av); err != nil {
return err
}
case *types.CardVerificationAttributesMemberDynamicCardVerificationCode:
av := object.Key("DynamicCardVerificationCode")
if err := awsRestjson1_serializeDocumentDynamicCardVerificationCode(&uv.Value, av); err != nil {
return err
}
case *types.CardVerificationAttributesMemberDynamicCardVerificationValue:
av := object.Key("DynamicCardVerificationValue")
if err := awsRestjson1_serializeDocumentDynamicCardVerificationValue(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentCardVerificationValue1(v *types.CardVerificationValue1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CardExpiryDate != nil {
ok := object.Key("CardExpiryDate")
ok.String(*v.CardExpiryDate)
}
if v.ServiceCode != nil {
ok := object.Key("ServiceCode")
ok.String(*v.ServiceCode)
}
return nil
}
func awsRestjson1_serializeDocumentCardVerificationValue2(v *types.CardVerificationValue2, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CardExpiryDate != nil {
ok := object.Key("CardExpiryDate")
ok.String(*v.CardExpiryDate)
}
return nil
}
func awsRestjson1_serializeDocumentCryptogramAuthResponse(v types.CryptogramAuthResponse, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.CryptogramAuthResponseMemberArpcMethod1:
av := object.Key("ArpcMethod1")
if err := awsRestjson1_serializeDocumentCryptogramVerificationArpcMethod1(&uv.Value, av); err != nil {
return err
}
case *types.CryptogramAuthResponseMemberArpcMethod2:
av := object.Key("ArpcMethod2")
if err := awsRestjson1_serializeDocumentCryptogramVerificationArpcMethod2(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentCryptogramVerificationArpcMethod1(v *types.CryptogramVerificationArpcMethod1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AuthResponseCode != nil {
ok := object.Key("AuthResponseCode")
ok.String(*v.AuthResponseCode)
}
return nil
}
func awsRestjson1_serializeDocumentCryptogramVerificationArpcMethod2(v *types.CryptogramVerificationArpcMethod2, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CardStatusUpdate != nil {
ok := object.Key("CardStatusUpdate")
ok.String(*v.CardStatusUpdate)
}
if v.ProprietaryAuthenticationData != nil {
ok := object.Key("ProprietaryAuthenticationData")
ok.String(*v.ProprietaryAuthenticationData)
}
return nil
}
func awsRestjson1_serializeDocumentDiscoverDynamicCardVerificationCode(v *types.DiscoverDynamicCardVerificationCode, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplicationTransactionCounter != nil {
ok := object.Key("ApplicationTransactionCounter")
ok.String(*v.ApplicationTransactionCounter)
}
if v.CardExpiryDate != nil {
ok := object.Key("CardExpiryDate")
ok.String(*v.CardExpiryDate)
}
if v.UnpredictableNumber != nil {
ok := object.Key("UnpredictableNumber")
ok.String(*v.UnpredictableNumber)
}
return nil
}
func awsRestjson1_serializeDocumentDukptAttributes(v *types.DukptAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DukptDerivationType) > 0 {
ok := object.Key("DukptDerivationType")
ok.String(string(v.DukptDerivationType))
}
if v.KeySerialNumber != nil {
ok := object.Key("KeySerialNumber")
ok.String(*v.KeySerialNumber)
}
return nil
}
func awsRestjson1_serializeDocumentDukptDerivationAttributes(v *types.DukptDerivationAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DukptKeyDerivationType) > 0 {
ok := object.Key("DukptKeyDerivationType")
ok.String(string(v.DukptKeyDerivationType))
}
if len(v.DukptKeyVariant) > 0 {
ok := object.Key("DukptKeyVariant")
ok.String(string(v.DukptKeyVariant))
}
if v.KeySerialNumber != nil {
ok := object.Key("KeySerialNumber")
ok.String(*v.KeySerialNumber)
}
return nil
}
func awsRestjson1_serializeDocumentDukptEncryptionAttributes(v *types.DukptEncryptionAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DukptKeyDerivationType) > 0 {
ok := object.Key("DukptKeyDerivationType")
ok.String(string(v.DukptKeyDerivationType))
}
if len(v.DukptKeyVariant) > 0 {
ok := object.Key("DukptKeyVariant")
ok.String(string(v.DukptKeyVariant))
}
if v.InitializationVector != nil {
ok := object.Key("InitializationVector")
ok.String(*v.InitializationVector)
}
if v.KeySerialNumber != nil {
ok := object.Key("KeySerialNumber")
ok.String(*v.KeySerialNumber)
}
if len(v.Mode) > 0 {
ok := object.Key("Mode")
ok.String(string(v.Mode))
}
return nil
}
func awsRestjson1_serializeDocumentDynamicCardVerificationCode(v *types.DynamicCardVerificationCode, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplicationTransactionCounter != nil {
ok := object.Key("ApplicationTransactionCounter")
ok.String(*v.ApplicationTransactionCounter)
}
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.TrackData != nil {
ok := object.Key("TrackData")
ok.String(*v.TrackData)
}
if v.UnpredictableNumber != nil {
ok := object.Key("UnpredictableNumber")
ok.String(*v.UnpredictableNumber)
}
return nil
}
func awsRestjson1_serializeDocumentDynamicCardVerificationValue(v *types.DynamicCardVerificationValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplicationTransactionCounter != nil {
ok := object.Key("ApplicationTransactionCounter")
ok.String(*v.ApplicationTransactionCounter)
}
if v.CardExpiryDate != nil {
ok := object.Key("CardExpiryDate")
ok.String(*v.CardExpiryDate)
}
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.ServiceCode != nil {
ok := object.Key("ServiceCode")
ok.String(*v.ServiceCode)
}
return nil
}
func awsRestjson1_serializeDocumentEncryptionDecryptionAttributes(v types.EncryptionDecryptionAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.EncryptionDecryptionAttributesMemberAsymmetric:
av := object.Key("Asymmetric")
if err := awsRestjson1_serializeDocumentAsymmetricEncryptionAttributes(&uv.Value, av); err != nil {
return err
}
case *types.EncryptionDecryptionAttributesMemberDukpt:
av := object.Key("Dukpt")
if err := awsRestjson1_serializeDocumentDukptEncryptionAttributes(&uv.Value, av); err != nil {
return err
}
case *types.EncryptionDecryptionAttributesMemberSymmetric:
av := object.Key("Symmetric")
if err := awsRestjson1_serializeDocumentSymmetricEncryptionAttributes(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentIbm3624NaturalPin(v *types.Ibm3624NaturalPin, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DecimalizationTable != nil {
ok := object.Key("DecimalizationTable")
ok.String(*v.DecimalizationTable)
}
if v.PinValidationData != nil {
ok := object.Key("PinValidationData")
ok.String(*v.PinValidationData)
}
if v.PinValidationDataPadCharacter != nil {
ok := object.Key("PinValidationDataPadCharacter")
ok.String(*v.PinValidationDataPadCharacter)
}
return nil
}
func awsRestjson1_serializeDocumentIbm3624PinFromOffset(v *types.Ibm3624PinFromOffset, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DecimalizationTable != nil {
ok := object.Key("DecimalizationTable")
ok.String(*v.DecimalizationTable)
}
if v.PinOffset != nil {
ok := object.Key("PinOffset")
ok.String(*v.PinOffset)
}
if v.PinValidationData != nil {
ok := object.Key("PinValidationData")
ok.String(*v.PinValidationData)
}
if v.PinValidationDataPadCharacter != nil {
ok := object.Key("PinValidationDataPadCharacter")
ok.String(*v.PinValidationDataPadCharacter)
}
return nil
}
func awsRestjson1_serializeDocumentIbm3624PinOffset(v *types.Ibm3624PinOffset, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DecimalizationTable != nil {
ok := object.Key("DecimalizationTable")
ok.String(*v.DecimalizationTable)
}
if v.EncryptedPinBlock != nil {
ok := object.Key("EncryptedPinBlock")
ok.String(*v.EncryptedPinBlock)
}
if v.PinValidationData != nil {
ok := object.Key("PinValidationData")
ok.String(*v.PinValidationData)
}
if v.PinValidationDataPadCharacter != nil {
ok := object.Key("PinValidationDataPadCharacter")
ok.String(*v.PinValidationDataPadCharacter)
}
return nil
}
func awsRestjson1_serializeDocumentIbm3624PinVerification(v *types.Ibm3624PinVerification, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DecimalizationTable != nil {
ok := object.Key("DecimalizationTable")
ok.String(*v.DecimalizationTable)
}
if v.PinOffset != nil {
ok := object.Key("PinOffset")
ok.String(*v.PinOffset)
}
if v.PinValidationData != nil {
ok := object.Key("PinValidationData")
ok.String(*v.PinValidationData)
}
if v.PinValidationDataPadCharacter != nil {
ok := object.Key("PinValidationDataPadCharacter")
ok.String(*v.PinValidationDataPadCharacter)
}
return nil
}
func awsRestjson1_serializeDocumentIbm3624RandomPin(v *types.Ibm3624RandomPin, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DecimalizationTable != nil {
ok := object.Key("DecimalizationTable")
ok.String(*v.DecimalizationTable)
}
if v.PinValidationData != nil {
ok := object.Key("PinValidationData")
ok.String(*v.PinValidationData)
}
if v.PinValidationDataPadCharacter != nil {
ok := object.Key("PinValidationDataPadCharacter")
ok.String(*v.PinValidationDataPadCharacter)
}
return nil
}
func awsRestjson1_serializeDocumentMacAlgorithmDukpt(v *types.MacAlgorithmDukpt, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DukptDerivationType) > 0 {
ok := object.Key("DukptDerivationType")
ok.String(string(v.DukptDerivationType))
}
if len(v.DukptKeyVariant) > 0 {
ok := object.Key("DukptKeyVariant")
ok.String(string(v.DukptKeyVariant))
}
if v.KeySerialNumber != nil {
ok := object.Key("KeySerialNumber")
ok.String(*v.KeySerialNumber)
}
return nil
}
func awsRestjson1_serializeDocumentMacAlgorithmEmv(v *types.MacAlgorithmEmv, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.MajorKeyDerivationMode) > 0 {
ok := object.Key("MajorKeyDerivationMode")
ok.String(string(v.MajorKeyDerivationMode))
}
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
if len(v.SessionKeyDerivationMode) > 0 {
ok := object.Key("SessionKeyDerivationMode")
ok.String(string(v.SessionKeyDerivationMode))
}
if v.SessionKeyDerivationValue != nil {
ok := object.Key("SessionKeyDerivationValue")
if err := awsRestjson1_serializeDocumentSessionKeyDerivationValue(v.SessionKeyDerivationValue, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentMacAttributes(v types.MacAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.MacAttributesMemberAlgorithm:
av := object.Key("Algorithm")
av.String(string(uv.Value))
case *types.MacAttributesMemberDukptCmac:
av := object.Key("DukptCmac")
if err := awsRestjson1_serializeDocumentMacAlgorithmDukpt(&uv.Value, av); err != nil {
return err
}
case *types.MacAttributesMemberDukptIso9797Algorithm1:
av := object.Key("DukptIso9797Algorithm1")
if err := awsRestjson1_serializeDocumentMacAlgorithmDukpt(&uv.Value, av); err != nil {
return err
}
case *types.MacAttributesMemberDukptIso9797Algorithm3:
av := object.Key("DukptIso9797Algorithm3")
if err := awsRestjson1_serializeDocumentMacAlgorithmDukpt(&uv.Value, av); err != nil {
return err
}
case *types.MacAttributesMemberEmvMac:
av := object.Key("EmvMac")
if err := awsRestjson1_serializeDocumentMacAlgorithmEmv(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentPinGenerationAttributes(v types.PinGenerationAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.PinGenerationAttributesMemberIbm3624NaturalPin:
av := object.Key("Ibm3624NaturalPin")
if err := awsRestjson1_serializeDocumentIbm3624NaturalPin(&uv.Value, av); err != nil {
return err
}
case *types.PinGenerationAttributesMemberIbm3624PinFromOffset:
av := object.Key("Ibm3624PinFromOffset")
if err := awsRestjson1_serializeDocumentIbm3624PinFromOffset(&uv.Value, av); err != nil {
return err
}
case *types.PinGenerationAttributesMemberIbm3624PinOffset:
av := object.Key("Ibm3624PinOffset")
if err := awsRestjson1_serializeDocumentIbm3624PinOffset(&uv.Value, av); err != nil {
return err
}
case *types.PinGenerationAttributesMemberIbm3624RandomPin:
av := object.Key("Ibm3624RandomPin")
if err := awsRestjson1_serializeDocumentIbm3624RandomPin(&uv.Value, av); err != nil {
return err
}
case *types.PinGenerationAttributesMemberVisaPin:
av := object.Key("VisaPin")
if err := awsRestjson1_serializeDocumentVisaPin(&uv.Value, av); err != nil {
return err
}
case *types.PinGenerationAttributesMemberVisaPinVerificationValue:
av := object.Key("VisaPinVerificationValue")
if err := awsRestjson1_serializeDocumentVisaPinVerificationValue(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentPinVerificationAttributes(v types.PinVerificationAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.PinVerificationAttributesMemberIbm3624Pin:
av := object.Key("Ibm3624Pin")
if err := awsRestjson1_serializeDocumentIbm3624PinVerification(&uv.Value, av); err != nil {
return err
}
case *types.PinVerificationAttributesMemberVisaPin:
av := object.Key("VisaPin")
if err := awsRestjson1_serializeDocumentVisaPinVerification(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentReEncryptionAttributes(v types.ReEncryptionAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.ReEncryptionAttributesMemberDukpt:
av := object.Key("Dukpt")
if err := awsRestjson1_serializeDocumentDukptEncryptionAttributes(&uv.Value, av); err != nil {
return err
}
case *types.ReEncryptionAttributesMemberSymmetric:
av := object.Key("Symmetric")
if err := awsRestjson1_serializeDocumentSymmetricEncryptionAttributes(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeyAmex(v *types.SessionKeyAmex, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeyDerivation(v types.SessionKeyDerivation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.SessionKeyDerivationMemberAmex:
av := object.Key("Amex")
if err := awsRestjson1_serializeDocumentSessionKeyAmex(&uv.Value, av); err != nil {
return err
}
case *types.SessionKeyDerivationMemberEmv2000:
av := object.Key("Emv2000")
if err := awsRestjson1_serializeDocumentSessionKeyEmv2000(&uv.Value, av); err != nil {
return err
}
case *types.SessionKeyDerivationMemberEmvCommon:
av := object.Key("EmvCommon")
if err := awsRestjson1_serializeDocumentSessionKeyEmvCommon(&uv.Value, av); err != nil {
return err
}
case *types.SessionKeyDerivationMemberMastercard:
av := object.Key("Mastercard")
if err := awsRestjson1_serializeDocumentSessionKeyMastercard(&uv.Value, av); err != nil {
return err
}
case *types.SessionKeyDerivationMemberVisa:
av := object.Key("Visa")
if err := awsRestjson1_serializeDocumentSessionKeyVisa(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeyDerivationValue(v types.SessionKeyDerivationValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.SessionKeyDerivationValueMemberApplicationCryptogram:
av := object.Key("ApplicationCryptogram")
av.String(uv.Value)
case *types.SessionKeyDerivationValueMemberApplicationTransactionCounter:
av := object.Key("ApplicationTransactionCounter")
av.String(uv.Value)
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeyEmv2000(v *types.SessionKeyEmv2000, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplicationTransactionCounter != nil {
ok := object.Key("ApplicationTransactionCounter")
ok.String(*v.ApplicationTransactionCounter)
}
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeyEmvCommon(v *types.SessionKeyEmvCommon, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplicationTransactionCounter != nil {
ok := object.Key("ApplicationTransactionCounter")
ok.String(*v.ApplicationTransactionCounter)
}
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeyMastercard(v *types.SessionKeyMastercard, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplicationTransactionCounter != nil {
ok := object.Key("ApplicationTransactionCounter")
ok.String(*v.ApplicationTransactionCounter)
}
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
if v.UnpredictableNumber != nil {
ok := object.Key("UnpredictableNumber")
ok.String(*v.UnpredictableNumber)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeyVisa(v *types.SessionKeyVisa, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PanSequenceNumber != nil {
ok := object.Key("PanSequenceNumber")
ok.String(*v.PanSequenceNumber)
}
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
return nil
}
func awsRestjson1_serializeDocumentSymmetricEncryptionAttributes(v *types.SymmetricEncryptionAttributes, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InitializationVector != nil {
ok := object.Key("InitializationVector")
ok.String(*v.InitializationVector)
}
if len(v.Mode) > 0 {
ok := object.Key("Mode")
ok.String(string(v.Mode))
}
if len(v.PaddingType) > 0 {
ok := object.Key("PaddingType")
ok.String(string(v.PaddingType))
}
return nil
}
func awsRestjson1_serializeDocumentTranslationIsoFormats(v types.TranslationIsoFormats, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.TranslationIsoFormatsMemberIsoFormat0:
av := object.Key("IsoFormat0")
if err := awsRestjson1_serializeDocumentTranslationPinDataIsoFormat034(&uv.Value, av); err != nil {
return err
}
case *types.TranslationIsoFormatsMemberIsoFormat1:
av := object.Key("IsoFormat1")
if err := awsRestjson1_serializeDocumentTranslationPinDataIsoFormat1(&uv.Value, av); err != nil {
return err
}
case *types.TranslationIsoFormatsMemberIsoFormat3:
av := object.Key("IsoFormat3")
if err := awsRestjson1_serializeDocumentTranslationPinDataIsoFormat034(&uv.Value, av); err != nil {
return err
}
case *types.TranslationIsoFormatsMemberIsoFormat4:
av := object.Key("IsoFormat4")
if err := awsRestjson1_serializeDocumentTranslationPinDataIsoFormat034(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentTranslationPinDataIsoFormat034(v *types.TranslationPinDataIsoFormat034, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PrimaryAccountNumber != nil {
ok := object.Key("PrimaryAccountNumber")
ok.String(*v.PrimaryAccountNumber)
}
return nil
}
func awsRestjson1_serializeDocumentTranslationPinDataIsoFormat1(v *types.TranslationPinDataIsoFormat1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsRestjson1_serializeDocumentVisaPin(v *types.VisaPin, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PinVerificationKeyIndex != nil {
ok := object.Key("PinVerificationKeyIndex")
ok.Integer(*v.PinVerificationKeyIndex)
}
return nil
}
func awsRestjson1_serializeDocumentVisaPinVerification(v *types.VisaPinVerification, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PinVerificationKeyIndex != nil {
ok := object.Key("PinVerificationKeyIndex")
ok.Integer(*v.PinVerificationKeyIndex)
}
if v.VerificationValue != nil {
ok := object.Key("VerificationValue")
ok.String(*v.VerificationValue)
}
return nil
}
func awsRestjson1_serializeDocumentVisaPinVerificationValue(v *types.VisaPinVerificationValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EncryptedPinBlock != nil {
ok := object.Key("EncryptedPinBlock")
ok.String(*v.EncryptedPinBlock)
}
if v.PinVerificationKeyIndex != nil {
ok := object.Key("PinVerificationKeyIndex")
ok.Integer(*v.PinVerificationKeyIndex)
}
return nil
}
| 2,085 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package paymentcryptographydata
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpDecryptData struct {
}
func (*validateOpDecryptData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDecryptData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DecryptDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDecryptDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpEncryptData struct {
}
func (*validateOpEncryptData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpEncryptData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*EncryptDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpEncryptDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGenerateCardValidationData struct {
}
func (*validateOpGenerateCardValidationData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGenerateCardValidationData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GenerateCardValidationDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGenerateCardValidationDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGenerateMac struct {
}
func (*validateOpGenerateMac) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGenerateMac) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GenerateMacInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGenerateMacInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGeneratePinData struct {
}
func (*validateOpGeneratePinData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGeneratePinData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GeneratePinDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGeneratePinDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpReEncryptData struct {
}
func (*validateOpReEncryptData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpReEncryptData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ReEncryptDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpReEncryptDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpTranslatePinData struct {
}
func (*validateOpTranslatePinData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpTranslatePinData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*TranslatePinDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpTranslatePinDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpVerifyAuthRequestCryptogram struct {
}
func (*validateOpVerifyAuthRequestCryptogram) ID() string {
return "OperationInputValidation"
}
func (m *validateOpVerifyAuthRequestCryptogram) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*VerifyAuthRequestCryptogramInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpVerifyAuthRequestCryptogramInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpVerifyCardValidationData struct {
}
func (*validateOpVerifyCardValidationData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpVerifyCardValidationData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*VerifyCardValidationDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpVerifyCardValidationDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpVerifyMac struct {
}
func (*validateOpVerifyMac) ID() string {
return "OperationInputValidation"
}
func (m *validateOpVerifyMac) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*VerifyMacInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpVerifyMacInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpVerifyPinData struct {
}
func (*validateOpVerifyPinData) ID() string {
return "OperationInputValidation"
}
func (m *validateOpVerifyPinData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*VerifyPinDataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpVerifyPinDataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpDecryptDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDecryptData{}, middleware.After)
}
func addOpEncryptDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpEncryptData{}, middleware.After)
}
func addOpGenerateCardValidationDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGenerateCardValidationData{}, middleware.After)
}
func addOpGenerateMacValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGenerateMac{}, middleware.After)
}
func addOpGeneratePinDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGeneratePinData{}, middleware.After)
}
func addOpReEncryptDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpReEncryptData{}, middleware.After)
}
func addOpTranslatePinDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpTranslatePinData{}, middleware.After)
}
func addOpVerifyAuthRequestCryptogramValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpVerifyAuthRequestCryptogram{}, middleware.After)
}
func addOpVerifyCardValidationDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpVerifyCardValidationData{}, middleware.After)
}
func addOpVerifyMacValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpVerifyMac{}, middleware.After)
}
func addOpVerifyPinDataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpVerifyPinData{}, middleware.After)
}
func validateAmexCardSecurityCodeVersion1(v *types.AmexCardSecurityCodeVersion1) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AmexCardSecurityCodeVersion1"}
if v.CardExpiryDate == nil {
invalidParams.Add(smithy.NewErrParamRequired("CardExpiryDate"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAmexCardSecurityCodeVersion2(v *types.AmexCardSecurityCodeVersion2) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AmexCardSecurityCodeVersion2"}
if v.CardExpiryDate == nil {
invalidParams.Add(smithy.NewErrParamRequired("CardExpiryDate"))
}
if v.ServiceCode == nil {
invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCardGenerationAttributes(v types.CardGenerationAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CardGenerationAttributes"}
switch uv := v.(type) {
case *types.CardGenerationAttributesMemberAmexCardSecurityCodeVersion1:
if err := validateAmexCardSecurityCodeVersion1(&uv.Value); err != nil {
invalidParams.AddNested("[AmexCardSecurityCodeVersion1]", err.(smithy.InvalidParamsError))
}
case *types.CardGenerationAttributesMemberAmexCardSecurityCodeVersion2:
if err := validateAmexCardSecurityCodeVersion2(&uv.Value); err != nil {
invalidParams.AddNested("[AmexCardSecurityCodeVersion2]", err.(smithy.InvalidParamsError))
}
case *types.CardGenerationAttributesMemberCardHolderVerificationValue:
if err := validateCardHolderVerificationValue(&uv.Value); err != nil {
invalidParams.AddNested("[CardHolderVerificationValue]", err.(smithy.InvalidParamsError))
}
case *types.CardGenerationAttributesMemberCardVerificationValue1:
if err := validateCardVerificationValue1(&uv.Value); err != nil {
invalidParams.AddNested("[CardVerificationValue1]", err.(smithy.InvalidParamsError))
}
case *types.CardGenerationAttributesMemberCardVerificationValue2:
if err := validateCardVerificationValue2(&uv.Value); err != nil {
invalidParams.AddNested("[CardVerificationValue2]", err.(smithy.InvalidParamsError))
}
case *types.CardGenerationAttributesMemberDynamicCardVerificationCode:
if err := validateDynamicCardVerificationCode(&uv.Value); err != nil {
invalidParams.AddNested("[DynamicCardVerificationCode]", err.(smithy.InvalidParamsError))
}
case *types.CardGenerationAttributesMemberDynamicCardVerificationValue:
if err := validateDynamicCardVerificationValue(&uv.Value); err != nil {
invalidParams.AddNested("[DynamicCardVerificationValue]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCardHolderVerificationValue(v *types.CardHolderVerificationValue) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CardHolderVerificationValue"}
if v.UnpredictableNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("UnpredictableNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if v.ApplicationTransactionCounter == nil {
invalidParams.Add(smithy.NewErrParamRequired("ApplicationTransactionCounter"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCardVerificationAttributes(v types.CardVerificationAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CardVerificationAttributes"}
switch uv := v.(type) {
case *types.CardVerificationAttributesMemberAmexCardSecurityCodeVersion1:
if err := validateAmexCardSecurityCodeVersion1(&uv.Value); err != nil {
invalidParams.AddNested("[AmexCardSecurityCodeVersion1]", err.(smithy.InvalidParamsError))
}
case *types.CardVerificationAttributesMemberAmexCardSecurityCodeVersion2:
if err := validateAmexCardSecurityCodeVersion2(&uv.Value); err != nil {
invalidParams.AddNested("[AmexCardSecurityCodeVersion2]", err.(smithy.InvalidParamsError))
}
case *types.CardVerificationAttributesMemberCardHolderVerificationValue:
if err := validateCardHolderVerificationValue(&uv.Value); err != nil {
invalidParams.AddNested("[CardHolderVerificationValue]", err.(smithy.InvalidParamsError))
}
case *types.CardVerificationAttributesMemberCardVerificationValue1:
if err := validateCardVerificationValue1(&uv.Value); err != nil {
invalidParams.AddNested("[CardVerificationValue1]", err.(smithy.InvalidParamsError))
}
case *types.CardVerificationAttributesMemberCardVerificationValue2:
if err := validateCardVerificationValue2(&uv.Value); err != nil {
invalidParams.AddNested("[CardVerificationValue2]", err.(smithy.InvalidParamsError))
}
case *types.CardVerificationAttributesMemberDiscoverDynamicCardVerificationCode:
if err := validateDiscoverDynamicCardVerificationCode(&uv.Value); err != nil {
invalidParams.AddNested("[DiscoverDynamicCardVerificationCode]", err.(smithy.InvalidParamsError))
}
case *types.CardVerificationAttributesMemberDynamicCardVerificationCode:
if err := validateDynamicCardVerificationCode(&uv.Value); err != nil {
invalidParams.AddNested("[DynamicCardVerificationCode]", err.(smithy.InvalidParamsError))
}
case *types.CardVerificationAttributesMemberDynamicCardVerificationValue:
if err := validateDynamicCardVerificationValue(&uv.Value); err != nil {
invalidParams.AddNested("[DynamicCardVerificationValue]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCardVerificationValue1(v *types.CardVerificationValue1) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CardVerificationValue1"}
if v.CardExpiryDate == nil {
invalidParams.Add(smithy.NewErrParamRequired("CardExpiryDate"))
}
if v.ServiceCode == nil {
invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCardVerificationValue2(v *types.CardVerificationValue2) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CardVerificationValue2"}
if v.CardExpiryDate == nil {
invalidParams.Add(smithy.NewErrParamRequired("CardExpiryDate"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCryptogramAuthResponse(v types.CryptogramAuthResponse) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CryptogramAuthResponse"}
switch uv := v.(type) {
case *types.CryptogramAuthResponseMemberArpcMethod1:
if err := validateCryptogramVerificationArpcMethod1(&uv.Value); err != nil {
invalidParams.AddNested("[ArpcMethod1]", err.(smithy.InvalidParamsError))
}
case *types.CryptogramAuthResponseMemberArpcMethod2:
if err := validateCryptogramVerificationArpcMethod2(&uv.Value); err != nil {
invalidParams.AddNested("[ArpcMethod2]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCryptogramVerificationArpcMethod1(v *types.CryptogramVerificationArpcMethod1) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CryptogramVerificationArpcMethod1"}
if v.AuthResponseCode == nil {
invalidParams.Add(smithy.NewErrParamRequired("AuthResponseCode"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCryptogramVerificationArpcMethod2(v *types.CryptogramVerificationArpcMethod2) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CryptogramVerificationArpcMethod2"}
if v.CardStatusUpdate == nil {
invalidParams.Add(smithy.NewErrParamRequired("CardStatusUpdate"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDiscoverDynamicCardVerificationCode(v *types.DiscoverDynamicCardVerificationCode) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DiscoverDynamicCardVerificationCode"}
if v.CardExpiryDate == nil {
invalidParams.Add(smithy.NewErrParamRequired("CardExpiryDate"))
}
if v.UnpredictableNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("UnpredictableNumber"))
}
if v.ApplicationTransactionCounter == nil {
invalidParams.Add(smithy.NewErrParamRequired("ApplicationTransactionCounter"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDukptAttributes(v *types.DukptAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DukptAttributes"}
if v.KeySerialNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeySerialNumber"))
}
if len(v.DukptDerivationType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("DukptDerivationType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDukptDerivationAttributes(v *types.DukptDerivationAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DukptDerivationAttributes"}
if v.KeySerialNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeySerialNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDukptEncryptionAttributes(v *types.DukptEncryptionAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DukptEncryptionAttributes"}
if v.KeySerialNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeySerialNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDynamicCardVerificationCode(v *types.DynamicCardVerificationCode) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DynamicCardVerificationCode"}
if v.UnpredictableNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("UnpredictableNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if v.ApplicationTransactionCounter == nil {
invalidParams.Add(smithy.NewErrParamRequired("ApplicationTransactionCounter"))
}
if v.TrackData == nil {
invalidParams.Add(smithy.NewErrParamRequired("TrackData"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDynamicCardVerificationValue(v *types.DynamicCardVerificationValue) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DynamicCardVerificationValue"}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if v.CardExpiryDate == nil {
invalidParams.Add(smithy.NewErrParamRequired("CardExpiryDate"))
}
if v.ServiceCode == nil {
invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
}
if v.ApplicationTransactionCounter == nil {
invalidParams.Add(smithy.NewErrParamRequired("ApplicationTransactionCounter"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEncryptionDecryptionAttributes(v types.EncryptionDecryptionAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EncryptionDecryptionAttributes"}
switch uv := v.(type) {
case *types.EncryptionDecryptionAttributesMemberDukpt:
if err := validateDukptEncryptionAttributes(&uv.Value); err != nil {
invalidParams.AddNested("[Dukpt]", err.(smithy.InvalidParamsError))
}
case *types.EncryptionDecryptionAttributesMemberSymmetric:
if err := validateSymmetricEncryptionAttributes(&uv.Value); err != nil {
invalidParams.AddNested("[Symmetric]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIbm3624NaturalPin(v *types.Ibm3624NaturalPin) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Ibm3624NaturalPin"}
if v.DecimalizationTable == nil {
invalidParams.Add(smithy.NewErrParamRequired("DecimalizationTable"))
}
if v.PinValidationDataPadCharacter == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationDataPadCharacter"))
}
if v.PinValidationData == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationData"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIbm3624PinFromOffset(v *types.Ibm3624PinFromOffset) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Ibm3624PinFromOffset"}
if v.DecimalizationTable == nil {
invalidParams.Add(smithy.NewErrParamRequired("DecimalizationTable"))
}
if v.PinValidationDataPadCharacter == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationDataPadCharacter"))
}
if v.PinValidationData == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationData"))
}
if v.PinOffset == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinOffset"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIbm3624PinOffset(v *types.Ibm3624PinOffset) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Ibm3624PinOffset"}
if v.EncryptedPinBlock == nil {
invalidParams.Add(smithy.NewErrParamRequired("EncryptedPinBlock"))
}
if v.DecimalizationTable == nil {
invalidParams.Add(smithy.NewErrParamRequired("DecimalizationTable"))
}
if v.PinValidationDataPadCharacter == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationDataPadCharacter"))
}
if v.PinValidationData == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationData"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIbm3624PinVerification(v *types.Ibm3624PinVerification) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Ibm3624PinVerification"}
if v.DecimalizationTable == nil {
invalidParams.Add(smithy.NewErrParamRequired("DecimalizationTable"))
}
if v.PinValidationDataPadCharacter == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationDataPadCharacter"))
}
if v.PinValidationData == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationData"))
}
if v.PinOffset == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinOffset"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIbm3624RandomPin(v *types.Ibm3624RandomPin) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Ibm3624RandomPin"}
if v.DecimalizationTable == nil {
invalidParams.Add(smithy.NewErrParamRequired("DecimalizationTable"))
}
if v.PinValidationDataPadCharacter == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationDataPadCharacter"))
}
if v.PinValidationData == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinValidationData"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMacAlgorithmDukpt(v *types.MacAlgorithmDukpt) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MacAlgorithmDukpt"}
if v.KeySerialNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeySerialNumber"))
}
if len(v.DukptKeyVariant) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("DukptKeyVariant"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMacAlgorithmEmv(v *types.MacAlgorithmEmv) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MacAlgorithmEmv"}
if len(v.MajorKeyDerivationMode) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("MajorKeyDerivationMode"))
}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if len(v.SessionKeyDerivationMode) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("SessionKeyDerivationMode"))
}
if v.SessionKeyDerivationValue == nil {
invalidParams.Add(smithy.NewErrParamRequired("SessionKeyDerivationValue"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMacAttributes(v types.MacAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MacAttributes"}
switch uv := v.(type) {
case *types.MacAttributesMemberDukptCmac:
if err := validateMacAlgorithmDukpt(&uv.Value); err != nil {
invalidParams.AddNested("[DukptCmac]", err.(smithy.InvalidParamsError))
}
case *types.MacAttributesMemberDukptIso9797Algorithm1:
if err := validateMacAlgorithmDukpt(&uv.Value); err != nil {
invalidParams.AddNested("[DukptIso9797Algorithm1]", err.(smithy.InvalidParamsError))
}
case *types.MacAttributesMemberDukptIso9797Algorithm3:
if err := validateMacAlgorithmDukpt(&uv.Value); err != nil {
invalidParams.AddNested("[DukptIso9797Algorithm3]", err.(smithy.InvalidParamsError))
}
case *types.MacAttributesMemberEmvMac:
if err := validateMacAlgorithmEmv(&uv.Value); err != nil {
invalidParams.AddNested("[EmvMac]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePinGenerationAttributes(v types.PinGenerationAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PinGenerationAttributes"}
switch uv := v.(type) {
case *types.PinGenerationAttributesMemberIbm3624NaturalPin:
if err := validateIbm3624NaturalPin(&uv.Value); err != nil {
invalidParams.AddNested("[Ibm3624NaturalPin]", err.(smithy.InvalidParamsError))
}
case *types.PinGenerationAttributesMemberIbm3624PinFromOffset:
if err := validateIbm3624PinFromOffset(&uv.Value); err != nil {
invalidParams.AddNested("[Ibm3624PinFromOffset]", err.(smithy.InvalidParamsError))
}
case *types.PinGenerationAttributesMemberIbm3624PinOffset:
if err := validateIbm3624PinOffset(&uv.Value); err != nil {
invalidParams.AddNested("[Ibm3624PinOffset]", err.(smithy.InvalidParamsError))
}
case *types.PinGenerationAttributesMemberIbm3624RandomPin:
if err := validateIbm3624RandomPin(&uv.Value); err != nil {
invalidParams.AddNested("[Ibm3624RandomPin]", err.(smithy.InvalidParamsError))
}
case *types.PinGenerationAttributesMemberVisaPin:
if err := validateVisaPin(&uv.Value); err != nil {
invalidParams.AddNested("[VisaPin]", err.(smithy.InvalidParamsError))
}
case *types.PinGenerationAttributesMemberVisaPinVerificationValue:
if err := validateVisaPinVerificationValue(&uv.Value); err != nil {
invalidParams.AddNested("[VisaPinVerificationValue]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePinVerificationAttributes(v types.PinVerificationAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PinVerificationAttributes"}
switch uv := v.(type) {
case *types.PinVerificationAttributesMemberIbm3624Pin:
if err := validateIbm3624PinVerification(&uv.Value); err != nil {
invalidParams.AddNested("[Ibm3624Pin]", err.(smithy.InvalidParamsError))
}
case *types.PinVerificationAttributesMemberVisaPin:
if err := validateVisaPinVerification(&uv.Value); err != nil {
invalidParams.AddNested("[VisaPin]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateReEncryptionAttributes(v types.ReEncryptionAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ReEncryptionAttributes"}
switch uv := v.(type) {
case *types.ReEncryptionAttributesMemberDukpt:
if err := validateDukptEncryptionAttributes(&uv.Value); err != nil {
invalidParams.AddNested("[Dukpt]", err.(smithy.InvalidParamsError))
}
case *types.ReEncryptionAttributesMemberSymmetric:
if err := validateSymmetricEncryptionAttributes(&uv.Value); err != nil {
invalidParams.AddNested("[Symmetric]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSessionKeyAmex(v *types.SessionKeyAmex) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SessionKeyAmex"}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSessionKeyDerivation(v types.SessionKeyDerivation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SessionKeyDerivation"}
switch uv := v.(type) {
case *types.SessionKeyDerivationMemberAmex:
if err := validateSessionKeyAmex(&uv.Value); err != nil {
invalidParams.AddNested("[Amex]", err.(smithy.InvalidParamsError))
}
case *types.SessionKeyDerivationMemberEmv2000:
if err := validateSessionKeyEmv2000(&uv.Value); err != nil {
invalidParams.AddNested("[Emv2000]", err.(smithy.InvalidParamsError))
}
case *types.SessionKeyDerivationMemberEmvCommon:
if err := validateSessionKeyEmvCommon(&uv.Value); err != nil {
invalidParams.AddNested("[EmvCommon]", err.(smithy.InvalidParamsError))
}
case *types.SessionKeyDerivationMemberMastercard:
if err := validateSessionKeyMastercard(&uv.Value); err != nil {
invalidParams.AddNested("[Mastercard]", err.(smithy.InvalidParamsError))
}
case *types.SessionKeyDerivationMemberVisa:
if err := validateSessionKeyVisa(&uv.Value); err != nil {
invalidParams.AddNested("[Visa]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSessionKeyEmv2000(v *types.SessionKeyEmv2000) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SessionKeyEmv2000"}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if v.ApplicationTransactionCounter == nil {
invalidParams.Add(smithy.NewErrParamRequired("ApplicationTransactionCounter"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSessionKeyEmvCommon(v *types.SessionKeyEmvCommon) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SessionKeyEmvCommon"}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if v.ApplicationTransactionCounter == nil {
invalidParams.Add(smithy.NewErrParamRequired("ApplicationTransactionCounter"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSessionKeyMastercard(v *types.SessionKeyMastercard) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SessionKeyMastercard"}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if v.ApplicationTransactionCounter == nil {
invalidParams.Add(smithy.NewErrParamRequired("ApplicationTransactionCounter"))
}
if v.UnpredictableNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("UnpredictableNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSessionKeyVisa(v *types.SessionKeyVisa) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SessionKeyVisa"}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.PanSequenceNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PanSequenceNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSymmetricEncryptionAttributes(v *types.SymmetricEncryptionAttributes) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SymmetricEncryptionAttributes"}
if len(v.Mode) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Mode"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTranslationIsoFormats(v types.TranslationIsoFormats) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TranslationIsoFormats"}
switch uv := v.(type) {
case *types.TranslationIsoFormatsMemberIsoFormat0:
if err := validateTranslationPinDataIsoFormat034(&uv.Value); err != nil {
invalidParams.AddNested("[IsoFormat0]", err.(smithy.InvalidParamsError))
}
case *types.TranslationIsoFormatsMemberIsoFormat3:
if err := validateTranslationPinDataIsoFormat034(&uv.Value); err != nil {
invalidParams.AddNested("[IsoFormat3]", err.(smithy.InvalidParamsError))
}
case *types.TranslationIsoFormatsMemberIsoFormat4:
if err := validateTranslationPinDataIsoFormat034(&uv.Value); err != nil {
invalidParams.AddNested("[IsoFormat4]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTranslationPinDataIsoFormat034(v *types.TranslationPinDataIsoFormat034) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TranslationPinDataIsoFormat034"}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVisaPin(v *types.VisaPin) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VisaPin"}
if v.PinVerificationKeyIndex == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinVerificationKeyIndex"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVisaPinVerification(v *types.VisaPinVerification) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VisaPinVerification"}
if v.PinVerificationKeyIndex == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinVerificationKeyIndex"))
}
if v.VerificationValue == nil {
invalidParams.Add(smithy.NewErrParamRequired("VerificationValue"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVisaPinVerificationValue(v *types.VisaPinVerificationValue) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VisaPinVerificationValue"}
if v.EncryptedPinBlock == nil {
invalidParams.Add(smithy.NewErrParamRequired("EncryptedPinBlock"))
}
if v.PinVerificationKeyIndex == nil {
invalidParams.Add(smithy.NewErrParamRequired("PinVerificationKeyIndex"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDecryptDataInput(v *DecryptDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DecryptDataInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if v.CipherText == nil {
invalidParams.Add(smithy.NewErrParamRequired("CipherText"))
}
if v.DecryptionAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("DecryptionAttributes"))
} else if v.DecryptionAttributes != nil {
if err := validateEncryptionDecryptionAttributes(v.DecryptionAttributes); err != nil {
invalidParams.AddNested("DecryptionAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpEncryptDataInput(v *EncryptDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EncryptDataInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if v.PlainText == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlainText"))
}
if v.EncryptionAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("EncryptionAttributes"))
} else if v.EncryptionAttributes != nil {
if err := validateEncryptionDecryptionAttributes(v.EncryptionAttributes); err != nil {
invalidParams.AddNested("EncryptionAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGenerateCardValidationDataInput(v *GenerateCardValidationDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GenerateCardValidationDataInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.GenerationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("GenerationAttributes"))
} else if v.GenerationAttributes != nil {
if err := validateCardGenerationAttributes(v.GenerationAttributes); err != nil {
invalidParams.AddNested("GenerationAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGenerateMacInput(v *GenerateMacInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GenerateMacInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if v.MessageData == nil {
invalidParams.Add(smithy.NewErrParamRequired("MessageData"))
}
if v.GenerationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("GenerationAttributes"))
} else if v.GenerationAttributes != nil {
if err := validateMacAttributes(v.GenerationAttributes); err != nil {
invalidParams.AddNested("GenerationAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGeneratePinDataInput(v *GeneratePinDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GeneratePinDataInput"}
if v.GenerationKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("GenerationKeyIdentifier"))
}
if v.EncryptionKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("EncryptionKeyIdentifier"))
}
if v.GenerationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("GenerationAttributes"))
} else if v.GenerationAttributes != nil {
if err := validatePinGenerationAttributes(v.GenerationAttributes); err != nil {
invalidParams.AddNested("GenerationAttributes", err.(smithy.InvalidParamsError))
}
}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if len(v.PinBlockFormat) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PinBlockFormat"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpReEncryptDataInput(v *ReEncryptDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ReEncryptDataInput"}
if v.IncomingKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("IncomingKeyIdentifier"))
}
if v.OutgoingKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("OutgoingKeyIdentifier"))
}
if v.CipherText == nil {
invalidParams.Add(smithy.NewErrParamRequired("CipherText"))
}
if v.IncomingEncryptionAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("IncomingEncryptionAttributes"))
} else if v.IncomingEncryptionAttributes != nil {
if err := validateReEncryptionAttributes(v.IncomingEncryptionAttributes); err != nil {
invalidParams.AddNested("IncomingEncryptionAttributes", err.(smithy.InvalidParamsError))
}
}
if v.OutgoingEncryptionAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("OutgoingEncryptionAttributes"))
} else if v.OutgoingEncryptionAttributes != nil {
if err := validateReEncryptionAttributes(v.OutgoingEncryptionAttributes); err != nil {
invalidParams.AddNested("OutgoingEncryptionAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTranslatePinDataInput(v *TranslatePinDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TranslatePinDataInput"}
if v.IncomingKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("IncomingKeyIdentifier"))
}
if v.OutgoingKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("OutgoingKeyIdentifier"))
}
if v.IncomingTranslationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("IncomingTranslationAttributes"))
} else if v.IncomingTranslationAttributes != nil {
if err := validateTranslationIsoFormats(v.IncomingTranslationAttributes); err != nil {
invalidParams.AddNested("IncomingTranslationAttributes", err.(smithy.InvalidParamsError))
}
}
if v.OutgoingTranslationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("OutgoingTranslationAttributes"))
} else if v.OutgoingTranslationAttributes != nil {
if err := validateTranslationIsoFormats(v.OutgoingTranslationAttributes); err != nil {
invalidParams.AddNested("OutgoingTranslationAttributes", err.(smithy.InvalidParamsError))
}
}
if v.EncryptedPinBlock == nil {
invalidParams.Add(smithy.NewErrParamRequired("EncryptedPinBlock"))
}
if v.IncomingDukptAttributes != nil {
if err := validateDukptDerivationAttributes(v.IncomingDukptAttributes); err != nil {
invalidParams.AddNested("IncomingDukptAttributes", err.(smithy.InvalidParamsError))
}
}
if v.OutgoingDukptAttributes != nil {
if err := validateDukptDerivationAttributes(v.OutgoingDukptAttributes); err != nil {
invalidParams.AddNested("OutgoingDukptAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpVerifyAuthRequestCryptogramInput(v *VerifyAuthRequestCryptogramInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VerifyAuthRequestCryptogramInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if v.TransactionData == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransactionData"))
}
if v.AuthRequestCryptogram == nil {
invalidParams.Add(smithy.NewErrParamRequired("AuthRequestCryptogram"))
}
if len(v.MajorKeyDerivationMode) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("MajorKeyDerivationMode"))
}
if v.SessionKeyDerivationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("SessionKeyDerivationAttributes"))
} else if v.SessionKeyDerivationAttributes != nil {
if err := validateSessionKeyDerivation(v.SessionKeyDerivationAttributes); err != nil {
invalidParams.AddNested("SessionKeyDerivationAttributes", err.(smithy.InvalidParamsError))
}
}
if v.AuthResponseAttributes != nil {
if err := validateCryptogramAuthResponse(v.AuthResponseAttributes); err != nil {
invalidParams.AddNested("AuthResponseAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpVerifyCardValidationDataInput(v *VerifyCardValidationDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VerifyCardValidationDataInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if v.VerificationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("VerificationAttributes"))
} else if v.VerificationAttributes != nil {
if err := validateCardVerificationAttributes(v.VerificationAttributes); err != nil {
invalidParams.AddNested("VerificationAttributes", err.(smithy.InvalidParamsError))
}
}
if v.ValidationData == nil {
invalidParams.Add(smithy.NewErrParamRequired("ValidationData"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpVerifyMacInput(v *VerifyMacInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VerifyMacInput"}
if v.KeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("KeyIdentifier"))
}
if v.MessageData == nil {
invalidParams.Add(smithy.NewErrParamRequired("MessageData"))
}
if v.Mac == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mac"))
}
if v.VerificationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("VerificationAttributes"))
} else if v.VerificationAttributes != nil {
if err := validateMacAttributes(v.VerificationAttributes); err != nil {
invalidParams.AddNested("VerificationAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpVerifyPinDataInput(v *VerifyPinDataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VerifyPinDataInput"}
if v.VerificationKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("VerificationKeyIdentifier"))
}
if v.EncryptionKeyIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("EncryptionKeyIdentifier"))
}
if v.VerificationAttributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("VerificationAttributes"))
} else if v.VerificationAttributes != nil {
if err := validatePinVerificationAttributes(v.VerificationAttributes); err != nil {
invalidParams.AddNested("VerificationAttributes", err.(smithy.InvalidParamsError))
}
}
if v.EncryptedPinBlock == nil {
invalidParams.Add(smithy.NewErrParamRequired("EncryptedPinBlock"))
}
if v.PrimaryAccountNumber == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryAccountNumber"))
}
if len(v.PinBlockFormat) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PinBlockFormat"))
}
if v.DukptAttributes != nil {
if err := validateDukptAttributes(v.DukptAttributes); err != nil {
invalidParams.AddNested("DukptAttributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 1,539 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver Payment Cryptography Data endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "dataplane.payment-cryptography.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "dataplane.payment-cryptography.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "dataplane.payment-cryptography.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "dataplane.payment-cryptography.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "dataplane.payment-cryptography.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "dataplane.payment-cryptography.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "dataplane.payment-cryptography.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "dataplane.payment-cryptography.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "dataplane.payment-cryptography.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "dataplane.payment-cryptography-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "dataplane.payment-cryptography.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 297 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type DukptDerivationType string
// Enum values for DukptDerivationType
const (
DukptDerivationTypeTdes2key DukptDerivationType = "TDES_2KEY"
DukptDerivationTypeTdes3key DukptDerivationType = "TDES_3KEY"
DukptDerivationTypeAes128 DukptDerivationType = "AES_128"
DukptDerivationTypeAes192 DukptDerivationType = "AES_192"
DukptDerivationTypeAes256 DukptDerivationType = "AES_256"
)
// Values returns all known values for DukptDerivationType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (DukptDerivationType) Values() []DukptDerivationType {
return []DukptDerivationType{
"TDES_2KEY",
"TDES_3KEY",
"AES_128",
"AES_192",
"AES_256",
}
}
type DukptEncryptionMode string
// Enum values for DukptEncryptionMode
const (
DukptEncryptionModeEcb DukptEncryptionMode = "ECB"
DukptEncryptionModeCbc DukptEncryptionMode = "CBC"
)
// Values returns all known values for DukptEncryptionMode. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (DukptEncryptionMode) Values() []DukptEncryptionMode {
return []DukptEncryptionMode{
"ECB",
"CBC",
}
}
type DukptKeyVariant string
// Enum values for DukptKeyVariant
const (
DukptKeyVariantBidirectional DukptKeyVariant = "BIDIRECTIONAL"
DukptKeyVariantRequest DukptKeyVariant = "REQUEST"
DukptKeyVariantResponse DukptKeyVariant = "RESPONSE"
)
// Values returns all known values for DukptKeyVariant. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (DukptKeyVariant) Values() []DukptKeyVariant {
return []DukptKeyVariant{
"BIDIRECTIONAL",
"REQUEST",
"RESPONSE",
}
}
type EncryptionMode string
// Enum values for EncryptionMode
const (
EncryptionModeEcb EncryptionMode = "ECB"
EncryptionModeCbc EncryptionMode = "CBC"
EncryptionModeCfb EncryptionMode = "CFB"
EncryptionModeCfb1 EncryptionMode = "CFB1"
EncryptionModeCfb8 EncryptionMode = "CFB8"
EncryptionModeCfb64 EncryptionMode = "CFB64"
EncryptionModeCfb128 EncryptionMode = "CFB128"
EncryptionModeOfb EncryptionMode = "OFB"
)
// Values returns all known values for EncryptionMode. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (EncryptionMode) Values() []EncryptionMode {
return []EncryptionMode{
"ECB",
"CBC",
"CFB",
"CFB1",
"CFB8",
"CFB64",
"CFB128",
"OFB",
}
}
type MacAlgorithm string
// Enum values for MacAlgorithm
const (
MacAlgorithmIso9797Algorithm1 MacAlgorithm = "ISO9797_ALGORITHM1"
MacAlgorithmIso9797Algorithm3 MacAlgorithm = "ISO9797_ALGORITHM3"
MacAlgorithmCmac MacAlgorithm = "CMAC"
MacAlgorithmHmacSha224 MacAlgorithm = "HMAC_SHA224"
MacAlgorithmHmacSha256 MacAlgorithm = "HMAC_SHA256"
MacAlgorithmHmacSha384 MacAlgorithm = "HMAC_SHA384"
MacAlgorithmHmacSha512 MacAlgorithm = "HMAC_SHA512"
)
// Values returns all known values for MacAlgorithm. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (MacAlgorithm) Values() []MacAlgorithm {
return []MacAlgorithm{
"ISO9797_ALGORITHM1",
"ISO9797_ALGORITHM3",
"CMAC",
"HMAC_SHA224",
"HMAC_SHA256",
"HMAC_SHA384",
"HMAC_SHA512",
}
}
type MajorKeyDerivationMode string
// Enum values for MajorKeyDerivationMode
const (
MajorKeyDerivationModeEmvOptionA MajorKeyDerivationMode = "EMV_OPTION_A"
MajorKeyDerivationModeEmvOptionB MajorKeyDerivationMode = "EMV_OPTION_B"
)
// Values returns all known values for MajorKeyDerivationMode. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (MajorKeyDerivationMode) Values() []MajorKeyDerivationMode {
return []MajorKeyDerivationMode{
"EMV_OPTION_A",
"EMV_OPTION_B",
}
}
type PaddingType string
// Enum values for PaddingType
const (
PaddingTypePkcs1 PaddingType = "PKCS1"
PaddingTypeOaepSha1 PaddingType = "OAEP_SHA1"
PaddingTypeOaepSha256 PaddingType = "OAEP_SHA256"
PaddingTypeOaepSha512 PaddingType = "OAEP_SHA512"
)
// Values returns all known values for PaddingType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (PaddingType) Values() []PaddingType {
return []PaddingType{
"PKCS1",
"OAEP_SHA1",
"OAEP_SHA256",
"OAEP_SHA512",
}
}
type PinBlockFormatForPinData string
// Enum values for PinBlockFormatForPinData
const (
PinBlockFormatForPinDataIsoFormat0 PinBlockFormatForPinData = "ISO_FORMAT_0"
PinBlockFormatForPinDataIsoFormat3 PinBlockFormatForPinData = "ISO_FORMAT_3"
)
// Values returns all known values for PinBlockFormatForPinData. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (PinBlockFormatForPinData) Values() []PinBlockFormatForPinData {
return []PinBlockFormatForPinData{
"ISO_FORMAT_0",
"ISO_FORMAT_3",
}
}
type SessionKeyDerivationMode string
// Enum values for SessionKeyDerivationMode
const (
SessionKeyDerivationModeEmvCommonSessionKey SessionKeyDerivationMode = "EMV_COMMON_SESSION_KEY"
SessionKeyDerivationModeEmv2000 SessionKeyDerivationMode = "EMV2000"
SessionKeyDerivationModeAmex SessionKeyDerivationMode = "AMEX"
SessionKeyDerivationModeMastercardSessionKey SessionKeyDerivationMode = "MASTERCARD_SESSION_KEY"
SessionKeyDerivationModeVisa SessionKeyDerivationMode = "VISA"
)
// Values returns all known values for SessionKeyDerivationMode. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (SessionKeyDerivationMode) Values() []SessionKeyDerivationMode {
return []SessionKeyDerivationMode{
"EMV_COMMON_SESSION_KEY",
"EMV2000",
"AMEX",
"MASTERCARD_SESSION_KEY",
"VISA",
}
}
type VerificationFailedReason string
// Enum values for VerificationFailedReason
const (
VerificationFailedReasonInvalidMac VerificationFailedReason = "INVALID_MAC"
VerificationFailedReasonInvalidPin VerificationFailedReason = "INVALID_PIN"
VerificationFailedReasonInvalidValidationData VerificationFailedReason = "INVALID_VALIDATION_DATA"
VerificationFailedReasonInvalidAuthRequestCryptogram VerificationFailedReason = "INVALID_AUTH_REQUEST_CRYPTOGRAM"
)
// Values returns all known values for VerificationFailedReason. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (VerificationFailedReason) Values() []VerificationFailedReason {
return []VerificationFailedReason{
"INVALID_MAC",
"INVALID_PIN",
"INVALID_VALIDATION_DATA",
"INVALID_AUTH_REQUEST_CRYPTOGRAM",
}
}
| 228 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// You do not have sufficient access to perform this action.
type AccessDeniedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AccessDeniedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AccessDeniedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AccessDeniedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AccessDeniedException"
}
return *e.ErrorCodeOverride
}
func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request processing has failed because of an unknown error, exception, or
// failure.
type InternalServerException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalServerException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServerException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServerException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServerException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The request was denied due to an invalid resource error.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request was denied due to request throttling.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ThrottlingException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ThrottlingException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ThrottlingException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ThrottlingException"
}
return *e.ErrorCodeOverride
}
func (e *ThrottlingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request was denied due to an invalid request error.
type ValidationException struct {
Message *string
ErrorCodeOverride *string
FieldList []ValidationExceptionField
noSmithyDocumentSerde
}
func (e *ValidationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationException"
}
return *e.ErrorCodeOverride
}
func (e *ValidationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// This request failed verification.
type VerificationFailedException struct {
Message *string
ErrorCodeOverride *string
Reason VerificationFailedReason
noSmithyDocumentSerde
}
func (e *VerificationFailedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *VerificationFailedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *VerificationFailedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "VerificationFailedException"
}
return *e.ErrorCodeOverride
}
func (e *VerificationFailedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 172 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
)
// Card data parameters that are required to generate a Card Security Code (CSC2)
// for an AMEX payment card.
type AmexCardSecurityCodeVersion1 struct {
// The expiry date of a payment card.
//
// This member is required.
CardExpiryDate *string
noSmithyDocumentSerde
}
// Card data parameters that are required to generate a Card Security Code (CSC2)
// for an AMEX payment card.
type AmexCardSecurityCodeVersion2 struct {
// The expiry date of a payment card.
//
// This member is required.
CardExpiryDate *string
// The service code of the AMEX payment card. This is different from the Card
// Security Code (CSC).
//
// This member is required.
ServiceCode *string
noSmithyDocumentSerde
}
// Parameters for plaintext encryption using asymmetric keys.
type AsymmetricEncryptionAttributes struct {
// The padding to be included with the data.
PaddingType PaddingType
noSmithyDocumentSerde
}
// Card data parameters that are required to generate Card Verification Values
// (CVV/CVV2), Dynamic Card Verification Values (dCVV/dCVV2), or Card Security
// Codes (CSC).
//
// The following types satisfy this interface:
//
// CardGenerationAttributesMemberAmexCardSecurityCodeVersion1
// CardGenerationAttributesMemberAmexCardSecurityCodeVersion2
// CardGenerationAttributesMemberCardHolderVerificationValue
// CardGenerationAttributesMemberCardVerificationValue1
// CardGenerationAttributesMemberCardVerificationValue2
// CardGenerationAttributesMemberDynamicCardVerificationCode
// CardGenerationAttributesMemberDynamicCardVerificationValue
type CardGenerationAttributes interface {
isCardGenerationAttributes()
}
// Card data parameters that are required to generate a Card Security Code (CSC2)
// for an AMEX payment card.
type CardGenerationAttributesMemberAmexCardSecurityCodeVersion1 struct {
Value AmexCardSecurityCodeVersion1
noSmithyDocumentSerde
}
func (*CardGenerationAttributesMemberAmexCardSecurityCodeVersion1) isCardGenerationAttributes() {}
// Card data parameters that are required to generate a Card Security Code (CSC2)
// for an AMEX payment card.
type CardGenerationAttributesMemberAmexCardSecurityCodeVersion2 struct {
Value AmexCardSecurityCodeVersion2
noSmithyDocumentSerde
}
func (*CardGenerationAttributesMemberAmexCardSecurityCodeVersion2) isCardGenerationAttributes() {}
// Card data parameters that are required to generate a cardholder verification
// value for the payment card.
type CardGenerationAttributesMemberCardHolderVerificationValue struct {
Value CardHolderVerificationValue
noSmithyDocumentSerde
}
func (*CardGenerationAttributesMemberCardHolderVerificationValue) isCardGenerationAttributes() {}
// Card data parameters that are required to generate Card Verification Value
// (CVV) for the payment card.
type CardGenerationAttributesMemberCardVerificationValue1 struct {
Value CardVerificationValue1
noSmithyDocumentSerde
}
func (*CardGenerationAttributesMemberCardVerificationValue1) isCardGenerationAttributes() {}
// Card data parameters that are required to generate Card Verification Value
// (CVV2) for the payment card.
type CardGenerationAttributesMemberCardVerificationValue2 struct {
Value CardVerificationValue2
noSmithyDocumentSerde
}
func (*CardGenerationAttributesMemberCardVerificationValue2) isCardGenerationAttributes() {}
// Card data parameters that are required to generate CDynamic Card Verification
// Code (dCVC) for the payment card.
type CardGenerationAttributesMemberDynamicCardVerificationCode struct {
Value DynamicCardVerificationCode
noSmithyDocumentSerde
}
func (*CardGenerationAttributesMemberDynamicCardVerificationCode) isCardGenerationAttributes() {}
// Card data parameters that are required to generate CDynamic Card Verification
// Value (dCVV) for the payment card.
type CardGenerationAttributesMemberDynamicCardVerificationValue struct {
Value DynamicCardVerificationValue
noSmithyDocumentSerde
}
func (*CardGenerationAttributesMemberDynamicCardVerificationValue) isCardGenerationAttributes() {}
// Card data parameters that are required to generate a cardholder verification
// value for the payment card.
type CardHolderVerificationValue struct {
// The transaction counter value that comes from a point of sale terminal.
//
// This member is required.
ApplicationTransactionCounter *string
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// A random number generated by the issuer.
//
// This member is required.
UnpredictableNumber *string
noSmithyDocumentSerde
}
// Card data parameters that are requried to verify Card Verification Values
// (CVV/CVV2), Dynamic Card Verification Values (dCVV/dCVV2), or Card Security
// Codes (CSC).
//
// The following types satisfy this interface:
//
// CardVerificationAttributesMemberAmexCardSecurityCodeVersion1
// CardVerificationAttributesMemberAmexCardSecurityCodeVersion2
// CardVerificationAttributesMemberCardHolderVerificationValue
// CardVerificationAttributesMemberCardVerificationValue1
// CardVerificationAttributesMemberCardVerificationValue2
// CardVerificationAttributesMemberDiscoverDynamicCardVerificationCode
// CardVerificationAttributesMemberDynamicCardVerificationCode
// CardVerificationAttributesMemberDynamicCardVerificationValue
type CardVerificationAttributes interface {
isCardVerificationAttributes()
}
// Card data parameters that are required to generate a Card Security Code (CSC2)
// for an AMEX payment card.
type CardVerificationAttributesMemberAmexCardSecurityCodeVersion1 struct {
Value AmexCardSecurityCodeVersion1
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberAmexCardSecurityCodeVersion1) isCardVerificationAttributes() {}
// Card data parameters that are required to verify a Card Security Code (CSC2)
// for an AMEX payment card.
type CardVerificationAttributesMemberAmexCardSecurityCodeVersion2 struct {
Value AmexCardSecurityCodeVersion2
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberAmexCardSecurityCodeVersion2) isCardVerificationAttributes() {}
// Card data parameters that are required to verify a cardholder verification
// value for the payment card.
type CardVerificationAttributesMemberCardHolderVerificationValue struct {
Value CardHolderVerificationValue
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberCardHolderVerificationValue) isCardVerificationAttributes() {}
// Card data parameters that are required to verify Card Verification Value (CVV)
// for the payment card.
type CardVerificationAttributesMemberCardVerificationValue1 struct {
Value CardVerificationValue1
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberCardVerificationValue1) isCardVerificationAttributes() {}
// Card data parameters that are required to verify Card Verification Value (CVV2)
// for the payment card.
type CardVerificationAttributesMemberCardVerificationValue2 struct {
Value CardVerificationValue2
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberCardVerificationValue2) isCardVerificationAttributes() {}
// Card data parameters that are required to verify CDynamic Card Verification
// Code (dCVC) for the payment card.
type CardVerificationAttributesMemberDiscoverDynamicCardVerificationCode struct {
Value DiscoverDynamicCardVerificationCode
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberDiscoverDynamicCardVerificationCode) isCardVerificationAttributes() {
}
// Card data parameters that are required to verify CDynamic Card Verification
// Code (dCVC) for the payment card.
type CardVerificationAttributesMemberDynamicCardVerificationCode struct {
Value DynamicCardVerificationCode
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberDynamicCardVerificationCode) isCardVerificationAttributes() {}
// Card data parameters that are required to verify CDynamic Card Verification
// Value (dCVV) for the payment card.
type CardVerificationAttributesMemberDynamicCardVerificationValue struct {
Value DynamicCardVerificationValue
noSmithyDocumentSerde
}
func (*CardVerificationAttributesMemberDynamicCardVerificationValue) isCardVerificationAttributes() {}
// Card data parameters that are required to verify CVV (Card Verification Value)
// for the payment card.
type CardVerificationValue1 struct {
// The expiry date of a payment card.
//
// This member is required.
CardExpiryDate *string
// The service code of the payment card. This is different from Card Security Code
// (CSC).
//
// This member is required.
ServiceCode *string
noSmithyDocumentSerde
}
// Card data parameters that are required to verify Card Verification Value (CVV2)
// for the payment card.
type CardVerificationValue2 struct {
// The expiry date of a payment card.
//
// This member is required.
CardExpiryDate *string
noSmithyDocumentSerde
}
// Parameters that are required for Authorization Response Cryptogram (ARPC)
// generation after Authorization Request Cryptogram (ARQC) verification is
// successful.
//
// The following types satisfy this interface:
//
// CryptogramAuthResponseMemberArpcMethod1
// CryptogramAuthResponseMemberArpcMethod2
type CryptogramAuthResponse interface {
isCryptogramAuthResponse()
}
// Parameters that are required for ARPC response generation using method1 after
// ARQC verification is successful.
type CryptogramAuthResponseMemberArpcMethod1 struct {
Value CryptogramVerificationArpcMethod1
noSmithyDocumentSerde
}
func (*CryptogramAuthResponseMemberArpcMethod1) isCryptogramAuthResponse() {}
// Parameters that are required for ARPC response generation using method2 after
// ARQC verification is successful.
type CryptogramAuthResponseMemberArpcMethod2 struct {
Value CryptogramVerificationArpcMethod2
noSmithyDocumentSerde
}
func (*CryptogramAuthResponseMemberArpcMethod2) isCryptogramAuthResponse() {}
// Parameters that are required for ARPC response generation using method1 after
// ARQC verification is successful.
type CryptogramVerificationArpcMethod1 struct {
// The auth code used to calculate APRC after ARQC verification is successful.
// This is the same auth code used for ARQC generation outside of Amazon Web
// Services Payment Cryptography.
//
// This member is required.
AuthResponseCode *string
noSmithyDocumentSerde
}
// Parameters that are required for ARPC response generation using method2 after
// ARQC verification is successful.
type CryptogramVerificationArpcMethod2 struct {
// The data indicating whether the issuer approves or declines an online
// transaction using an EMV chip card.
//
// This member is required.
CardStatusUpdate *string
// The proprietary authentication data used by issuer for communication during
// online transaction using an EMV chip card.
ProprietaryAuthenticationData *string
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify dCVC (Dynamic Card
// Verification Code).
type DiscoverDynamicCardVerificationCode struct {
// The transaction counter value that comes from the terminal.
//
// This member is required.
ApplicationTransactionCounter *string
// The expiry date of a payment card.
//
// This member is required.
CardExpiryDate *string
// A random number that is generated by the issuer.
//
// This member is required.
UnpredictableNumber *string
noSmithyDocumentSerde
}
// Parameters that are used for Derived Unique Key Per Transaction (DUKPT)
// derivation algorithm.
type DukptAttributes struct {
// The key type derived using DUKPT from a Base Derivation Key (BDK) and Key
// Serial Number (KSN). This must be less than or equal to the strength of the BDK.
// For example, you can't use AES_128 as a derivation type for a BDK of AES_128 or
// TDES_2KEY .
//
// This member is required.
DukptDerivationType DukptDerivationType
// The unique identifier known as Key Serial Number (KSN) that comes from an
// encrypting device using DUKPT encryption method. The KSN is derived from the
// encrypting device unique identifier and an internal transaction counter.
//
// This member is required.
KeySerialNumber *string
noSmithyDocumentSerde
}
// Parameters required for encryption or decryption of data using DUKPT.
type DukptDerivationAttributes struct {
// The unique identifier known as Key Serial Number (KSN) that comes from an
// encrypting device using DUKPT encryption method. The KSN is derived from the
// encrypting device unique identifier and an internal transaction counter.
//
// This member is required.
KeySerialNumber *string
// The key type derived using DUKPT from a Base Derivation Key (BDK) and Key
// Serial Number (KSN). This must be less than or equal to the strength of the BDK.
// For example, you can't use AES_128 as a derivation type for a BDK of AES_128 or
// TDES_2KEY
DukptKeyDerivationType DukptDerivationType
// The type of use of DUKPT, which can be for incoming data decryption, outgoing
// data encryption, or both.
DukptKeyVariant DukptKeyVariant
noSmithyDocumentSerde
}
// Parameters that are required to encrypt plaintext data using DUKPT.
type DukptEncryptionAttributes struct {
// The unique identifier known as Key Serial Number (KSN) that comes from an
// encrypting device using DUKPT encryption method. The KSN is derived from the
// encrypting device unique identifier and an internal transaction counter.
//
// This member is required.
KeySerialNumber *string
// The key type encrypted using DUKPT from a Base Derivation Key (BDK) and Key
// Serial Number (KSN). This must be less than or equal to the strength of the BDK.
// For example, you can't use AES_128 as a derivation type for a BDK of AES_128 or
// TDES_2KEY
DukptKeyDerivationType DukptDerivationType
// The type of use of DUKPT, which can be incoming data decryption, outgoing data
// encryption, or both.
DukptKeyVariant DukptKeyVariant
// An input to cryptographic primitive used to provide the intial state. Typically
// the InitializationVector must have a random or psuedo-random value, but
// sometimes it only needs to be unpredictable or unique. If you don't provide a
// value, Amazon Web Services Payment Cryptography generates a random value.
InitializationVector *string
// The block cipher mode of operation. Block ciphers are designed to encrypt a
// block of data of fixed size, for example, 128 bits. The size of the input block
// is usually same as the size of the encrypted output block, while the key length
// can be different. A mode of operation describes how to repeatedly apply a
// cipher's single-block operation to securely transform amounts of data larger
// than a block. The default is CBC.
Mode DukptEncryptionMode
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Dynamic Card Verification
// Value (dCVV).
type DynamicCardVerificationCode struct {
// The transaction counter value that comes from the terminal.
//
// This member is required.
ApplicationTransactionCounter *string
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The data on the two tracks of magnetic cards used for financial transactions.
// This includes the cardholder name, PAN, expiration date, bank ID (BIN) and
// several other numbers the issuing bank uses to validate the data received.
//
// This member is required.
TrackData *string
// A random number generated by the issuer.
//
// This member is required.
UnpredictableNumber *string
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Dynamic Card Verification
// Value (dCVV).
type DynamicCardVerificationValue struct {
// The transaction counter value that comes from the terminal.
//
// This member is required.
ApplicationTransactionCounter *string
// The expiry date of a payment card.
//
// This member is required.
CardExpiryDate *string
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The service code of the payment card. This is different from Card Security Code
// (CSC).
//
// This member is required.
ServiceCode *string
noSmithyDocumentSerde
}
// Parameters that are required to perform encryption and decryption operations.
//
// The following types satisfy this interface:
//
// EncryptionDecryptionAttributesMemberAsymmetric
// EncryptionDecryptionAttributesMemberDukpt
// EncryptionDecryptionAttributesMemberSymmetric
type EncryptionDecryptionAttributes interface {
isEncryptionDecryptionAttributes()
}
// Parameters for plaintext encryption using asymmetric keys.
type EncryptionDecryptionAttributesMemberAsymmetric struct {
Value AsymmetricEncryptionAttributes
noSmithyDocumentSerde
}
func (*EncryptionDecryptionAttributesMemberAsymmetric) isEncryptionDecryptionAttributes() {}
// Parameters that are required to encrypt plaintext data using DUKPT.
type EncryptionDecryptionAttributesMemberDukpt struct {
Value DukptEncryptionAttributes
noSmithyDocumentSerde
}
func (*EncryptionDecryptionAttributesMemberDukpt) isEncryptionDecryptionAttributes() {}
// Parameters that are required to perform encryption and decryption using
// symmetric keys.
type EncryptionDecryptionAttributesMemberSymmetric struct {
Value SymmetricEncryptionAttributes
noSmithyDocumentSerde
}
func (*EncryptionDecryptionAttributesMemberSymmetric) isEncryptionDecryptionAttributes() {}
// Parameters that are required to generate or verify Ibm3624 natural PIN.
type Ibm3624NaturalPin struct {
// The decimalization table to use for IBM 3624 PIN algorithm. The table is used
// to convert the algorithm intermediate result from hexadecimal characters to
// decimal.
//
// This member is required.
DecimalizationTable *string
// The unique data for cardholder identification.
//
// This member is required.
PinValidationData *string
// The padding character for validation data.
//
// This member is required.
PinValidationDataPadCharacter *string
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Ibm3624 PIN from offset PIN.
type Ibm3624PinFromOffset struct {
// The decimalization table to use for IBM 3624 PIN algorithm. The table is used
// to convert the algorithm intermediate result from hexadecimal characters to
// decimal.
//
// This member is required.
DecimalizationTable *string
// The PIN offset value.
//
// This member is required.
PinOffset *string
// The unique data for cardholder identification.
//
// This member is required.
PinValidationData *string
// The padding character for validation data.
//
// This member is required.
PinValidationDataPadCharacter *string
noSmithyDocumentSerde
}
// Pparameters that are required to generate or verify Ibm3624 PIN offset PIN.
type Ibm3624PinOffset struct {
// The decimalization table to use for IBM 3624 PIN algorithm. The table is used
// to convert the algorithm intermediate result from hexadecimal characters to
// decimal.
//
// This member is required.
DecimalizationTable *string
// The encrypted PIN block data. According to ISO 9564 standard, a PIN Block is an
// encoded representation of a payment card Personal Account Number (PAN) and the
// cardholder Personal Identification Number (PIN).
//
// This member is required.
EncryptedPinBlock *string
// The unique data for cardholder identification.
//
// This member is required.
PinValidationData *string
// The padding character for validation data.
//
// This member is required.
PinValidationDataPadCharacter *string
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Ibm3624 PIN verification PIN.
type Ibm3624PinVerification struct {
// The decimalization table to use for IBM 3624 PIN algorithm. The table is used
// to convert the algorithm intermediate result from hexadecimal characters to
// decimal.
//
// This member is required.
DecimalizationTable *string
// The PIN offset value.
//
// This member is required.
PinOffset *string
// The unique data for cardholder identification.
//
// This member is required.
PinValidationData *string
// The padding character for validation data.
//
// This member is required.
PinValidationDataPadCharacter *string
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Ibm3624 random PIN.
type Ibm3624RandomPin struct {
// The decimalization table to use for IBM 3624 PIN algorithm. The table is used
// to convert the algorithm intermediate result from hexadecimal characters to
// decimal.
//
// This member is required.
DecimalizationTable *string
// The unique data for cardholder identification.
//
// This member is required.
PinValidationData *string
// The padding character for validation data.
//
// This member is required.
PinValidationDataPadCharacter *string
noSmithyDocumentSerde
}
// Parameters required for DUKPT MAC generation and verification.
type MacAlgorithmDukpt struct {
// The type of use of DUKPT, which can be MAC generation, MAC verification, or
// both.
//
// This member is required.
DukptKeyVariant DukptKeyVariant
// The unique identifier known as Key Serial Number (KSN) that comes from an
// encrypting device using DUKPT encryption method. The KSN is derived from the
// encrypting device unique identifier and an internal transaction counter.
//
// This member is required.
KeySerialNumber *string
// The key type derived using DUKPT from a Base Derivation Key (BDK) and Key
// Serial Number (KSN). This must be less than or equal to the strength of the BDK.
// For example, you can't use AES_128 as a derivation type for a BDK of AES_128 or
// TDES_2KEY .
DukptDerivationType DukptDerivationType
noSmithyDocumentSerde
}
// Parameters that are required for EMV MAC generation and verification.
type MacAlgorithmEmv struct {
// The method to use when deriving the master key for EMV MAC generation or
// verification.
//
// This member is required.
MajorKeyDerivationMode MajorKeyDerivationMode
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The Primary Account Number (PAN), a unique identifier for a payment credit or
// debit card and associates the card to a specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
// The method of deriving a session key for EMV MAC generation or verification.
//
// This member is required.
SessionKeyDerivationMode SessionKeyDerivationMode
// Parameters that are required to generate session key for EMV generation and
// verification.
//
// This member is required.
SessionKeyDerivationValue SessionKeyDerivationValue
noSmithyDocumentSerde
}
// Parameters that are required for DUKPT, HMAC, or EMV MAC generation or
// verification.
//
// The following types satisfy this interface:
//
// MacAttributesMemberAlgorithm
// MacAttributesMemberDukptCmac
// MacAttributesMemberDukptIso9797Algorithm1
// MacAttributesMemberDukptIso9797Algorithm3
// MacAttributesMemberEmvMac
type MacAttributes interface {
isMacAttributes()
}
// The encryption algorithm for MAC generation or verification.
type MacAttributesMemberAlgorithm struct {
Value MacAlgorithm
noSmithyDocumentSerde
}
func (*MacAttributesMemberAlgorithm) isMacAttributes() {}
// Parameters that are required for MAC generation or verification using DUKPT
// CMAC algorithm.
type MacAttributesMemberDukptCmac struct {
Value MacAlgorithmDukpt
noSmithyDocumentSerde
}
func (*MacAttributesMemberDukptCmac) isMacAttributes() {}
// Parameters that are required for MAC generation or verification using DUKPT ISO
// 9797 algorithm1.
type MacAttributesMemberDukptIso9797Algorithm1 struct {
Value MacAlgorithmDukpt
noSmithyDocumentSerde
}
func (*MacAttributesMemberDukptIso9797Algorithm1) isMacAttributes() {}
// Parameters that are required for MAC generation or verification using DUKPT ISO
// 9797 algorithm2.
type MacAttributesMemberDukptIso9797Algorithm3 struct {
Value MacAlgorithmDukpt
noSmithyDocumentSerde
}
func (*MacAttributesMemberDukptIso9797Algorithm3) isMacAttributes() {}
// Parameters that are required for MAC generation or verification using EMV MAC
// algorithm.
type MacAttributesMemberEmvMac struct {
Value MacAlgorithmEmv
noSmithyDocumentSerde
}
func (*MacAttributesMemberEmvMac) isMacAttributes() {}
// Parameters that are required to generate, translate, or verify PIN data.
//
// The following types satisfy this interface:
//
// PinDataMemberPinOffset
// PinDataMemberVerificationValue
type PinData interface {
isPinData()
}
// The PIN offset value.
type PinDataMemberPinOffset struct {
Value string
noSmithyDocumentSerde
}
func (*PinDataMemberPinOffset) isPinData() {}
// The unique data to identify a cardholder. In most cases, this is the same as
// cardholder's Primary Account Number (PAN). If a value is not provided, it
// defaults to PAN.
type PinDataMemberVerificationValue struct {
Value string
noSmithyDocumentSerde
}
func (*PinDataMemberVerificationValue) isPinData() {}
// Parameters that are required for PIN data generation.
//
// The following types satisfy this interface:
//
// PinGenerationAttributesMemberIbm3624NaturalPin
// PinGenerationAttributesMemberIbm3624PinFromOffset
// PinGenerationAttributesMemberIbm3624PinOffset
// PinGenerationAttributesMemberIbm3624RandomPin
// PinGenerationAttributesMemberVisaPin
// PinGenerationAttributesMemberVisaPinVerificationValue
type PinGenerationAttributes interface {
isPinGenerationAttributes()
}
// Parameters that are required to generate or verify Ibm3624 natural PIN.
type PinGenerationAttributesMemberIbm3624NaturalPin struct {
Value Ibm3624NaturalPin
noSmithyDocumentSerde
}
func (*PinGenerationAttributesMemberIbm3624NaturalPin) isPinGenerationAttributes() {}
// Parameters that are required to generate or verify Ibm3624 PIN from offset PIN.
type PinGenerationAttributesMemberIbm3624PinFromOffset struct {
Value Ibm3624PinFromOffset
noSmithyDocumentSerde
}
func (*PinGenerationAttributesMemberIbm3624PinFromOffset) isPinGenerationAttributes() {}
// Parameters that are required to generate or verify Ibm3624 PIN offset PIN.
type PinGenerationAttributesMemberIbm3624PinOffset struct {
Value Ibm3624PinOffset
noSmithyDocumentSerde
}
func (*PinGenerationAttributesMemberIbm3624PinOffset) isPinGenerationAttributes() {}
// Parameters that are required to generate or verify Ibm3624 random PIN.
type PinGenerationAttributesMemberIbm3624RandomPin struct {
Value Ibm3624RandomPin
noSmithyDocumentSerde
}
func (*PinGenerationAttributesMemberIbm3624RandomPin) isPinGenerationAttributes() {}
// Parameters that are required to generate or verify Visa PIN.
type PinGenerationAttributesMemberVisaPin struct {
Value VisaPin
noSmithyDocumentSerde
}
func (*PinGenerationAttributesMemberVisaPin) isPinGenerationAttributes() {}
// Parameters that are required to generate or verify Visa PIN Verification Value
// (PVV).
type PinGenerationAttributesMemberVisaPinVerificationValue struct {
Value VisaPinVerificationValue
noSmithyDocumentSerde
}
func (*PinGenerationAttributesMemberVisaPinVerificationValue) isPinGenerationAttributes() {}
// Parameters that are required for PIN data verification.
//
// The following types satisfy this interface:
//
// PinVerificationAttributesMemberIbm3624Pin
// PinVerificationAttributesMemberVisaPin
type PinVerificationAttributes interface {
isPinVerificationAttributes()
}
// Parameters that are required to generate or verify Ibm3624 PIN.
type PinVerificationAttributesMemberIbm3624Pin struct {
Value Ibm3624PinVerification
noSmithyDocumentSerde
}
func (*PinVerificationAttributesMemberIbm3624Pin) isPinVerificationAttributes() {}
// Parameters that are required to generate or verify Visa PIN.
type PinVerificationAttributesMemberVisaPin struct {
Value VisaPinVerification
noSmithyDocumentSerde
}
func (*PinVerificationAttributesMemberVisaPin) isPinVerificationAttributes() {}
// Parameters that are required to perform reencryption operation.
//
// The following types satisfy this interface:
//
// ReEncryptionAttributesMemberDukpt
// ReEncryptionAttributesMemberSymmetric
type ReEncryptionAttributes interface {
isReEncryptionAttributes()
}
// Parameters that are required to encrypt plaintext data using DUKPT.
type ReEncryptionAttributesMemberDukpt struct {
Value DukptEncryptionAttributes
noSmithyDocumentSerde
}
func (*ReEncryptionAttributesMemberDukpt) isReEncryptionAttributes() {}
// Parameters that are required to encrypt data using symmetric keys.
type ReEncryptionAttributesMemberSymmetric struct {
Value SymmetricEncryptionAttributes
noSmithyDocumentSerde
}
func (*ReEncryptionAttributesMemberSymmetric) isReEncryptionAttributes() {}
// Parameters to derive session key for an Amex payment card.
type SessionKeyAmex struct {
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The Primary Account Number (PAN) of the cardholder. A PAN is a unique
// identifier for a payment credit or debit card and associates the card to a
// specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
noSmithyDocumentSerde
}
// Parameters to derive a session key for Authorization Response Cryptogram (ARQC)
// verification.
//
// The following types satisfy this interface:
//
// SessionKeyDerivationMemberAmex
// SessionKeyDerivationMemberEmv2000
// SessionKeyDerivationMemberEmvCommon
// SessionKeyDerivationMemberMastercard
// SessionKeyDerivationMemberVisa
type SessionKeyDerivation interface {
isSessionKeyDerivation()
}
// Parameters to derive session key for an Amex payment card for ARQC verification.
type SessionKeyDerivationMemberAmex struct {
Value SessionKeyAmex
noSmithyDocumentSerde
}
func (*SessionKeyDerivationMemberAmex) isSessionKeyDerivation() {}
// Parameters to derive session key for an Emv2000 payment card for ARQC
// verification.
type SessionKeyDerivationMemberEmv2000 struct {
Value SessionKeyEmv2000
noSmithyDocumentSerde
}
func (*SessionKeyDerivationMemberEmv2000) isSessionKeyDerivation() {}
// Parameters to derive session key for an Emv common payment card for ARQC
// verification.
type SessionKeyDerivationMemberEmvCommon struct {
Value SessionKeyEmvCommon
noSmithyDocumentSerde
}
func (*SessionKeyDerivationMemberEmvCommon) isSessionKeyDerivation() {}
// Parameters to derive session key for a Mastercard payment card for ARQC
// verification.
type SessionKeyDerivationMemberMastercard struct {
Value SessionKeyMastercard
noSmithyDocumentSerde
}
func (*SessionKeyDerivationMemberMastercard) isSessionKeyDerivation() {}
// Parameters to derive session key for a Visa payment cardfor ARQC verification.
type SessionKeyDerivationMemberVisa struct {
Value SessionKeyVisa
noSmithyDocumentSerde
}
func (*SessionKeyDerivationMemberVisa) isSessionKeyDerivation() {}
// Parameters to derive session key value using a MAC EMV algorithm.
//
// The following types satisfy this interface:
//
// SessionKeyDerivationValueMemberApplicationCryptogram
// SessionKeyDerivationValueMemberApplicationTransactionCounter
type SessionKeyDerivationValue interface {
isSessionKeyDerivationValue()
}
// The cryptogram provided by the terminal during transaction processing.
type SessionKeyDerivationValueMemberApplicationCryptogram struct {
Value string
noSmithyDocumentSerde
}
func (*SessionKeyDerivationValueMemberApplicationCryptogram) isSessionKeyDerivationValue() {}
// The transaction counter that is provided by the terminal during transaction
// processing.
type SessionKeyDerivationValueMemberApplicationTransactionCounter struct {
Value string
noSmithyDocumentSerde
}
func (*SessionKeyDerivationValueMemberApplicationTransactionCounter) isSessionKeyDerivationValue() {}
// Parameters to derive session key for an Emv2000 payment card for ARQC
// verification.
type SessionKeyEmv2000 struct {
// The transaction counter that is provided by the terminal during transaction
// processing.
//
// This member is required.
ApplicationTransactionCounter *string
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The Primary Account Number (PAN) of the cardholder. A PAN is a unique
// identifier for a payment credit or debit card and associates the card to a
// specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
noSmithyDocumentSerde
}
// Parameters to derive session key for an Emv common payment card for ARQC
// verification.
type SessionKeyEmvCommon struct {
// The transaction counter that is provided by the terminal during transaction
// processing.
//
// This member is required.
ApplicationTransactionCounter *string
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The Primary Account Number (PAN) of the cardholder. A PAN is a unique
// identifier for a payment credit or debit card and associates the card to a
// specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
noSmithyDocumentSerde
}
// Parameters to derive session key for Mastercard payment card for ARQC
// verification.
type SessionKeyMastercard struct {
// The transaction counter that is provided by the terminal during transaction
// processing.
//
// This member is required.
ApplicationTransactionCounter *string
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The Primary Account Number (PAN) of the cardholder. A PAN is a unique
// identifier for a payment credit or debit card and associates the card to a
// specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
// A random number generated by the issuer.
//
// This member is required.
UnpredictableNumber *string
noSmithyDocumentSerde
}
// Parameters to derive session key for Visa payment card for ARQC verification.
type SessionKeyVisa struct {
// A number that identifies and differentiates payment cards with the same Primary
// Account Number (PAN).
//
// This member is required.
PanSequenceNumber *string
// The Primary Account Number (PAN) of the cardholder. A PAN is a unique
// identifier for a payment credit or debit card and associates the card to a
// specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
noSmithyDocumentSerde
}
// Parameters requried to encrypt plaintext data using symmetric keys.
type SymmetricEncryptionAttributes struct {
// The block cipher mode of operation. Block ciphers are designed to encrypt a
// block of data of fixed size (for example, 128 bits). The size of the input block
// is usually same as the size of the encrypted output block, while the key length
// can be different. A mode of operation describes how to repeatedly apply a
// cipher's single-block operation to securely transform amounts of data larger
// than a block.
//
// This member is required.
Mode EncryptionMode
// An input to cryptographic primitive used to provide the intial state. The
// InitializationVector is typically required have a random or psuedo-random value,
// but sometimes it only needs to be unpredictable or unique. If a value is not
// provided, Amazon Web Services Payment Cryptography generates a random value.
InitializationVector *string
// The padding to be included with the data.
PaddingType PaddingType
noSmithyDocumentSerde
}
// Parameters that are required for translation between ISO9564 PIN block formats
// 0,1,3,4.
//
// The following types satisfy this interface:
//
// TranslationIsoFormatsMemberIsoFormat0
// TranslationIsoFormatsMemberIsoFormat1
// TranslationIsoFormatsMemberIsoFormat3
// TranslationIsoFormatsMemberIsoFormat4
type TranslationIsoFormats interface {
isTranslationIsoFormats()
}
// Parameters that are required for ISO9564 PIN format 0 tranlation.
type TranslationIsoFormatsMemberIsoFormat0 struct {
Value TranslationPinDataIsoFormat034
noSmithyDocumentSerde
}
func (*TranslationIsoFormatsMemberIsoFormat0) isTranslationIsoFormats() {}
// Parameters that are required for ISO9564 PIN format 1 tranlation.
type TranslationIsoFormatsMemberIsoFormat1 struct {
Value TranslationPinDataIsoFormat1
noSmithyDocumentSerde
}
func (*TranslationIsoFormatsMemberIsoFormat1) isTranslationIsoFormats() {}
// Parameters that are required for ISO9564 PIN format 3 tranlation.
type TranslationIsoFormatsMemberIsoFormat3 struct {
Value TranslationPinDataIsoFormat034
noSmithyDocumentSerde
}
func (*TranslationIsoFormatsMemberIsoFormat3) isTranslationIsoFormats() {}
// Parameters that are required for ISO9564 PIN format 4 tranlation.
type TranslationIsoFormatsMemberIsoFormat4 struct {
Value TranslationPinDataIsoFormat034
noSmithyDocumentSerde
}
func (*TranslationIsoFormatsMemberIsoFormat4) isTranslationIsoFormats() {}
// Parameters that are required for tranlation between ISO9564 PIN format 0,3,4
// tranlation.
type TranslationPinDataIsoFormat034 struct {
// The Primary Account Number (PAN) of the cardholder. A PAN is a unique
// identifier for a payment credit or debit card and associates the card to a
// specific account holder.
//
// This member is required.
PrimaryAccountNumber *string
noSmithyDocumentSerde
}
// Parameters that are required for ISO9564 PIN format 1 tranlation.
type TranslationPinDataIsoFormat1 struct {
noSmithyDocumentSerde
}
// The request was denied due to an invalid request error.
type ValidationExceptionField struct {
// The request was denied due to an invalid request error.
//
// This member is required.
Message *string
// The request was denied due to an invalid request error.
//
// This member is required.
Path *string
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Visa PIN.
type VisaPin struct {
// The value for PIN verification index. It is used in the Visa PIN algorithm to
// calculate the PVV (PIN Verification Value).
//
// This member is required.
PinVerificationKeyIndex *int32
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Visa PIN.
type VisaPinVerification struct {
// The value for PIN verification index. It is used in the Visa PIN algorithm to
// calculate the PVV (PIN Verification Value).
//
// This member is required.
PinVerificationKeyIndex *int32
// Parameters that are required to generate or verify Visa PVV (PIN Verification
// Value).
//
// This member is required.
VerificationValue *string
noSmithyDocumentSerde
}
// Parameters that are required to generate or verify Visa PVV (PIN Verification
// Value).
type VisaPinVerificationValue struct {
// The encrypted PIN block data to verify.
//
// This member is required.
EncryptedPinBlock *string
// The value for PIN verification index. It is used in the Visa PIN algorithm to
// calculate the PVV (PIN Verification Value).
//
// This member is required.
PinVerificationKeyIndex *int32
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
// UnknownUnionMember is returned when a union member is returned over the wire,
// but has an unknown tag.
type UnknownUnionMember struct {
Tag string
Value []byte
noSmithyDocumentSerde
}
func (*UnknownUnionMember) isCardGenerationAttributes() {}
func (*UnknownUnionMember) isCardVerificationAttributes() {}
func (*UnknownUnionMember) isCryptogramAuthResponse() {}
func (*UnknownUnionMember) isEncryptionDecryptionAttributes() {}
func (*UnknownUnionMember) isMacAttributes() {}
func (*UnknownUnionMember) isPinData() {}
func (*UnknownUnionMember) isPinGenerationAttributes() {}
func (*UnknownUnionMember) isPinVerificationAttributes() {}
func (*UnknownUnionMember) isReEncryptionAttributes() {}
func (*UnknownUnionMember) isSessionKeyDerivation() {}
func (*UnknownUnionMember) isSessionKeyDerivationValue() {}
func (*UnknownUnionMember) isTranslationIsoFormats() {}
| 1,354 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types_test
import (
"fmt"
"github.com/aws/aws-sdk-go-v2/service/paymentcryptographydata/types"
)
func ExampleCardGenerationAttributes_outputUsage() {
var union types.CardGenerationAttributes
// type switches can be used to check the union value
switch v := union.(type) {
case *types.CardGenerationAttributesMemberAmexCardSecurityCodeVersion1:
_ = v.Value // Value is types.AmexCardSecurityCodeVersion1
case *types.CardGenerationAttributesMemberAmexCardSecurityCodeVersion2:
_ = v.Value // Value is types.AmexCardSecurityCodeVersion2
case *types.CardGenerationAttributesMemberCardHolderVerificationValue:
_ = v.Value // Value is types.CardHolderVerificationValue
case *types.CardGenerationAttributesMemberCardVerificationValue1:
_ = v.Value // Value is types.CardVerificationValue1
case *types.CardGenerationAttributesMemberCardVerificationValue2:
_ = v.Value // Value is types.CardVerificationValue2
case *types.CardGenerationAttributesMemberDynamicCardVerificationCode:
_ = v.Value // Value is types.DynamicCardVerificationCode
case *types.CardGenerationAttributesMemberDynamicCardVerificationValue:
_ = v.Value // Value is types.DynamicCardVerificationValue
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.AmexCardSecurityCodeVersion2
var _ *types.AmexCardSecurityCodeVersion1
var _ *types.CardHolderVerificationValue
var _ *types.DynamicCardVerificationCode
var _ *types.CardVerificationValue2
var _ *types.CardVerificationValue1
var _ *types.DynamicCardVerificationValue
func ExampleCardVerificationAttributes_outputUsage() {
var union types.CardVerificationAttributes
// type switches can be used to check the union value
switch v := union.(type) {
case *types.CardVerificationAttributesMemberAmexCardSecurityCodeVersion1:
_ = v.Value // Value is types.AmexCardSecurityCodeVersion1
case *types.CardVerificationAttributesMemberAmexCardSecurityCodeVersion2:
_ = v.Value // Value is types.AmexCardSecurityCodeVersion2
case *types.CardVerificationAttributesMemberCardHolderVerificationValue:
_ = v.Value // Value is types.CardHolderVerificationValue
case *types.CardVerificationAttributesMemberCardVerificationValue1:
_ = v.Value // Value is types.CardVerificationValue1
case *types.CardVerificationAttributesMemberCardVerificationValue2:
_ = v.Value // Value is types.CardVerificationValue2
case *types.CardVerificationAttributesMemberDiscoverDynamicCardVerificationCode:
_ = v.Value // Value is types.DiscoverDynamicCardVerificationCode
case *types.CardVerificationAttributesMemberDynamicCardVerificationCode:
_ = v.Value // Value is types.DynamicCardVerificationCode
case *types.CardVerificationAttributesMemberDynamicCardVerificationValue:
_ = v.Value // Value is types.DynamicCardVerificationValue
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.AmexCardSecurityCodeVersion2
var _ *types.AmexCardSecurityCodeVersion1
var _ *types.CardHolderVerificationValue
var _ *types.DynamicCardVerificationCode
var _ *types.DiscoverDynamicCardVerificationCode
var _ *types.CardVerificationValue2
var _ *types.CardVerificationValue1
var _ *types.DynamicCardVerificationValue
func ExampleCryptogramAuthResponse_outputUsage() {
var union types.CryptogramAuthResponse
// type switches can be used to check the union value
switch v := union.(type) {
case *types.CryptogramAuthResponseMemberArpcMethod1:
_ = v.Value // Value is types.CryptogramVerificationArpcMethod1
case *types.CryptogramAuthResponseMemberArpcMethod2:
_ = v.Value // Value is types.CryptogramVerificationArpcMethod2
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.CryptogramVerificationArpcMethod2
var _ *types.CryptogramVerificationArpcMethod1
func ExampleEncryptionDecryptionAttributes_outputUsage() {
var union types.EncryptionDecryptionAttributes
// type switches can be used to check the union value
switch v := union.(type) {
case *types.EncryptionDecryptionAttributesMemberAsymmetric:
_ = v.Value // Value is types.AsymmetricEncryptionAttributes
case *types.EncryptionDecryptionAttributesMemberDukpt:
_ = v.Value // Value is types.DukptEncryptionAttributes
case *types.EncryptionDecryptionAttributesMemberSymmetric:
_ = v.Value // Value is types.SymmetricEncryptionAttributes
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.SymmetricEncryptionAttributes
var _ *types.AsymmetricEncryptionAttributes
var _ *types.DukptEncryptionAttributes
func ExampleMacAttributes_outputUsage() {
var union types.MacAttributes
// type switches can be used to check the union value
switch v := union.(type) {
case *types.MacAttributesMemberAlgorithm:
_ = v.Value // Value is types.MacAlgorithm
case *types.MacAttributesMemberDukptCmac:
_ = v.Value // Value is types.MacAlgorithmDukpt
case *types.MacAttributesMemberDukptIso9797Algorithm1:
_ = v.Value // Value is types.MacAlgorithmDukpt
case *types.MacAttributesMemberDukptIso9797Algorithm3:
_ = v.Value // Value is types.MacAlgorithmDukpt
case *types.MacAttributesMemberEmvMac:
_ = v.Value // Value is types.MacAlgorithmEmv
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.MacAlgorithmDukpt
var _ types.MacAlgorithm
var _ *types.MacAlgorithmEmv
func ExamplePinData_outputUsage() {
var union types.PinData
// type switches can be used to check the union value
switch v := union.(type) {
case *types.PinDataMemberPinOffset:
_ = v.Value // Value is string
case *types.PinDataMemberVerificationValue:
_ = v.Value // Value is string
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *string
func ExamplePinGenerationAttributes_outputUsage() {
var union types.PinGenerationAttributes
// type switches can be used to check the union value
switch v := union.(type) {
case *types.PinGenerationAttributesMemberIbm3624NaturalPin:
_ = v.Value // Value is types.Ibm3624NaturalPin
case *types.PinGenerationAttributesMemberIbm3624PinFromOffset:
_ = v.Value // Value is types.Ibm3624PinFromOffset
case *types.PinGenerationAttributesMemberIbm3624PinOffset:
_ = v.Value // Value is types.Ibm3624PinOffset
case *types.PinGenerationAttributesMemberIbm3624RandomPin:
_ = v.Value // Value is types.Ibm3624RandomPin
case *types.PinGenerationAttributesMemberVisaPin:
_ = v.Value // Value is types.VisaPin
case *types.PinGenerationAttributesMemberVisaPinVerificationValue:
_ = v.Value // Value is types.VisaPinVerificationValue
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.Ibm3624RandomPin
var _ *types.Ibm3624PinOffset
var _ *types.VisaPinVerificationValue
var _ *types.VisaPin
var _ *types.Ibm3624NaturalPin
var _ *types.Ibm3624PinFromOffset
func ExamplePinVerificationAttributes_outputUsage() {
var union types.PinVerificationAttributes
// type switches can be used to check the union value
switch v := union.(type) {
case *types.PinVerificationAttributesMemberIbm3624Pin:
_ = v.Value // Value is types.Ibm3624PinVerification
case *types.PinVerificationAttributesMemberVisaPin:
_ = v.Value // Value is types.VisaPinVerification
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.Ibm3624PinVerification
var _ *types.VisaPinVerification
func ExampleReEncryptionAttributes_outputUsage() {
var union types.ReEncryptionAttributes
// type switches can be used to check the union value
switch v := union.(type) {
case *types.ReEncryptionAttributesMemberDukpt:
_ = v.Value // Value is types.DukptEncryptionAttributes
case *types.ReEncryptionAttributesMemberSymmetric:
_ = v.Value // Value is types.SymmetricEncryptionAttributes
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.SymmetricEncryptionAttributes
var _ *types.DukptEncryptionAttributes
func ExampleSessionKeyDerivation_outputUsage() {
var union types.SessionKeyDerivation
// type switches can be used to check the union value
switch v := union.(type) {
case *types.SessionKeyDerivationMemberAmex:
_ = v.Value // Value is types.SessionKeyAmex
case *types.SessionKeyDerivationMemberEmv2000:
_ = v.Value // Value is types.SessionKeyEmv2000
case *types.SessionKeyDerivationMemberEmvCommon:
_ = v.Value // Value is types.SessionKeyEmvCommon
case *types.SessionKeyDerivationMemberMastercard:
_ = v.Value // Value is types.SessionKeyMastercard
case *types.SessionKeyDerivationMemberVisa:
_ = v.Value // Value is types.SessionKeyVisa
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.SessionKeyVisa
var _ *types.SessionKeyEmvCommon
var _ *types.SessionKeyEmv2000
var _ *types.SessionKeyAmex
var _ *types.SessionKeyMastercard
func ExampleSessionKeyDerivationValue_outputUsage() {
var union types.SessionKeyDerivationValue
// type switches can be used to check the union value
switch v := union.(type) {
case *types.SessionKeyDerivationValueMemberApplicationCryptogram:
_ = v.Value // Value is string
case *types.SessionKeyDerivationValueMemberApplicationTransactionCounter:
_ = v.Value // Value is string
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *string
var _ *string
func ExampleTranslationIsoFormats_outputUsage() {
var union types.TranslationIsoFormats
// type switches can be used to check the union value
switch v := union.(type) {
case *types.TranslationIsoFormatsMemberIsoFormat0:
_ = v.Value // Value is types.TranslationPinDataIsoFormat034
case *types.TranslationIsoFormatsMemberIsoFormat1:
_ = v.Value // Value is types.TranslationPinDataIsoFormat1
case *types.TranslationIsoFormatsMemberIsoFormat3:
_ = v.Value // Value is types.TranslationPinDataIsoFormat034
case *types.TranslationIsoFormatsMemberIsoFormat4:
_ = v.Value // Value is types.TranslationPinDataIsoFormat034
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.TranslationPinDataIsoFormat1
var _ *types.TranslationPinDataIsoFormat034
| 364 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "Personalize"
const ServiceAPIVersion = "2018-05-22"
// Client provides the API client to make operations call for Amazon Personalize.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "personalize", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 434 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a batch inference job. The operation can handle up to 50 million
// records and the input file must be in JSON format. For more information, see
// Creating a batch inference job (https://docs.aws.amazon.com/personalize/latest/dg/creating-batch-inference-job.html)
// .
func (c *Client) CreateBatchInferenceJob(ctx context.Context, params *CreateBatchInferenceJobInput, optFns ...func(*Options)) (*CreateBatchInferenceJobOutput, error) {
if params == nil {
params = &CreateBatchInferenceJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateBatchInferenceJob", params, optFns, c.addOperationCreateBatchInferenceJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateBatchInferenceJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateBatchInferenceJobInput struct {
// The Amazon S3 path that leads to the input file to base your recommendations
// on. The input material must be in JSON format.
//
// This member is required.
JobInput *types.BatchInferenceJobInput
// The name of the batch inference job to create.
//
// This member is required.
JobName *string
// The path to the Amazon S3 bucket where the job's output will be stored.
//
// This member is required.
JobOutput *types.BatchInferenceJobOutput
// The ARN of the Amazon Identity and Access Management role that has permissions
// to read and write to your input and output Amazon S3 buckets respectively.
//
// This member is required.
RoleArn *string
// The Amazon Resource Name (ARN) of the solution version that will be used to
// generate the batch inference recommendations.
//
// This member is required.
SolutionVersionArn *string
// The configuration details of a batch inference job.
BatchInferenceJobConfig *types.BatchInferenceJobConfig
// The ARN of the filter to apply to the batch inference job. For more information
// on using filters, see Filtering batch recommendations (https://docs.aws.amazon.com/personalize/latest/dg/filter-batch.html)
// .
FilterArn *string
// The number of recommendations to retrieve.
NumResults *int32
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the batch inference job.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateBatchInferenceJobOutput struct {
// The ARN of the batch inference job.
BatchInferenceJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateBatchInferenceJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateBatchInferenceJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateBatchInferenceJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateBatchInferenceJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateBatchInferenceJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateBatchInferenceJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateBatchInferenceJob",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a batch segment job. The operation can handle up to 50 million records
// and the input file must be in JSON format. For more information, see Getting
// batch recommendations and user segments (https://docs.aws.amazon.com/personalize/latest/dg/recommendations-batch.html)
// .
func (c *Client) CreateBatchSegmentJob(ctx context.Context, params *CreateBatchSegmentJobInput, optFns ...func(*Options)) (*CreateBatchSegmentJobOutput, error) {
if params == nil {
params = &CreateBatchSegmentJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateBatchSegmentJob", params, optFns, c.addOperationCreateBatchSegmentJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateBatchSegmentJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateBatchSegmentJobInput struct {
// The Amazon S3 path for the input data used to generate the batch segment job.
//
// This member is required.
JobInput *types.BatchSegmentJobInput
// The name of the batch segment job to create.
//
// This member is required.
JobName *string
// The Amazon S3 path for the bucket where the job's output will be stored.
//
// This member is required.
JobOutput *types.BatchSegmentJobOutput
// The ARN of the Amazon Identity and Access Management role that has permissions
// to read and write to your input and output Amazon S3 buckets respectively.
//
// This member is required.
RoleArn *string
// The Amazon Resource Name (ARN) of the solution version you want the batch
// segment job to use to generate batch segments.
//
// This member is required.
SolutionVersionArn *string
// The ARN of the filter to apply to the batch segment job. For more information
// on using filters, see Filtering batch recommendations (https://docs.aws.amazon.com/personalize/latest/dg/filter-batch.html)
// .
FilterArn *string
// The number of predicted users generated by the batch segment job for each line
// of input data. The maximum number of users per segment is 5 million.
NumResults *int32
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the batch segment job.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateBatchSegmentJobOutput struct {
// The ARN of the batch segment job.
BatchSegmentJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateBatchSegmentJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateBatchSegmentJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateBatchSegmentJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateBatchSegmentJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateBatchSegmentJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateBatchSegmentJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateBatchSegmentJob",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a campaign that deploys a solution version. When a client calls the
// GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html)
// and GetPersonalizedRanking (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetPersonalizedRanking.html)
// APIs, a campaign is specified in the request. Minimum Provisioned TPS and
// Auto-Scaling A high minProvisionedTPS will increase your bill. We recommend
// starting with 1 for minProvisionedTPS (the default). Track your usage using
// Amazon CloudWatch metrics, and increase the minProvisionedTPS as necessary. A
// transaction is a single GetRecommendations or GetPersonalizedRanking call.
// Transactions per second (TPS) is the throughput and unit of billing for Amazon
// Personalize. The minimum provisioned TPS ( minProvisionedTPS ) specifies the
// baseline throughput provisioned by Amazon Personalize, and thus, the minimum
// billing charge. If your TPS increases beyond minProvisionedTPS , Amazon
// Personalize auto-scales the provisioned capacity up and down, but never below
// minProvisionedTPS . There's a short time delay while the capacity is increased
// that might cause loss of transactions. The actual TPS used is calculated as the
// average requests/second within a 5-minute window. You pay for maximum of either
// the minimum provisioned TPS or the actual TPS. We recommend starting with a low
// minProvisionedTPS , track your usage using Amazon CloudWatch metrics, and then
// increase the minProvisionedTPS as necessary. Status A campaign can be in one of
// the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - DELETE PENDING > DELETE IN_PROGRESS
//
// To get the campaign status, call DescribeCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeCampaign.html)
// . Wait until the status of the campaign is ACTIVE before asking the campaign
// for recommendations. Related APIs
// - ListCampaigns (https://docs.aws.amazon.com/personalize/latest/dg/API_ListCampaigns.html)
// - DescribeCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeCampaign.html)
// - UpdateCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_UpdateCampaign.html)
// - DeleteCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteCampaign.html)
func (c *Client) CreateCampaign(ctx context.Context, params *CreateCampaignInput, optFns ...func(*Options)) (*CreateCampaignOutput, error) {
if params == nil {
params = &CreateCampaignInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateCampaign", params, optFns, c.addOperationCreateCampaignMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateCampaignOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateCampaignInput struct {
// A name for the new campaign. The campaign name must be unique within your
// account.
//
// This member is required.
Name *string
// The Amazon Resource Name (ARN) of the solution version to deploy.
//
// This member is required.
SolutionVersionArn *string
// The configuration details of a campaign.
CampaignConfig *types.CampaignConfig
// Specifies the requested minimum provisioned transactions (recommendations) per
// second that Amazon Personalize will support. A high minProvisionedTPS will
// increase your bill. We recommend starting with 1 for minProvisionedTPS (the
// default). Track your usage using Amazon CloudWatch metrics, and increase the
// minProvisionedTPS as necessary.
MinProvisionedTPS *int32
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the campaign.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateCampaignOutput struct {
// The Amazon Resource Name (ARN) of the campaign.
CampaignArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateCampaignMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateCampaign{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateCampaign{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateCampaignValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateCampaign(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateCampaign(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateCampaign",
}
}
| 174 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an empty dataset and adds it to the specified dataset group. Use
// CreateDatasetImportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetImportJob.html)
// to import your training data to a dataset. There are three types of datasets:
// - Interactions
// - Items
// - Users
//
// Each dataset type has an associated schema with required field types. Only the
// Interactions dataset is required in order to train a model (also referred to as
// creating a solution). A dataset can be in one of the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - DELETE PENDING > DELETE IN_PROGRESS
//
// To get the status of the dataset, call DescribeDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDataset.html)
// . Related APIs
// - CreateDatasetGroup (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetGroup.html)
// - ListDatasets (https://docs.aws.amazon.com/personalize/latest/dg/API_ListDatasets.html)
// - DescribeDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDataset.html)
// - DeleteDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteDataset.html)
func (c *Client) CreateDataset(ctx context.Context, params *CreateDatasetInput, optFns ...func(*Options)) (*CreateDatasetOutput, error) {
if params == nil {
params = &CreateDatasetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDataset", params, optFns, c.addOperationCreateDatasetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetInput struct {
// The Amazon Resource Name (ARN) of the dataset group to add the dataset to.
//
// This member is required.
DatasetGroupArn *string
// The type of dataset. One of the following (case insensitive) values:
// - Interactions
// - Items
// - Users
//
// This member is required.
DatasetType *string
// The name for the dataset.
//
// This member is required.
Name *string
// The ARN of the schema to associate with the dataset. The schema defines the
// dataset fields.
//
// This member is required.
SchemaArn *string
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the dataset.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDatasetOutput struct {
// The ARN of the dataset.
DatasetArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDataset{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDataset{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDatasetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDataset(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDataset(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateDataset",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a job that exports data from your dataset to an Amazon S3 bucket. To
// allow Amazon Personalize to export the training data, you must specify an
// service-linked IAM role that gives Amazon Personalize PutObject permissions for
// your Amazon S3 bucket. For information, see Exporting a dataset (https://docs.aws.amazon.com/personalize/latest/dg/export-data.html)
// in the Amazon Personalize developer guide. Status A dataset export job can be in
// one of the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
//
// To get the status of the export job, call DescribeDatasetExportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDatasetExportJob.html)
// , and specify the Amazon Resource Name (ARN) of the dataset export job. The
// dataset export is complete when the status shows as ACTIVE. If the status shows
// as CREATE FAILED, the response includes a failureReason key, which describes
// why the job failed.
func (c *Client) CreateDatasetExportJob(ctx context.Context, params *CreateDatasetExportJobInput, optFns ...func(*Options)) (*CreateDatasetExportJobOutput, error) {
if params == nil {
params = &CreateDatasetExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDatasetExportJob", params, optFns, c.addOperationCreateDatasetExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetExportJobInput struct {
// The Amazon Resource Name (ARN) of the dataset that contains the data to export.
//
// This member is required.
DatasetArn *string
// The name for the dataset export job.
//
// This member is required.
JobName *string
// The path to the Amazon S3 bucket where the job's output is stored.
//
// This member is required.
JobOutput *types.DatasetExportJobOutput
// The Amazon Resource Name (ARN) of the IAM service role that has permissions to
// add data to your output Amazon S3 bucket.
//
// This member is required.
RoleArn *string
// The data to export, based on how you imported the data. You can choose to
// export only BULK data that you imported using a dataset import job, only PUT
// data that you imported incrementally (using the console, PutEvents, PutUsers and
// PutItems operations), or ALL for both types. The default value is PUT .
IngestionMode types.IngestionMode
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the dataset export job.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDatasetExportJobOutput struct {
// The Amazon Resource Name (ARN) of the dataset export job.
DatasetExportJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDatasetExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDatasetExportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDatasetExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDatasetExportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDatasetExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateDatasetExportJob",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an empty dataset group. A dataset group is a container for Amazon
// Personalize resources. A dataset group can contain at most three datasets, one
// for each type of dataset:
// - Interactions
// - Items
// - Users
//
// A dataset group can be a Domain dataset group, where you specify a domain and
// use pre-configured resources like recommenders, or a Custom dataset group, where
// you use custom resources, such as a solution with a solution version, that you
// deploy with a campaign. If you start with a Domain dataset group, you can still
// add custom resources such as solutions and solution versions trained with
// recipes for custom use cases and deployed with campaigns. A dataset group can be
// in one of the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - DELETE PENDING
//
// To get the status of the dataset group, call DescribeDatasetGroup (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDatasetGroup.html)
// . If the status shows as CREATE FAILED, the response includes a failureReason
// key, which describes why the creation failed. You must wait until the status of
// the dataset group is ACTIVE before adding a dataset to the group. You can
// specify an Key Management Service (KMS) key to encrypt the datasets in the
// group. If you specify a KMS key, you must also include an Identity and Access
// Management (IAM) role that has permission to access the key. APIs that require a
// dataset group ARN in the request
// - CreateDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html)
// - CreateEventTracker (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateEventTracker.html)
// - CreateSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html)
//
// Related APIs
// - ListDatasetGroups (https://docs.aws.amazon.com/personalize/latest/dg/API_ListDatasetGroups.html)
// - DescribeDatasetGroup (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDatasetGroup.html)
// - DeleteDatasetGroup (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteDatasetGroup.html)
func (c *Client) CreateDatasetGroup(ctx context.Context, params *CreateDatasetGroupInput, optFns ...func(*Options)) (*CreateDatasetGroupOutput, error) {
if params == nil {
params = &CreateDatasetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDatasetGroup", params, optFns, c.addOperationCreateDatasetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetGroupInput struct {
// The name for the new dataset group.
//
// This member is required.
Name *string
// The domain of the dataset group. Specify a domain to create a Domain dataset
// group. The domain you specify determines the default schemas for datasets and
// the use cases available for recommenders. If you don't specify a domain, you
// create a Custom dataset group with solution versions that you deploy with a
// campaign.
Domain types.Domain
// The Amazon Resource Name (ARN) of a Key Management Service (KMS) key used to
// encrypt the datasets.
KmsKeyArn *string
// The ARN of the Identity and Access Management (IAM) role that has permissions
// to access the Key Management Service (KMS) key. Supplying an IAM role is only
// valid when also specifying a KMS key.
RoleArn *string
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the dataset group.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDatasetGroupOutput struct {
// The Amazon Resource Name (ARN) of the new dataset group.
DatasetGroupArn *string
// The domain for the new Domain dataset group.
Domain types.Domain
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDatasetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDatasetGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDatasetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDatasetGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDatasetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateDatasetGroup",
}
}
| 180 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a job that imports training data from your data source (an Amazon S3
// bucket) to an Amazon Personalize dataset. To allow Amazon Personalize to import
// the training data, you must specify an IAM service role that has permission to
// read from the data source, as Amazon Personalize makes a copy of your data and
// processes it internally. For information on granting access to your Amazon S3
// bucket, see Giving Amazon Personalize Access to Amazon S3 Resources (https://docs.aws.amazon.com/personalize/latest/dg/granting-personalize-s3-access.html)
// . By default, a dataset import job replaces any existing data in the dataset
// that you imported in bulk. To add new records without replacing existing data,
// specify INCREMENTAL for the import mode in the CreateDatasetImportJob operation.
// Status A dataset import job can be in one of the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
//
// To get the status of the import job, call DescribeDatasetImportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDatasetImportJob.html)
// , providing the Amazon Resource Name (ARN) of the dataset import job. The
// dataset import is complete when the status shows as ACTIVE. If the status shows
// as CREATE FAILED, the response includes a failureReason key, which describes
// why the job failed. Importing takes time. You must wait until the status shows
// as ACTIVE before training a model using the dataset. Related APIs
// - ListDatasetImportJobs (https://docs.aws.amazon.com/personalize/latest/dg/API_ListDatasetImportJobs.html)
// - DescribeDatasetImportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDatasetImportJob.html)
func (c *Client) CreateDatasetImportJob(ctx context.Context, params *CreateDatasetImportJobInput, optFns ...func(*Options)) (*CreateDatasetImportJobOutput, error) {
if params == nil {
params = &CreateDatasetImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDatasetImportJob", params, optFns, c.addOperationCreateDatasetImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetImportJobInput struct {
// The Amazon S3 bucket that contains the training data to import.
//
// This member is required.
DataSource *types.DataSource
// The ARN of the dataset that receives the imported data.
//
// This member is required.
DatasetArn *string
// The name for the dataset import job.
//
// This member is required.
JobName *string
// The ARN of the IAM role that has permissions to read from the Amazon S3 data
// source.
//
// This member is required.
RoleArn *string
// Specify how to add the new records to an existing dataset. The default import
// mode is FULL . If you haven't imported bulk records into the dataset previously,
// you can only specify FULL .
// - Specify FULL to overwrite all existing bulk data in your dataset. Data you
// imported individually is not replaced.
// - Specify INCREMENTAL to append the new records to the existing data in your
// dataset. Amazon Personalize replaces any record with the same ID with the new
// one.
ImportMode types.ImportMode
// If you created a metric attribution, specify whether to publish metrics for
// this import job to Amazon S3
PublishAttributionMetricsToS3 *bool
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the dataset import job.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDatasetImportJobOutput struct {
// The ARN of the dataset import job.
DatasetImportJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDatasetImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDatasetImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDatasetImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDatasetImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateDatasetImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateDatasetImportJob",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an event tracker that you use when adding event data to a specified
// dataset group using the PutEvents (https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html)
// API. Only one event tracker can be associated with a dataset group. You will get
// an error if you call CreateEventTracker using the same dataset group as an
// existing event tracker. When you create an event tracker, the response includes
// a tracking ID, which you pass as a parameter when you use the PutEvents (https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html)
// operation. Amazon Personalize then appends the event data to the Interactions
// dataset of the dataset group you specify in your event tracker. The event
// tracker can be in one of the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - DELETE PENDING > DELETE IN_PROGRESS
//
// To get the status of the event tracker, call DescribeEventTracker (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeEventTracker.html)
// . The event tracker must be in the ACTIVE state before using the tracking ID.
// Related APIs
// - ListEventTrackers (https://docs.aws.amazon.com/personalize/latest/dg/API_ListEventTrackers.html)
// - DescribeEventTracker (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeEventTracker.html)
// - DeleteEventTracker (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteEventTracker.html)
func (c *Client) CreateEventTracker(ctx context.Context, params *CreateEventTrackerInput, optFns ...func(*Options)) (*CreateEventTrackerOutput, error) {
if params == nil {
params = &CreateEventTrackerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateEventTracker", params, optFns, c.addOperationCreateEventTrackerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateEventTrackerOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateEventTrackerInput struct {
// The Amazon Resource Name (ARN) of the dataset group that receives the event
// data.
//
// This member is required.
DatasetGroupArn *string
// The name for the event tracker.
//
// This member is required.
Name *string
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the event tracker.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateEventTrackerOutput struct {
// The ARN of the event tracker.
EventTrackerArn *string
// The ID of the event tracker. Include this ID in requests to the PutEvents (https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html)
// API.
TrackingId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateEventTrackerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateEventTracker{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateEventTracker{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateEventTrackerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateEventTracker(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateEventTracker(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateEventTracker",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a recommendation filter. For more information, see Filtering
// recommendations and user segments (https://docs.aws.amazon.com/personalize/latest/dg/filter.html)
// .
func (c *Client) CreateFilter(ctx context.Context, params *CreateFilterInput, optFns ...func(*Options)) (*CreateFilterOutput, error) {
if params == nil {
params = &CreateFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFilter", params, optFns, c.addOperationCreateFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFilterInput struct {
// The ARN of the dataset group that the filter will belong to.
//
// This member is required.
DatasetGroupArn *string
// The filter expression defines which items are included or excluded from
// recommendations. Filter expression must follow specific format rules. For
// information about filter expression structure and syntax, see Filter expressions (https://docs.aws.amazon.com/personalize/latest/dg/filter-expressions.html)
// .
//
// This member is required.
FilterExpression *string
// The name of the filter to create.
//
// This member is required.
Name *string
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the filter.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateFilterOutput struct {
// The ARN of the new filter.
FilterArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateFilter",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a metric attribution. A metric attribution creates reports on the data
// that you import into Amazon Personalize. Depending on how you imported the data,
// you can view reports in Amazon CloudWatch or Amazon S3. For more information,
// see Measuring impact of recommendations (https://docs.aws.amazon.com/personalize/latest/dg/measuring-recommendation-impact.html)
// .
func (c *Client) CreateMetricAttribution(ctx context.Context, params *CreateMetricAttributionInput, optFns ...func(*Options)) (*CreateMetricAttributionOutput, error) {
if params == nil {
params = &CreateMetricAttributionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateMetricAttribution", params, optFns, c.addOperationCreateMetricAttributionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateMetricAttributionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateMetricAttributionInput struct {
// The Amazon Resource Name (ARN) of the destination dataset group for the metric
// attribution.
//
// This member is required.
DatasetGroupArn *string
// A list of metric attributes for the metric attribution. Each metric attribute
// specifies an event type to track and a function. Available functions are SUM()
// or SAMPLECOUNT() . For SUM() functions, provide the dataset type (either
// Interactions or Items) and column to sum as a parameter. For example
// SUM(Items.PRICE).
//
// This member is required.
Metrics []types.MetricAttribute
// The output configuration details for the metric attribution.
//
// This member is required.
MetricsOutputConfig *types.MetricAttributionOutput
// A name for the metric attribution.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
type CreateMetricAttributionOutput struct {
// The Amazon Resource Name (ARN) for the new metric attribution.
MetricAttributionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateMetricAttributionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateMetricAttribution{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateMetricAttribution{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateMetricAttributionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateMetricAttribution(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateMetricAttribution(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateMetricAttribution",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a recommender with the recipe (a Domain dataset group use case) you
// specify. You create recommenders for a Domain dataset group and specify the
// recommender's Amazon Resource Name (ARN) when you make a GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html)
// request. Minimum recommendation requests per second A high
// minRecommendationRequestsPerSecond will increase your bill. We recommend
// starting with 1 for minRecommendationRequestsPerSecond (the default). Track
// your usage using Amazon CloudWatch metrics, and increase the
// minRecommendationRequestsPerSecond as necessary. When you create a recommender,
// you can configure the recommender's minimum recommendation requests per second.
// The minimum recommendation requests per second (
// minRecommendationRequestsPerSecond ) specifies the baseline recommendation
// request throughput provisioned by Amazon Personalize. The default
// minRecommendationRequestsPerSecond is 1 . A recommendation request is a single
// GetRecommendations operation. Request throughput is measured in requests per
// second and Amazon Personalize uses your requests per second to derive your
// requests per hour and the price of your recommender usage. If your requests per
// second increases beyond minRecommendationRequestsPerSecond , Amazon Personalize
// auto-scales the provisioned capacity up and down, but never below
// minRecommendationRequestsPerSecond . There's a short time delay while the
// capacity is increased that might cause loss of requests. Your bill is the
// greater of either the minimum requests per hour (based on
// minRecommendationRequestsPerSecond) or the actual number of requests. The actual
// request throughput used is calculated as the average requests/second within a
// one-hour window. We recommend starting with the default
// minRecommendationRequestsPerSecond , track your usage using Amazon CloudWatch
// metrics, and then increase the minRecommendationRequestsPerSecond as necessary.
// Status A recommender can be in one of the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - STOP PENDING > STOP IN_PROGRESS > INACTIVE > START PENDING > START
// IN_PROGRESS > ACTIVE
// - DELETE PENDING > DELETE IN_PROGRESS
//
// To get the recommender status, call DescribeRecommender (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeRecommender.html)
// . Wait until the status of the recommender is ACTIVE before asking the
// recommender for recommendations. Related APIs
// - ListRecommenders (https://docs.aws.amazon.com/personalize/latest/dg/API_ListRecommenders.html)
// - DescribeRecommender (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeRecommender.html)
// - UpdateRecommender (https://docs.aws.amazon.com/personalize/latest/dg/API_UpdateRecommender.html)
// - DeleteRecommender (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteRecommender.html)
func (c *Client) CreateRecommender(ctx context.Context, params *CreateRecommenderInput, optFns ...func(*Options)) (*CreateRecommenderOutput, error) {
if params == nil {
params = &CreateRecommenderInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateRecommender", params, optFns, c.addOperationCreateRecommenderMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateRecommenderOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateRecommenderInput struct {
// The Amazon Resource Name (ARN) of the destination domain dataset group for the
// recommender.
//
// This member is required.
DatasetGroupArn *string
// The name of the recommender.
//
// This member is required.
Name *string
// The Amazon Resource Name (ARN) of the recipe that the recommender will use. For
// a recommender, a recipe is a Domain dataset group use case. Only Domain dataset
// group use cases can be used to create a recommender. For information about use
// cases see Choosing recommender use cases (https://docs.aws.amazon.com/personalize/latest/dg/domain-use-cases.html)
// .
//
// This member is required.
RecipeArn *string
// The configuration details of the recommender.
RecommenderConfig *types.RecommenderConfig
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the recommender.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateRecommenderOutput struct {
// The Amazon Resource Name (ARN) of the recommender.
RecommenderArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateRecommenderMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateRecommender{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateRecommender{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateRecommenderValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateRecommender(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateRecommender(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateRecommender",
}
}
| 185 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Amazon Personalize schema from the specified schema string. The
// schema you create must be in Avro JSON format. Amazon Personalize recognizes
// three schema variants. Each schema is associated with a dataset type and has a
// set of required field and keywords. If you are creating a schema for a dataset
// in a Domain dataset group, you provide the domain of the Domain dataset group.
// You specify a schema when you call CreateDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html)
// . Related APIs
// - ListSchemas (https://docs.aws.amazon.com/personalize/latest/dg/API_ListSchemas.html)
// - DescribeSchema (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeSchema.html)
// - DeleteSchema (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteSchema.html)
func (c *Client) CreateSchema(ctx context.Context, params *CreateSchemaInput, optFns ...func(*Options)) (*CreateSchemaOutput, error) {
if params == nil {
params = &CreateSchemaInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSchema", params, optFns, c.addOperationCreateSchemaMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSchemaOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSchemaInput struct {
// The name for the schema.
//
// This member is required.
Name *string
// A schema in Avro JSON format.
//
// This member is required.
Schema *string
// The domain for the schema. If you are creating a schema for a dataset in a
// Domain dataset group, specify the domain you chose when you created the Domain
// dataset group.
Domain types.Domain
noSmithyDocumentSerde
}
type CreateSchemaOutput struct {
// The Amazon Resource Name (ARN) of the created schema.
SchemaArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSchemaMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSchema{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSchema{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateSchemaValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSchema(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateSchema(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateSchema",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates the configuration for training a model. A trained model is known as a
// solution version. After the configuration is created, you train the model
// (create a solution version) by calling the CreateSolutionVersion (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolutionVersion.html)
// operation. Every time you call CreateSolutionVersion , a new version of the
// solution is created. After creating a solution version, you check its accuracy
// by calling GetSolutionMetrics (https://docs.aws.amazon.com/personalize/latest/dg/API_GetSolutionMetrics.html)
// . When you are satisfied with the version, you deploy it using CreateCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateCampaign.html)
// . The campaign provides recommendations to a client through the
// GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html)
// API. To train a model, Amazon Personalize requires training data and a recipe.
// The training data comes from the dataset group that you provide in the request.
// A recipe specifies the training algorithm and a feature transformation. You can
// specify one of the predefined recipes provided by Amazon Personalize. Amazon
// Personalize doesn't support configuring the hpoObjective for solution
// hyperparameter optimization at this time. Status A solution can be in one of the
// following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - DELETE PENDING > DELETE IN_PROGRESS
//
// To get the status of the solution, call DescribeSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeSolution.html)
// . Wait until the status shows as ACTIVE before calling CreateSolutionVersion .
// Related APIs
//
// - ListSolutions (https://docs.aws.amazon.com/personalize/latest/dg/API_ListSolutions.html)
//
// - CreateSolutionVersion (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolutionVersion.html)
//
// - DescribeSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeSolution.html)
//
// - DeleteSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteSolution.html)
//
// - ListSolutionVersions (https://docs.aws.amazon.com/personalize/latest/dg/API_ListSolutionVersions.html)
//
// - DescribeSolutionVersion (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeSolutionVersion.html)
func (c *Client) CreateSolution(ctx context.Context, params *CreateSolutionInput, optFns ...func(*Options)) (*CreateSolutionOutput, error) {
if params == nil {
params = &CreateSolutionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSolution", params, optFns, c.addOperationCreateSolutionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSolutionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSolutionInput struct {
// The Amazon Resource Name (ARN) of the dataset group that provides the training
// data.
//
// This member is required.
DatasetGroupArn *string
// The name for the solution.
//
// This member is required.
Name *string
// When your have multiple event types (using an EVENT_TYPE schema field), this
// parameter specifies which event type (for example, 'click' or 'like') is used
// for training the model. If you do not provide an eventType , Amazon Personalize
// will use all interactions for training with equal weight regardless of type.
EventType *string
// We don't recommend enabling automated machine learning. Instead, match your use
// case to the available Amazon Personalize recipes. For more information, see
// Determining your use case. (https://docs.aws.amazon.com/personalize/latest/dg/determining-use-case.html)
// Whether to perform automated machine learning (AutoML). The default is false .
// For this case, you must specify recipeArn . When set to true , Amazon
// Personalize analyzes your training data and selects the optimal
// USER_PERSONALIZATION recipe and hyperparameters. In this case, you must omit
// recipeArn . Amazon Personalize determines the optimal recipe by running tests
// with different values for the hyperparameters. AutoML lengthens the training
// process as compared to selecting a specific recipe.
PerformAutoML bool
// Whether to perform hyperparameter optimization (HPO) on the specified or
// selected recipe. The default is false . When performing AutoML, this parameter
// is always true and you should not set it to false .
PerformHPO *bool
// The ARN of the recipe to use for model training. Only specified when
// performAutoML is false.
RecipeArn *string
// The configuration to use with the solution. When performAutoML is set to true,
// Amazon Personalize only evaluates the autoMLConfig section of the solution
// configuration. Amazon Personalize doesn't support configuring the hpoObjective
// at this time.
SolutionConfig *types.SolutionConfig
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the solution.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateSolutionOutput struct {
// The ARN of the solution.
SolutionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSolutionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSolution{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSolution{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateSolutionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSolution(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateSolution(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateSolution",
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Trains or retrains an active solution in a Custom dataset group. A solution is
// created using the CreateSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html)
// operation and must be in the ACTIVE state before calling CreateSolutionVersion .
// A new version of the solution is created every time you call this operation.
// Status A solution version can be in one of the following states:
// - CREATE PENDING
// - CREATE IN_PROGRESS
// - ACTIVE
// - CREATE FAILED
// - CREATE STOPPING
// - CREATE STOPPED
//
// To get the status of the version, call DescribeSolutionVersion (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeSolutionVersion.html)
// . Wait until the status shows as ACTIVE before calling CreateCampaign . If the
// status shows as CREATE FAILED, the response includes a failureReason key, which
// describes why the job failed. Related APIs
// - ListSolutionVersions (https://docs.aws.amazon.com/personalize/latest/dg/API_ListSolutionVersions.html)
// - DescribeSolutionVersion (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeSolutionVersion.html)
// - ListSolutions (https://docs.aws.amazon.com/personalize/latest/dg/API_ListSolutions.html)
// - CreateSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html)
// - DescribeSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeSolution.html)
// - DeleteSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteSolution.html)
func (c *Client) CreateSolutionVersion(ctx context.Context, params *CreateSolutionVersionInput, optFns ...func(*Options)) (*CreateSolutionVersionOutput, error) {
if params == nil {
params = &CreateSolutionVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSolutionVersion", params, optFns, c.addOperationCreateSolutionVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSolutionVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSolutionVersionInput struct {
// The Amazon Resource Name (ARN) of the solution containing the training
// configuration information.
//
// This member is required.
SolutionArn *string
// The name of the solution version.
Name *string
// A list of tags (https://docs.aws.amazon.com/personalize/latest/dg/tagging-resources.html)
// to apply to the solution version.
Tags []types.Tag
// The scope of training to be performed when creating the solution version. The
// FULL option trains the solution version based on the entirety of the input
// solution's training data, while the UPDATE option processes only the data that
// has changed in comparison to the input solution. Choose UPDATE when you want to
// incrementally update your solution version instead of creating an entirely new
// one. The UPDATE option can only be used when you already have an active
// solution version created from the input solution using the FULL option and the
// input solution was trained with the User-Personalization (https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-new-item-USER_PERSONALIZATION.html)
// recipe or the HRNN-Coldstart (https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-hrnn-coldstart.html)
// recipe.
TrainingMode types.TrainingMode
noSmithyDocumentSerde
}
type CreateSolutionVersionOutput struct {
// The ARN of the new solution version.
SolutionVersionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSolutionVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSolutionVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSolutionVersion{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateSolutionVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSolutionVersion(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateSolutionVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "CreateSolutionVersion",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes a campaign by deleting the solution deployment. The solution that the
// campaign is based on is not deleted and can be redeployed when needed. A deleted
// campaign can no longer be specified in a GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html)
// request. For information on creating campaigns, see CreateCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateCampaign.html)
// .
func (c *Client) DeleteCampaign(ctx context.Context, params *DeleteCampaignInput, optFns ...func(*Options)) (*DeleteCampaignOutput, error) {
if params == nil {
params = &DeleteCampaignInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteCampaign", params, optFns, c.addOperationDeleteCampaignMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteCampaignOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteCampaignInput struct {
// The Amazon Resource Name (ARN) of the campaign to delete.
//
// This member is required.
CampaignArn *string
noSmithyDocumentSerde
}
type DeleteCampaignOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteCampaignMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteCampaign{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteCampaign{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteCampaignValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCampaign(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteCampaign(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteCampaign",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a dataset. You can't delete a dataset if an associated DatasetImportJob
// or SolutionVersion is in the CREATE PENDING or IN PROGRESS state. For more
// information on datasets, see CreateDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html)
// .
func (c *Client) DeleteDataset(ctx context.Context, params *DeleteDatasetInput, optFns ...func(*Options)) (*DeleteDatasetOutput, error) {
if params == nil {
params = &DeleteDatasetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDataset", params, optFns, c.addOperationDeleteDatasetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDatasetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDatasetInput struct {
// The Amazon Resource Name (ARN) of the dataset to delete.
//
// This member is required.
DatasetArn *string
noSmithyDocumentSerde
}
type DeleteDatasetOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDatasetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDataset{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDataset{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDatasetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDataset(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDataset(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteDataset",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a dataset group. Before you delete a dataset group, you must delete the
// following:
// - All associated event trackers.
// - All associated solutions.
// - All datasets in the dataset group.
func (c *Client) DeleteDatasetGroup(ctx context.Context, params *DeleteDatasetGroupInput, optFns ...func(*Options)) (*DeleteDatasetGroupOutput, error) {
if params == nil {
params = &DeleteDatasetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDatasetGroup", params, optFns, c.addOperationDeleteDatasetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDatasetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDatasetGroupInput struct {
// The ARN of the dataset group to delete.
//
// This member is required.
DatasetGroupArn *string
noSmithyDocumentSerde
}
type DeleteDatasetGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDatasetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDatasetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDatasetGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDatasetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDatasetGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDatasetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteDatasetGroup",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the event tracker. Does not delete the event-interactions dataset from
// the associated dataset group. For more information on event trackers, see
// CreateEventTracker (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateEventTracker.html)
// .
func (c *Client) DeleteEventTracker(ctx context.Context, params *DeleteEventTrackerInput, optFns ...func(*Options)) (*DeleteEventTrackerOutput, error) {
if params == nil {
params = &DeleteEventTrackerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteEventTracker", params, optFns, c.addOperationDeleteEventTrackerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteEventTrackerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteEventTrackerInput struct {
// The Amazon Resource Name (ARN) of the event tracker to delete.
//
// This member is required.
EventTrackerArn *string
noSmithyDocumentSerde
}
type DeleteEventTrackerOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteEventTrackerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteEventTracker{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteEventTracker{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteEventTrackerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteEventTracker(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEventTracker(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteEventTracker",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a filter.
func (c *Client) DeleteFilter(ctx context.Context, params *DeleteFilterInput, optFns ...func(*Options)) (*DeleteFilterOutput, error) {
if params == nil {
params = &DeleteFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFilter", params, optFns, c.addOperationDeleteFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFilterInput struct {
// The ARN of the filter to delete.
//
// This member is required.
FilterArn *string
noSmithyDocumentSerde
}
type DeleteFilterOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteFilter",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a metric attribution.
func (c *Client) DeleteMetricAttribution(ctx context.Context, params *DeleteMetricAttributionInput, optFns ...func(*Options)) (*DeleteMetricAttributionOutput, error) {
if params == nil {
params = &DeleteMetricAttributionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteMetricAttribution", params, optFns, c.addOperationDeleteMetricAttributionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteMetricAttributionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteMetricAttributionInput struct {
// The metric attribution's Amazon Resource Name (ARN).
//
// This member is required.
MetricAttributionArn *string
noSmithyDocumentSerde
}
type DeleteMetricAttributionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteMetricAttributionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteMetricAttribution{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteMetricAttribution{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteMetricAttributionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteMetricAttribution(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteMetricAttribution(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteMetricAttribution",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deactivates and removes a recommender. A deleted recommender can no longer be
// specified in a GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html)
// request.
func (c *Client) DeleteRecommender(ctx context.Context, params *DeleteRecommenderInput, optFns ...func(*Options)) (*DeleteRecommenderOutput, error) {
if params == nil {
params = &DeleteRecommenderInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteRecommender", params, optFns, c.addOperationDeleteRecommenderMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteRecommenderOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteRecommenderInput struct {
// The Amazon Resource Name (ARN) of the recommender to delete.
//
// This member is required.
RecommenderArn *string
noSmithyDocumentSerde
}
type DeleteRecommenderOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteRecommenderMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteRecommender{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteRecommender{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteRecommenderValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteRecommender(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteRecommender(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteRecommender",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a schema. Before deleting a schema, you must delete all datasets
// referencing the schema. For more information on schemas, see CreateSchema (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSchema.html)
// .
func (c *Client) DeleteSchema(ctx context.Context, params *DeleteSchemaInput, optFns ...func(*Options)) (*DeleteSchemaOutput, error) {
if params == nil {
params = &DeleteSchemaInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSchema", params, optFns, c.addOperationDeleteSchemaMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSchemaOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSchemaInput struct {
// The Amazon Resource Name (ARN) of the schema to delete.
//
// This member is required.
SchemaArn *string
noSmithyDocumentSerde
}
type DeleteSchemaOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSchemaMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteSchema{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteSchema{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteSchemaValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSchema(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteSchema(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteSchema",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes all versions of a solution and the Solution object itself. Before
// deleting a solution, you must delete all campaigns based on the solution. To
// determine what campaigns are using the solution, call ListCampaigns (https://docs.aws.amazon.com/personalize/latest/dg/API_ListCampaigns.html)
// and supply the Amazon Resource Name (ARN) of the solution. You can't delete a
// solution if an associated SolutionVersion is in the CREATE PENDING or IN
// PROGRESS state. For more information on solutions, see CreateSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html)
// .
func (c *Client) DeleteSolution(ctx context.Context, params *DeleteSolutionInput, optFns ...func(*Options)) (*DeleteSolutionOutput, error) {
if params == nil {
params = &DeleteSolutionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSolution", params, optFns, c.addOperationDeleteSolutionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSolutionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSolutionInput struct {
// The ARN of the solution to delete.
//
// This member is required.
SolutionArn *string
noSmithyDocumentSerde
}
type DeleteSolutionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSolutionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteSolution{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteSolution{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteSolutionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSolution(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteSolution(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DeleteSolution",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the given algorithm.
func (c *Client) DescribeAlgorithm(ctx context.Context, params *DescribeAlgorithmInput, optFns ...func(*Options)) (*DescribeAlgorithmOutput, error) {
if params == nil {
params = &DescribeAlgorithmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAlgorithm", params, optFns, c.addOperationDescribeAlgorithmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAlgorithmOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAlgorithmInput struct {
// The Amazon Resource Name (ARN) of the algorithm to describe.
//
// This member is required.
AlgorithmArn *string
noSmithyDocumentSerde
}
type DescribeAlgorithmOutput struct {
// A listing of the properties of the algorithm.
Algorithm *types.Algorithm
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAlgorithmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAlgorithm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAlgorithm{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAlgorithmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAlgorithm(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAlgorithm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeAlgorithm",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the properties of a batch inference job including name, Amazon Resource
// Name (ARN), status, input and output configurations, and the ARN of the solution
// version used to generate the recommendations.
func (c *Client) DescribeBatchInferenceJob(ctx context.Context, params *DescribeBatchInferenceJobInput, optFns ...func(*Options)) (*DescribeBatchInferenceJobOutput, error) {
if params == nil {
params = &DescribeBatchInferenceJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeBatchInferenceJob", params, optFns, c.addOperationDescribeBatchInferenceJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeBatchInferenceJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeBatchInferenceJobInput struct {
// The ARN of the batch inference job to describe.
//
// This member is required.
BatchInferenceJobArn *string
noSmithyDocumentSerde
}
type DescribeBatchInferenceJobOutput struct {
// Information on the specified batch inference job.
BatchInferenceJob *types.BatchInferenceJob
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeBatchInferenceJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeBatchInferenceJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeBatchInferenceJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeBatchInferenceJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeBatchInferenceJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeBatchInferenceJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeBatchInferenceJob",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the properties of a batch segment job including name, Amazon Resource Name
// (ARN), status, input and output configurations, and the ARN of the solution
// version used to generate segments.
func (c *Client) DescribeBatchSegmentJob(ctx context.Context, params *DescribeBatchSegmentJobInput, optFns ...func(*Options)) (*DescribeBatchSegmentJobOutput, error) {
if params == nil {
params = &DescribeBatchSegmentJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeBatchSegmentJob", params, optFns, c.addOperationDescribeBatchSegmentJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeBatchSegmentJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeBatchSegmentJobInput struct {
// The ARN of the batch segment job to describe.
//
// This member is required.
BatchSegmentJobArn *string
noSmithyDocumentSerde
}
type DescribeBatchSegmentJobOutput struct {
// Information on the specified batch segment job.
BatchSegmentJob *types.BatchSegmentJob
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeBatchSegmentJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeBatchSegmentJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeBatchSegmentJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeBatchSegmentJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeBatchSegmentJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeBatchSegmentJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeBatchSegmentJob",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the given campaign, including its status. A campaign can be in one of
// the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - DELETE PENDING > DELETE IN_PROGRESS
//
// When the status is CREATE FAILED , the response includes the failureReason key,
// which describes why. For more information on campaigns, see CreateCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateCampaign.html)
// .
func (c *Client) DescribeCampaign(ctx context.Context, params *DescribeCampaignInput, optFns ...func(*Options)) (*DescribeCampaignOutput, error) {
if params == nil {
params = &DescribeCampaignInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeCampaign", params, optFns, c.addOperationDescribeCampaignMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeCampaignOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeCampaignInput struct {
// The Amazon Resource Name (ARN) of the campaign.
//
// This member is required.
CampaignArn *string
noSmithyDocumentSerde
}
type DescribeCampaignOutput struct {
// The properties of the campaign.
Campaign *types.Campaign
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeCampaignMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeCampaign{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeCampaign{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeCampaignValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeCampaign(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeCampaign(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeCampaign",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the given dataset. For more information on datasets, see CreateDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html)
// .
func (c *Client) DescribeDataset(ctx context.Context, params *DescribeDatasetInput, optFns ...func(*Options)) (*DescribeDatasetOutput, error) {
if params == nil {
params = &DescribeDatasetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataset", params, optFns, c.addOperationDescribeDatasetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDatasetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDatasetInput struct {
// The Amazon Resource Name (ARN) of the dataset to describe.
//
// This member is required.
DatasetArn *string
noSmithyDocumentSerde
}
type DescribeDatasetOutput struct {
// A listing of the dataset's properties.
Dataset *types.Dataset
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDatasetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDataset{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDataset{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDatasetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataset(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataset(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeDataset",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the dataset export job created by CreateDatasetExportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetExportJob.html)
// , including the export job status.
func (c *Client) DescribeDatasetExportJob(ctx context.Context, params *DescribeDatasetExportJobInput, optFns ...func(*Options)) (*DescribeDatasetExportJobOutput, error) {
if params == nil {
params = &DescribeDatasetExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDatasetExportJob", params, optFns, c.addOperationDescribeDatasetExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDatasetExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDatasetExportJobInput struct {
// The Amazon Resource Name (ARN) of the dataset export job to describe.
//
// This member is required.
DatasetExportJobArn *string
noSmithyDocumentSerde
}
type DescribeDatasetExportJobOutput struct {
// Information about the dataset export job, including the status. The status is
// one of the following values:
// - CREATE PENDING
// - CREATE IN_PROGRESS
// - ACTIVE
// - CREATE FAILED
DatasetExportJob *types.DatasetExportJob
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDatasetExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDatasetExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDatasetExportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDatasetExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDatasetExportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDatasetExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeDatasetExportJob",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the given dataset group. For more information on dataset groups, see
// CreateDatasetGroup (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetGroup.html)
// .
func (c *Client) DescribeDatasetGroup(ctx context.Context, params *DescribeDatasetGroupInput, optFns ...func(*Options)) (*DescribeDatasetGroupOutput, error) {
if params == nil {
params = &DescribeDatasetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDatasetGroup", params, optFns, c.addOperationDescribeDatasetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDatasetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDatasetGroupInput struct {
// The Amazon Resource Name (ARN) of the dataset group to describe.
//
// This member is required.
DatasetGroupArn *string
noSmithyDocumentSerde
}
type DescribeDatasetGroupOutput struct {
// A listing of the dataset group's properties.
DatasetGroup *types.DatasetGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDatasetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDatasetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDatasetGroup{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDatasetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDatasetGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDatasetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeDatasetGroup",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the dataset import job created by CreateDatasetImportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetImportJob.html)
// , including the import job status.
func (c *Client) DescribeDatasetImportJob(ctx context.Context, params *DescribeDatasetImportJobInput, optFns ...func(*Options)) (*DescribeDatasetImportJobOutput, error) {
if params == nil {
params = &DescribeDatasetImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDatasetImportJob", params, optFns, c.addOperationDescribeDatasetImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDatasetImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDatasetImportJobInput struct {
// The Amazon Resource Name (ARN) of the dataset import job to describe.
//
// This member is required.
DatasetImportJobArn *string
noSmithyDocumentSerde
}
type DescribeDatasetImportJobOutput struct {
// Information about the dataset import job, including the status. The status is
// one of the following values:
// - CREATE PENDING
// - CREATE IN_PROGRESS
// - ACTIVE
// - CREATE FAILED
DatasetImportJob *types.DatasetImportJob
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDatasetImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDatasetImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDatasetImportJob{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDatasetImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDatasetImportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDatasetImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeDatasetImportJob",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes an event tracker. The response includes the trackingId and status of
// the event tracker. For more information on event trackers, see
// CreateEventTracker (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateEventTracker.html)
// .
func (c *Client) DescribeEventTracker(ctx context.Context, params *DescribeEventTrackerInput, optFns ...func(*Options)) (*DescribeEventTrackerOutput, error) {
if params == nil {
params = &DescribeEventTrackerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEventTracker", params, optFns, c.addOperationDescribeEventTrackerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEventTrackerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEventTrackerInput struct {
// The Amazon Resource Name (ARN) of the event tracker to describe.
//
// This member is required.
EventTrackerArn *string
noSmithyDocumentSerde
}
type DescribeEventTrackerOutput struct {
// An object that describes the event tracker.
EventTracker *types.EventTracker
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEventTrackerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEventTracker{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEventTracker{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeEventTrackerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeEventTracker(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeEventTracker(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeEventTracker",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the given feature transformation.
func (c *Client) DescribeFeatureTransformation(ctx context.Context, params *DescribeFeatureTransformationInput, optFns ...func(*Options)) (*DescribeFeatureTransformationOutput, error) {
if params == nil {
params = &DescribeFeatureTransformationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFeatureTransformation", params, optFns, c.addOperationDescribeFeatureTransformationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFeatureTransformationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFeatureTransformationInput struct {
// The Amazon Resource Name (ARN) of the feature transformation to describe.
//
// This member is required.
FeatureTransformationArn *string
noSmithyDocumentSerde
}
type DescribeFeatureTransformationOutput struct {
// A listing of the FeatureTransformation properties.
FeatureTransformation *types.FeatureTransformation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFeatureTransformationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFeatureTransformation{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFeatureTransformation{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeFeatureTransformationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFeatureTransformation(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFeatureTransformation(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeFeatureTransformation",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a filter's properties.
func (c *Client) DescribeFilter(ctx context.Context, params *DescribeFilterInput, optFns ...func(*Options)) (*DescribeFilterOutput, error) {
if params == nil {
params = &DescribeFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFilter", params, optFns, c.addOperationDescribeFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFilterInput struct {
// The ARN of the filter to describe.
//
// This member is required.
FilterArn *string
noSmithyDocumentSerde
}
type DescribeFilterOutput struct {
// The filter's details.
Filter *types.Filter
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFilter{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFilter(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeFilter",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a metric attribution.
func (c *Client) DescribeMetricAttribution(ctx context.Context, params *DescribeMetricAttributionInput, optFns ...func(*Options)) (*DescribeMetricAttributionOutput, error) {
if params == nil {
params = &DescribeMetricAttributionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeMetricAttribution", params, optFns, c.addOperationDescribeMetricAttributionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeMetricAttributionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeMetricAttributionInput struct {
// The metric attribution's Amazon Resource Name (ARN).
//
// This member is required.
MetricAttributionArn *string
noSmithyDocumentSerde
}
type DescribeMetricAttributionOutput struct {
// The details of the metric attribution.
MetricAttribution *types.MetricAttribution
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeMetricAttributionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeMetricAttribution{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeMetricAttribution{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeMetricAttributionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeMetricAttribution(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeMetricAttribution(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeMetricAttribution",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a recipe. A recipe contains three items:
// - An algorithm that trains a model.
// - Hyperparameters that govern the training.
// - Feature transformation information for modifying the input data before
// training.
//
// Amazon Personalize provides a set of predefined recipes. You specify a recipe
// when you create a solution with the CreateSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html)
// API. CreateSolution trains a model by using the algorithm in the specified
// recipe and a training dataset. The solution, when deployed as a campaign, can
// provide recommendations using the GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html)
// API.
func (c *Client) DescribeRecipe(ctx context.Context, params *DescribeRecipeInput, optFns ...func(*Options)) (*DescribeRecipeOutput, error) {
if params == nil {
params = &DescribeRecipeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeRecipe", params, optFns, c.addOperationDescribeRecipeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeRecipeOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeRecipeInput struct {
// The Amazon Resource Name (ARN) of the recipe to describe.
//
// This member is required.
RecipeArn *string
noSmithyDocumentSerde
}
type DescribeRecipeOutput struct {
// An object that describes the recipe.
Recipe *types.Recipe
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeRecipeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeRecipe{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeRecipe{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeRecipeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeRecipe(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeRecipe(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeRecipe",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the given recommender, including its status. A recommender can be in
// one of the following states:
// - CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
// - STOP PENDING > STOP IN_PROGRESS > INACTIVE > START PENDING > START
// IN_PROGRESS > ACTIVE
// - DELETE PENDING > DELETE IN_PROGRESS
//
// When the status is CREATE FAILED , the response includes the failureReason key,
// which describes why. The modelMetrics key is null when the recommender is being
// created or deleted. For more information on recommenders, see CreateRecommender (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateRecommender.html)
// .
func (c *Client) DescribeRecommender(ctx context.Context, params *DescribeRecommenderInput, optFns ...func(*Options)) (*DescribeRecommenderOutput, error) {
if params == nil {
params = &DescribeRecommenderInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeRecommender", params, optFns, c.addOperationDescribeRecommenderMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeRecommenderOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeRecommenderInput struct {
// The Amazon Resource Name (ARN) of the recommender to describe.
//
// This member is required.
RecommenderArn *string
noSmithyDocumentSerde
}
type DescribeRecommenderOutput struct {
// The properties of the recommender.
Recommender *types.Recommender
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeRecommenderMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeRecommender{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeRecommender{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeRecommenderValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeRecommender(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeRecommender(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeRecommender",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a schema. For more information on schemas, see CreateSchema (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSchema.html)
// .
func (c *Client) DescribeSchema(ctx context.Context, params *DescribeSchemaInput, optFns ...func(*Options)) (*DescribeSchemaOutput, error) {
if params == nil {
params = &DescribeSchemaInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeSchema", params, optFns, c.addOperationDescribeSchemaMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeSchemaOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeSchemaInput struct {
// The Amazon Resource Name (ARN) of the schema to retrieve.
//
// This member is required.
SchemaArn *string
noSmithyDocumentSerde
}
type DescribeSchemaOutput struct {
// The requested schema.
Schema *types.DatasetSchema
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeSchemaMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeSchema{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeSchema{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeSchemaValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeSchema(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeSchema(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeSchema",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a solution. For more information on solutions, see CreateSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html)
// .
func (c *Client) DescribeSolution(ctx context.Context, params *DescribeSolutionInput, optFns ...func(*Options)) (*DescribeSolutionOutput, error) {
if params == nil {
params = &DescribeSolutionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeSolution", params, optFns, c.addOperationDescribeSolutionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeSolutionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeSolutionInput struct {
// The Amazon Resource Name (ARN) of the solution to describe.
//
// This member is required.
SolutionArn *string
noSmithyDocumentSerde
}
type DescribeSolutionOutput struct {
// An object that describes the solution.
Solution *types.Solution
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeSolutionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeSolution{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeSolution{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeSolutionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeSolution(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeSolution(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeSolution",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a specific version of a solution. For more information on solutions,
// see CreateSolution (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html)
func (c *Client) DescribeSolutionVersion(ctx context.Context, params *DescribeSolutionVersionInput, optFns ...func(*Options)) (*DescribeSolutionVersionOutput, error) {
if params == nil {
params = &DescribeSolutionVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeSolutionVersion", params, optFns, c.addOperationDescribeSolutionVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeSolutionVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeSolutionVersionInput struct {
// The Amazon Resource Name (ARN) of the solution version.
//
// This member is required.
SolutionVersionArn *string
noSmithyDocumentSerde
}
type DescribeSolutionVersionOutput struct {
// The solution version.
SolutionVersion *types.SolutionVersion
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeSolutionVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeSolutionVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeSolutionVersion{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeSolutionVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeSolutionVersion(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeSolutionVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "DescribeSolutionVersion",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the metrics for the specified solution version.
func (c *Client) GetSolutionMetrics(ctx context.Context, params *GetSolutionMetricsInput, optFns ...func(*Options)) (*GetSolutionMetricsOutput, error) {
if params == nil {
params = &GetSolutionMetricsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSolutionMetrics", params, optFns, c.addOperationGetSolutionMetricsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSolutionMetricsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSolutionMetricsInput struct {
// The Amazon Resource Name (ARN) of the solution version for which to get metrics.
//
// This member is required.
SolutionVersionArn *string
noSmithyDocumentSerde
}
type GetSolutionMetricsOutput struct {
// The metrics for the solution version. For more information, see Evaluating a
// solution version with metrics (https://docs.aws.amazon.com/personalize/latest/dg/working-with-training-metrics.html)
// .
Metrics map[string]float64
// The same solution version ARN as specified in the request.
SolutionVersionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSolutionMetricsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetSolutionMetrics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetSolutionMetrics{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpGetSolutionMetricsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSolutionMetrics(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opGetSolutionMetrics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "GetSolutionMetrics",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets a list of the batch inference jobs that have been performed off of a
// solution version.
func (c *Client) ListBatchInferenceJobs(ctx context.Context, params *ListBatchInferenceJobsInput, optFns ...func(*Options)) (*ListBatchInferenceJobsOutput, error) {
if params == nil {
params = &ListBatchInferenceJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListBatchInferenceJobs", params, optFns, c.addOperationListBatchInferenceJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListBatchInferenceJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListBatchInferenceJobsInput struct {
// The maximum number of batch inference job results to return in each page. The
// default value is 100.
MaxResults *int32
// The token to request the next page of results.
NextToken *string
// The Amazon Resource Name (ARN) of the solution version from which the batch
// inference jobs were created.
SolutionVersionArn *string
noSmithyDocumentSerde
}
type ListBatchInferenceJobsOutput struct {
// A list containing information on each job that is returned.
BatchInferenceJobs []types.BatchInferenceJobSummary
// The token to use to retrieve the next page of results. The value is null when
// there are no more results to return.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListBatchInferenceJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListBatchInferenceJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListBatchInferenceJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListBatchInferenceJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListBatchInferenceJobsAPIClient is a client that implements the
// ListBatchInferenceJobs operation.
type ListBatchInferenceJobsAPIClient interface {
ListBatchInferenceJobs(context.Context, *ListBatchInferenceJobsInput, ...func(*Options)) (*ListBatchInferenceJobsOutput, error)
}
var _ ListBatchInferenceJobsAPIClient = (*Client)(nil)
// ListBatchInferenceJobsPaginatorOptions is the paginator options for
// ListBatchInferenceJobs
type ListBatchInferenceJobsPaginatorOptions struct {
// The maximum number of batch inference job results to return in each page. The
// default value is 100.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListBatchInferenceJobsPaginator is a paginator for ListBatchInferenceJobs
type ListBatchInferenceJobsPaginator struct {
options ListBatchInferenceJobsPaginatorOptions
client ListBatchInferenceJobsAPIClient
params *ListBatchInferenceJobsInput
nextToken *string
firstPage bool
}
// NewListBatchInferenceJobsPaginator returns a new ListBatchInferenceJobsPaginator
func NewListBatchInferenceJobsPaginator(client ListBatchInferenceJobsAPIClient, params *ListBatchInferenceJobsInput, optFns ...func(*ListBatchInferenceJobsPaginatorOptions)) *ListBatchInferenceJobsPaginator {
if params == nil {
params = &ListBatchInferenceJobsInput{}
}
options := ListBatchInferenceJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListBatchInferenceJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListBatchInferenceJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListBatchInferenceJobs page.
func (p *ListBatchInferenceJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListBatchInferenceJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListBatchInferenceJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListBatchInferenceJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListBatchInferenceJobs",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets a list of the batch segment jobs that have been performed off of a
// solution version that you specify.
func (c *Client) ListBatchSegmentJobs(ctx context.Context, params *ListBatchSegmentJobsInput, optFns ...func(*Options)) (*ListBatchSegmentJobsOutput, error) {
if params == nil {
params = &ListBatchSegmentJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListBatchSegmentJobs", params, optFns, c.addOperationListBatchSegmentJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListBatchSegmentJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListBatchSegmentJobsInput struct {
// The maximum number of batch segment job results to return in each page. The
// default value is 100.
MaxResults *int32
// The token to request the next page of results.
NextToken *string
// The Amazon Resource Name (ARN) of the solution version that the batch segment
// jobs used to generate batch segments.
SolutionVersionArn *string
noSmithyDocumentSerde
}
type ListBatchSegmentJobsOutput struct {
// A list containing information on each job that is returned.
BatchSegmentJobs []types.BatchSegmentJobSummary
// The token to use to retrieve the next page of results. The value is null when
// there are no more results to return.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListBatchSegmentJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListBatchSegmentJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListBatchSegmentJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListBatchSegmentJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListBatchSegmentJobsAPIClient is a client that implements the
// ListBatchSegmentJobs operation.
type ListBatchSegmentJobsAPIClient interface {
ListBatchSegmentJobs(context.Context, *ListBatchSegmentJobsInput, ...func(*Options)) (*ListBatchSegmentJobsOutput, error)
}
var _ ListBatchSegmentJobsAPIClient = (*Client)(nil)
// ListBatchSegmentJobsPaginatorOptions is the paginator options for
// ListBatchSegmentJobs
type ListBatchSegmentJobsPaginatorOptions struct {
// The maximum number of batch segment job results to return in each page. The
// default value is 100.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListBatchSegmentJobsPaginator is a paginator for ListBatchSegmentJobs
type ListBatchSegmentJobsPaginator struct {
options ListBatchSegmentJobsPaginatorOptions
client ListBatchSegmentJobsAPIClient
params *ListBatchSegmentJobsInput
nextToken *string
firstPage bool
}
// NewListBatchSegmentJobsPaginator returns a new ListBatchSegmentJobsPaginator
func NewListBatchSegmentJobsPaginator(client ListBatchSegmentJobsAPIClient, params *ListBatchSegmentJobsInput, optFns ...func(*ListBatchSegmentJobsPaginatorOptions)) *ListBatchSegmentJobsPaginator {
if params == nil {
params = &ListBatchSegmentJobsInput{}
}
options := ListBatchSegmentJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListBatchSegmentJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListBatchSegmentJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListBatchSegmentJobs page.
func (p *ListBatchSegmentJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListBatchSegmentJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListBatchSegmentJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListBatchSegmentJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListBatchSegmentJobs",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of campaigns that use the given solution. When a solution is not
// specified, all the campaigns associated with the account are listed. The
// response provides the properties for each campaign, including the Amazon
// Resource Name (ARN). For more information on campaigns, see CreateCampaign (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateCampaign.html)
// .
func (c *Client) ListCampaigns(ctx context.Context, params *ListCampaignsInput, optFns ...func(*Options)) (*ListCampaignsOutput, error) {
if params == nil {
params = &ListCampaignsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCampaigns", params, optFns, c.addOperationListCampaignsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListCampaignsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListCampaignsInput struct {
// The maximum number of campaigns to return.
MaxResults *int32
// A token returned from the previous call to ListCampaigns (https://docs.aws.amazon.com/personalize/latest/dg/API_ListCampaigns.html)
// for getting the next set of campaigns (if they exist).
NextToken *string
// The Amazon Resource Name (ARN) of the solution to list the campaigns for. When
// a solution is not specified, all the campaigns associated with the account are
// listed.
SolutionArn *string
noSmithyDocumentSerde
}
type ListCampaignsOutput struct {
// A list of the campaigns.
Campaigns []types.CampaignSummary
// A token for getting the next set of campaigns (if they exist).
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListCampaignsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListCampaigns{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListCampaigns{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCampaigns(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListCampaignsAPIClient is a client that implements the ListCampaigns operation.
type ListCampaignsAPIClient interface {
ListCampaigns(context.Context, *ListCampaignsInput, ...func(*Options)) (*ListCampaignsOutput, error)
}
var _ ListCampaignsAPIClient = (*Client)(nil)
// ListCampaignsPaginatorOptions is the paginator options for ListCampaigns
type ListCampaignsPaginatorOptions struct {
// The maximum number of campaigns to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListCampaignsPaginator is a paginator for ListCampaigns
type ListCampaignsPaginator struct {
options ListCampaignsPaginatorOptions
client ListCampaignsAPIClient
params *ListCampaignsInput
nextToken *string
firstPage bool
}
// NewListCampaignsPaginator returns a new ListCampaignsPaginator
func NewListCampaignsPaginator(client ListCampaignsAPIClient, params *ListCampaignsInput, optFns ...func(*ListCampaignsPaginatorOptions)) *ListCampaignsPaginator {
if params == nil {
params = &ListCampaignsInput{}
}
options := ListCampaignsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListCampaignsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListCampaignsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListCampaigns page.
func (p *ListCampaignsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCampaignsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListCampaigns(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListCampaigns(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListCampaigns",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of dataset export jobs that use the given dataset. When a
// dataset is not specified, all the dataset export jobs associated with the
// account are listed. The response provides the properties for each dataset export
// job, including the Amazon Resource Name (ARN). For more information on dataset
// export jobs, see CreateDatasetExportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetExportJob.html)
// . For more information on datasets, see CreateDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html)
// .
func (c *Client) ListDatasetExportJobs(ctx context.Context, params *ListDatasetExportJobsInput, optFns ...func(*Options)) (*ListDatasetExportJobsOutput, error) {
if params == nil {
params = &ListDatasetExportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDatasetExportJobs", params, optFns, c.addOperationListDatasetExportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDatasetExportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDatasetExportJobsInput struct {
// The Amazon Resource Name (ARN) of the dataset to list the dataset export jobs
// for.
DatasetArn *string
// The maximum number of dataset export jobs to return.
MaxResults *int32
// A token returned from the previous call to ListDatasetExportJobs for getting
// the next set of dataset export jobs (if they exist).
NextToken *string
noSmithyDocumentSerde
}
type ListDatasetExportJobsOutput struct {
// The list of dataset export jobs.
DatasetExportJobs []types.DatasetExportJobSummary
// A token for getting the next set of dataset export jobs (if they exist).
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDatasetExportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDatasetExportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDatasetExportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDatasetExportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDatasetExportJobsAPIClient is a client that implements the
// ListDatasetExportJobs operation.
type ListDatasetExportJobsAPIClient interface {
ListDatasetExportJobs(context.Context, *ListDatasetExportJobsInput, ...func(*Options)) (*ListDatasetExportJobsOutput, error)
}
var _ ListDatasetExportJobsAPIClient = (*Client)(nil)
// ListDatasetExportJobsPaginatorOptions is the paginator options for
// ListDatasetExportJobs
type ListDatasetExportJobsPaginatorOptions struct {
// The maximum number of dataset export jobs to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListDatasetExportJobsPaginator is a paginator for ListDatasetExportJobs
type ListDatasetExportJobsPaginator struct {
options ListDatasetExportJobsPaginatorOptions
client ListDatasetExportJobsAPIClient
params *ListDatasetExportJobsInput
nextToken *string
firstPage bool
}
// NewListDatasetExportJobsPaginator returns a new ListDatasetExportJobsPaginator
func NewListDatasetExportJobsPaginator(client ListDatasetExportJobsAPIClient, params *ListDatasetExportJobsInput, optFns ...func(*ListDatasetExportJobsPaginatorOptions)) *ListDatasetExportJobsPaginator {
if params == nil {
params = &ListDatasetExportJobsInput{}
}
options := ListDatasetExportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDatasetExportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDatasetExportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDatasetExportJobs page.
func (p *ListDatasetExportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetExportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDatasetExportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDatasetExportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListDatasetExportJobs",
}
}
| 229 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of dataset groups. The response provides the properties for each
// dataset group, including the Amazon Resource Name (ARN). For more information on
// dataset groups, see CreateDatasetGroup (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetGroup.html)
// .
func (c *Client) ListDatasetGroups(ctx context.Context, params *ListDatasetGroupsInput, optFns ...func(*Options)) (*ListDatasetGroupsOutput, error) {
if params == nil {
params = &ListDatasetGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDatasetGroups", params, optFns, c.addOperationListDatasetGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDatasetGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDatasetGroupsInput struct {
// The maximum number of dataset groups to return.
MaxResults *int32
// A token returned from the previous call to ListDatasetGroups for getting the
// next set of dataset groups (if they exist).
NextToken *string
noSmithyDocumentSerde
}
type ListDatasetGroupsOutput struct {
// The list of your dataset groups.
DatasetGroups []types.DatasetGroupSummary
// A token for getting the next set of dataset groups (if they exist).
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDatasetGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDatasetGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDatasetGroups{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDatasetGroups(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDatasetGroupsAPIClient is a client that implements the ListDatasetGroups
// operation.
type ListDatasetGroupsAPIClient interface {
ListDatasetGroups(context.Context, *ListDatasetGroupsInput, ...func(*Options)) (*ListDatasetGroupsOutput, error)
}
var _ ListDatasetGroupsAPIClient = (*Client)(nil)
// ListDatasetGroupsPaginatorOptions is the paginator options for ListDatasetGroups
type ListDatasetGroupsPaginatorOptions struct {
// The maximum number of dataset groups to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListDatasetGroupsPaginator is a paginator for ListDatasetGroups
type ListDatasetGroupsPaginator struct {
options ListDatasetGroupsPaginatorOptions
client ListDatasetGroupsAPIClient
params *ListDatasetGroupsInput
nextToken *string
firstPage bool
}
// NewListDatasetGroupsPaginator returns a new ListDatasetGroupsPaginator
func NewListDatasetGroupsPaginator(client ListDatasetGroupsAPIClient, params *ListDatasetGroupsInput, optFns ...func(*ListDatasetGroupsPaginatorOptions)) *ListDatasetGroupsPaginator {
if params == nil {
params = &ListDatasetGroupsInput{}
}
options := ListDatasetGroupsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDatasetGroupsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDatasetGroupsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDatasetGroups page.
func (p *ListDatasetGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetGroupsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDatasetGroups(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDatasetGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListDatasetGroups",
}
}
| 221 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of dataset import jobs that use the given dataset. When a
// dataset is not specified, all the dataset import jobs associated with the
// account are listed. The response provides the properties for each dataset import
// job, including the Amazon Resource Name (ARN). For more information on dataset
// import jobs, see CreateDatasetImportJob (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDatasetImportJob.html)
// . For more information on datasets, see CreateDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html)
// .
func (c *Client) ListDatasetImportJobs(ctx context.Context, params *ListDatasetImportJobsInput, optFns ...func(*Options)) (*ListDatasetImportJobsOutput, error) {
if params == nil {
params = &ListDatasetImportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDatasetImportJobs", params, optFns, c.addOperationListDatasetImportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDatasetImportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDatasetImportJobsInput struct {
// The Amazon Resource Name (ARN) of the dataset to list the dataset import jobs
// for.
DatasetArn *string
// The maximum number of dataset import jobs to return.
MaxResults *int32
// A token returned from the previous call to ListDatasetImportJobs for getting
// the next set of dataset import jobs (if they exist).
NextToken *string
noSmithyDocumentSerde
}
type ListDatasetImportJobsOutput struct {
// The list of dataset import jobs.
DatasetImportJobs []types.DatasetImportJobSummary
// A token for getting the next set of dataset import jobs (if they exist).
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDatasetImportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDatasetImportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDatasetImportJobs{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDatasetImportJobs(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDatasetImportJobsAPIClient is a client that implements the
// ListDatasetImportJobs operation.
type ListDatasetImportJobsAPIClient interface {
ListDatasetImportJobs(context.Context, *ListDatasetImportJobsInput, ...func(*Options)) (*ListDatasetImportJobsOutput, error)
}
var _ ListDatasetImportJobsAPIClient = (*Client)(nil)
// ListDatasetImportJobsPaginatorOptions is the paginator options for
// ListDatasetImportJobs
type ListDatasetImportJobsPaginatorOptions struct {
// The maximum number of dataset import jobs to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListDatasetImportJobsPaginator is a paginator for ListDatasetImportJobs
type ListDatasetImportJobsPaginator struct {
options ListDatasetImportJobsPaginatorOptions
client ListDatasetImportJobsAPIClient
params *ListDatasetImportJobsInput
nextToken *string
firstPage bool
}
// NewListDatasetImportJobsPaginator returns a new ListDatasetImportJobsPaginator
func NewListDatasetImportJobsPaginator(client ListDatasetImportJobsAPIClient, params *ListDatasetImportJobsInput, optFns ...func(*ListDatasetImportJobsPaginatorOptions)) *ListDatasetImportJobsPaginator {
if params == nil {
params = &ListDatasetImportJobsInput{}
}
options := ListDatasetImportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDatasetImportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDatasetImportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDatasetImportJobs page.
func (p *ListDatasetImportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetImportJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDatasetImportJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDatasetImportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListDatasetImportJobs",
}
}
| 229 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the list of datasets contained in the given dataset group. The response
// provides the properties for each dataset, including the Amazon Resource Name
// (ARN). For more information on datasets, see CreateDataset (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html)
// .
func (c *Client) ListDatasets(ctx context.Context, params *ListDatasetsInput, optFns ...func(*Options)) (*ListDatasetsOutput, error) {
if params == nil {
params = &ListDatasetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDatasets", params, optFns, c.addOperationListDatasetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDatasetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDatasetsInput struct {
// The Amazon Resource Name (ARN) of the dataset group that contains the datasets
// to list.
DatasetGroupArn *string
// The maximum number of datasets to return.
MaxResults *int32
// A token returned from the previous call to ListDatasetImportJobs for getting
// the next set of dataset import jobs (if they exist).
NextToken *string
noSmithyDocumentSerde
}
type ListDatasetsOutput struct {
// An array of Dataset objects. Each object provides metadata information.
Datasets []types.DatasetSummary
// A token for getting the next set of datasets (if they exist).
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDatasetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDatasets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDatasets{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDatasets(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListDatasetsAPIClient is a client that implements the ListDatasets operation.
type ListDatasetsAPIClient interface {
ListDatasets(context.Context, *ListDatasetsInput, ...func(*Options)) (*ListDatasetsOutput, error)
}
var _ ListDatasetsAPIClient = (*Client)(nil)
// ListDatasetsPaginatorOptions is the paginator options for ListDatasets
type ListDatasetsPaginatorOptions struct {
// The maximum number of datasets to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListDatasetsPaginator is a paginator for ListDatasets
type ListDatasetsPaginator struct {
options ListDatasetsPaginatorOptions
client ListDatasetsAPIClient
params *ListDatasetsInput
nextToken *string
firstPage bool
}
// NewListDatasetsPaginator returns a new ListDatasetsPaginator
func NewListDatasetsPaginator(client ListDatasetsAPIClient, params *ListDatasetsInput, optFns ...func(*ListDatasetsPaginatorOptions)) *ListDatasetsPaginator {
if params == nil {
params = &ListDatasetsInput{}
}
options := ListDatasetsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDatasetsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDatasetsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDatasets page.
func (p *ListDatasetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListDatasets(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListDatasets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListDatasets",
}
}
| 224 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the list of event trackers associated with the account. The response
// provides the properties for each event tracker, including the Amazon Resource
// Name (ARN) and tracking ID. For more information on event trackers, see
// CreateEventTracker (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateEventTracker.html)
// .
func (c *Client) ListEventTrackers(ctx context.Context, params *ListEventTrackersInput, optFns ...func(*Options)) (*ListEventTrackersOutput, error) {
if params == nil {
params = &ListEventTrackersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListEventTrackers", params, optFns, c.addOperationListEventTrackersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListEventTrackersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListEventTrackersInput struct {
// The ARN of a dataset group used to filter the response.
DatasetGroupArn *string
// The maximum number of event trackers to return.
MaxResults *int32
// A token returned from the previous call to ListEventTrackers for getting the
// next set of event trackers (if they exist).
NextToken *string
noSmithyDocumentSerde
}
type ListEventTrackersOutput struct {
// A list of event trackers.
EventTrackers []types.EventTrackerSummary
// A token for getting the next set of event trackers (if they exist).
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListEventTrackersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListEventTrackers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListEventTrackers{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListEventTrackers(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListEventTrackersAPIClient is a client that implements the ListEventTrackers
// operation.
type ListEventTrackersAPIClient interface {
ListEventTrackers(context.Context, *ListEventTrackersInput, ...func(*Options)) (*ListEventTrackersOutput, error)
}
var _ ListEventTrackersAPIClient = (*Client)(nil)
// ListEventTrackersPaginatorOptions is the paginator options for ListEventTrackers
type ListEventTrackersPaginatorOptions struct {
// The maximum number of event trackers to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListEventTrackersPaginator is a paginator for ListEventTrackers
type ListEventTrackersPaginator struct {
options ListEventTrackersPaginatorOptions
client ListEventTrackersAPIClient
params *ListEventTrackersInput
nextToken *string
firstPage bool
}
// NewListEventTrackersPaginator returns a new ListEventTrackersPaginator
func NewListEventTrackersPaginator(client ListEventTrackersAPIClient, params *ListEventTrackersInput, optFns ...func(*ListEventTrackersPaginatorOptions)) *ListEventTrackersPaginator {
if params == nil {
params = &ListEventTrackersInput{}
}
options := ListEventTrackersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListEventTrackersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListEventTrackersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListEventTrackers page.
func (p *ListEventTrackersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListEventTrackersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListEventTrackers(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListEventTrackers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListEventTrackers",
}
}
| 225 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all filters that belong to a given dataset group.
func (c *Client) ListFilters(ctx context.Context, params *ListFiltersInput, optFns ...func(*Options)) (*ListFiltersOutput, error) {
if params == nil {
params = &ListFiltersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFilters", params, optFns, c.addOperationListFiltersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFiltersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFiltersInput struct {
// The ARN of the dataset group that contains the filters.
DatasetGroupArn *string
// The maximum number of filters to return.
MaxResults *int32
// A token returned from the previous call to ListFilters for getting the next set
// of filters (if they exist).
NextToken *string
noSmithyDocumentSerde
}
type ListFiltersOutput struct {
// A list of returned filters.
Filters []types.FilterSummary
// A token for getting the next set of filters (if they exist).
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFiltersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListFilters{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListFilters{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListFilters(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListFiltersAPIClient is a client that implements the ListFilters operation.
type ListFiltersAPIClient interface {
ListFilters(context.Context, *ListFiltersInput, ...func(*Options)) (*ListFiltersOutput, error)
}
var _ ListFiltersAPIClient = (*Client)(nil)
// ListFiltersPaginatorOptions is the paginator options for ListFilters
type ListFiltersPaginatorOptions struct {
// The maximum number of filters to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListFiltersPaginator is a paginator for ListFilters
type ListFiltersPaginator struct {
options ListFiltersPaginatorOptions
client ListFiltersAPIClient
params *ListFiltersInput
nextToken *string
firstPage bool
}
// NewListFiltersPaginator returns a new ListFiltersPaginator
func NewListFiltersPaginator(client ListFiltersAPIClient, params *ListFiltersInput, optFns ...func(*ListFiltersPaginatorOptions)) *ListFiltersPaginator {
if params == nil {
params = &ListFiltersInput{}
}
options := ListFiltersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListFiltersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListFiltersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListFilters page.
func (p *ListFiltersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFiltersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListFilters(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListFilters(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListFilters",
}
}
| 220 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the metrics for the metric attribution.
func (c *Client) ListMetricAttributionMetrics(ctx context.Context, params *ListMetricAttributionMetricsInput, optFns ...func(*Options)) (*ListMetricAttributionMetricsOutput, error) {
if params == nil {
params = &ListMetricAttributionMetricsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMetricAttributionMetrics", params, optFns, c.addOperationListMetricAttributionMetricsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMetricAttributionMetricsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMetricAttributionMetricsInput struct {
// The maximum number of metrics to return in one page of results.
MaxResults *int32
// The Amazon Resource Name (ARN) of the metric attribution to retrieve attributes
// for.
MetricAttributionArn *string
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListMetricAttributionMetricsOutput struct {
// The metrics for the specified metric attribution.
Metrics []types.MetricAttribute
// Specify the pagination token from a previous
// ListMetricAttributionMetricsResponse request to retrieve the next page of
// results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMetricAttributionMetricsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListMetricAttributionMetrics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListMetricAttributionMetrics{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListMetricAttributionMetrics(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListMetricAttributionMetricsAPIClient is a client that implements the
// ListMetricAttributionMetrics operation.
type ListMetricAttributionMetricsAPIClient interface {
ListMetricAttributionMetrics(context.Context, *ListMetricAttributionMetricsInput, ...func(*Options)) (*ListMetricAttributionMetricsOutput, error)
}
var _ ListMetricAttributionMetricsAPIClient = (*Client)(nil)
// ListMetricAttributionMetricsPaginatorOptions is the paginator options for
// ListMetricAttributionMetrics
type ListMetricAttributionMetricsPaginatorOptions struct {
// The maximum number of metrics to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListMetricAttributionMetricsPaginator is a paginator for
// ListMetricAttributionMetrics
type ListMetricAttributionMetricsPaginator struct {
options ListMetricAttributionMetricsPaginatorOptions
client ListMetricAttributionMetricsAPIClient
params *ListMetricAttributionMetricsInput
nextToken *string
firstPage bool
}
// NewListMetricAttributionMetricsPaginator returns a new
// ListMetricAttributionMetricsPaginator
func NewListMetricAttributionMetricsPaginator(client ListMetricAttributionMetricsAPIClient, params *ListMetricAttributionMetricsInput, optFns ...func(*ListMetricAttributionMetricsPaginatorOptions)) *ListMetricAttributionMetricsPaginator {
if params == nil {
params = &ListMetricAttributionMetricsInput{}
}
options := ListMetricAttributionMetricsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMetricAttributionMetricsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMetricAttributionMetricsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMetricAttributionMetrics page.
func (p *ListMetricAttributionMetricsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMetricAttributionMetricsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListMetricAttributionMetrics(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListMetricAttributionMetrics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListMetricAttributionMetrics",
}
}
| 227 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists metric attributions.
func (c *Client) ListMetricAttributions(ctx context.Context, params *ListMetricAttributionsInput, optFns ...func(*Options)) (*ListMetricAttributionsOutput, error) {
if params == nil {
params = &ListMetricAttributionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMetricAttributions", params, optFns, c.addOperationListMetricAttributionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMetricAttributionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMetricAttributionsInput struct {
// The metric attributions' dataset group Amazon Resource Name (ARN).
DatasetGroupArn *string
// The maximum number of metric attributions to return in one page of results.
MaxResults *int32
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
noSmithyDocumentSerde
}
type ListMetricAttributionsOutput struct {
// The list of metric attributions.
MetricAttributions []types.MetricAttributionSummary
// Specify the pagination token from a previous request to retrieve the next page
// of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMetricAttributionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListMetricAttributions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListMetricAttributions{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListMetricAttributions(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListMetricAttributionsAPIClient is a client that implements the
// ListMetricAttributions operation.
type ListMetricAttributionsAPIClient interface {
ListMetricAttributions(context.Context, *ListMetricAttributionsInput, ...func(*Options)) (*ListMetricAttributionsOutput, error)
}
var _ ListMetricAttributionsAPIClient = (*Client)(nil)
// ListMetricAttributionsPaginatorOptions is the paginator options for
// ListMetricAttributions
type ListMetricAttributionsPaginatorOptions struct {
// The maximum number of metric attributions to return in one page of results.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListMetricAttributionsPaginator is a paginator for ListMetricAttributions
type ListMetricAttributionsPaginator struct {
options ListMetricAttributionsPaginatorOptions
client ListMetricAttributionsAPIClient
params *ListMetricAttributionsInput
nextToken *string
firstPage bool
}
// NewListMetricAttributionsPaginator returns a new ListMetricAttributionsPaginator
func NewListMetricAttributionsPaginator(client ListMetricAttributionsAPIClient, params *ListMetricAttributionsInput, optFns ...func(*ListMetricAttributionsPaginatorOptions)) *ListMetricAttributionsPaginator {
if params == nil {
params = &ListMetricAttributionsInput{}
}
options := ListMetricAttributionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMetricAttributionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMetricAttributionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMetricAttributions page.
func (p *ListMetricAttributionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMetricAttributionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListMetricAttributions(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListMetricAttributions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListMetricAttributions",
}
}
| 223 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of available recipes. The response provides the properties for
// each recipe, including the recipe's Amazon Resource Name (ARN).
func (c *Client) ListRecipes(ctx context.Context, params *ListRecipesInput, optFns ...func(*Options)) (*ListRecipesOutput, error) {
if params == nil {
params = &ListRecipesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListRecipes", params, optFns, c.addOperationListRecipesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListRecipesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListRecipesInput struct {
// Filters returned recipes by domain for a Domain dataset group. Only recipes
// (Domain dataset group use cases) for this domain are included in the response.
// If you don't specify a domain, all recipes are returned.
Domain types.Domain
// The maximum number of recipes to return.
MaxResults *int32
// A token returned from the previous call to ListRecipes for getting the next set
// of recipes (if they exist).
NextToken *string
// The default is SERVICE .
RecipeProvider types.RecipeProvider
noSmithyDocumentSerde
}
type ListRecipesOutput struct {
// A token for getting the next set of recipes.
NextToken *string
// The list of available recipes.
Recipes []types.RecipeSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListRecipesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListRecipes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListRecipes{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListRecipes(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListRecipesAPIClient is a client that implements the ListRecipes operation.
type ListRecipesAPIClient interface {
ListRecipes(context.Context, *ListRecipesInput, ...func(*Options)) (*ListRecipesOutput, error)
}
var _ ListRecipesAPIClient = (*Client)(nil)
// ListRecipesPaginatorOptions is the paginator options for ListRecipes
type ListRecipesPaginatorOptions struct {
// The maximum number of recipes to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListRecipesPaginator is a paginator for ListRecipes
type ListRecipesPaginator struct {
options ListRecipesPaginatorOptions
client ListRecipesAPIClient
params *ListRecipesInput
nextToken *string
firstPage bool
}
// NewListRecipesPaginator returns a new ListRecipesPaginator
func NewListRecipesPaginator(client ListRecipesAPIClient, params *ListRecipesInput, optFns ...func(*ListRecipesPaginatorOptions)) *ListRecipesPaginator {
if params == nil {
params = &ListRecipesInput{}
}
options := ListRecipesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListRecipesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListRecipesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListRecipes page.
func (p *ListRecipesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRecipesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListRecipes(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListRecipes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListRecipes",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package personalize
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/personalize/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of recommenders in a given Domain dataset group. When a Domain
// dataset group is not specified, all the recommenders associated with the account
// are listed. The response provides the properties for each recommender, including
// the Amazon Resource Name (ARN). For more information on recommenders, see
// CreateRecommender (https://docs.aws.amazon.com/personalize/latest/dg/API_CreateRecommender.html)
// .
func (c *Client) ListRecommenders(ctx context.Context, params *ListRecommendersInput, optFns ...func(*Options)) (*ListRecommendersOutput, error) {
if params == nil {
params = &ListRecommendersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListRecommenders", params, optFns, c.addOperationListRecommendersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListRecommendersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListRecommendersInput struct {
// The Amazon Resource Name (ARN) of the Domain dataset group to list the
// recommenders for. When a Domain dataset group is not specified, all the
// recommenders associated with the account are listed.
DatasetGroupArn *string
// The maximum number of recommenders to return.
MaxResults *int32
// A token returned from the previous call to ListRecommenders for getting the
// next set of recommenders (if they exist).
NextToken *string
noSmithyDocumentSerde
}
type ListRecommendersOutput struct {
// A token for getting the next set of recommenders (if they exist).
NextToken *string
// A list of the recommenders.
Recommenders []types.RecommenderSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListRecommendersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListRecommenders{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListRecommenders{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListRecommenders(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// ListRecommendersAPIClient is a client that implements the ListRecommenders
// operation.
type ListRecommendersAPIClient interface {
ListRecommenders(context.Context, *ListRecommendersInput, ...func(*Options)) (*ListRecommendersOutput, error)
}
var _ ListRecommendersAPIClient = (*Client)(nil)
// ListRecommendersPaginatorOptions is the paginator options for ListRecommenders
type ListRecommendersPaginatorOptions struct {
// The maximum number of recommenders to return.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListRecommendersPaginator is a paginator for ListRecommenders
type ListRecommendersPaginator struct {
options ListRecommendersPaginatorOptions
client ListRecommendersAPIClient
params *ListRecommendersInput
nextToken *string
firstPage bool
}
// NewListRecommendersPaginator returns a new ListRecommendersPaginator
func NewListRecommendersPaginator(client ListRecommendersAPIClient, params *ListRecommendersInput, optFns ...func(*ListRecommendersPaginatorOptions)) *ListRecommendersPaginator {
if params == nil {
params = &ListRecommendersInput{}
}
options := ListRecommendersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListRecommendersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListRecommendersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListRecommenders page.
func (p *ListRecommendersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRecommendersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListRecommenders(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListRecommenders(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "personalize",
OperationName: "ListRecommenders",
}
}
| 228 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.