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 networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an attachment. Supports all attachment types.
func (c *Client) DeleteAttachment(ctx context.Context, params *DeleteAttachmentInput, optFns ...func(*Options)) (*DeleteAttachmentOutput, error) {
if params == nil {
params = &DeleteAttachmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAttachment", params, optFns, c.addOperationDeleteAttachmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAttachmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAttachmentInput struct {
// The ID of the attachment to delete.
//
// This member is required.
AttachmentId *string
noSmithyDocumentSerde
}
type DeleteAttachmentOutput struct {
// Information about the deleted attachment.
Attachment *types.Attachment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAttachmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteAttachment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteAttachment{}, 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 = addOpDeleteAttachmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAttachment(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_opDeleteAttachment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteAttachment",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified connection in your global network.
func (c *Client) DeleteConnection(ctx context.Context, params *DeleteConnectionInput, optFns ...func(*Options)) (*DeleteConnectionOutput, error) {
if params == nil {
params = &DeleteConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteConnection", params, optFns, c.addOperationDeleteConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteConnectionInput struct {
// The ID of the connection.
//
// This member is required.
ConnectionId *string
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
noSmithyDocumentSerde
}
type DeleteConnectionOutput struct {
// Information about the connection.
Connection *types.Connection
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteConnection{}, 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 = addOpDeleteConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteConnection(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_opDeleteConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteConnection",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a Connect peer.
func (c *Client) DeleteConnectPeer(ctx context.Context, params *DeleteConnectPeerInput, optFns ...func(*Options)) (*DeleteConnectPeerOutput, error) {
if params == nil {
params = &DeleteConnectPeerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteConnectPeer", params, optFns, c.addOperationDeleteConnectPeerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteConnectPeerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteConnectPeerInput struct {
// The ID of the deleted Connect peer.
//
// This member is required.
ConnectPeerId *string
noSmithyDocumentSerde
}
type DeleteConnectPeerOutput struct {
// Information about the deleted Connect peer.
ConnectPeer *types.ConnectPeer
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteConnectPeerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteConnectPeer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteConnectPeer{}, 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 = addOpDeleteConnectPeerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteConnectPeer(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_opDeleteConnectPeer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteConnectPeer",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a core network along with all core network policies. This can only be
// done if there are no attachments on a core network.
func (c *Client) DeleteCoreNetwork(ctx context.Context, params *DeleteCoreNetworkInput, optFns ...func(*Options)) (*DeleteCoreNetworkOutput, error) {
if params == nil {
params = &DeleteCoreNetworkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteCoreNetwork", params, optFns, c.addOperationDeleteCoreNetworkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteCoreNetworkOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteCoreNetworkInput struct {
// The network ID of the deleted core network.
//
// This member is required.
CoreNetworkId *string
noSmithyDocumentSerde
}
type DeleteCoreNetworkOutput struct {
// Information about the deleted core network.
CoreNetwork *types.CoreNetwork
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteCoreNetworkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteCoreNetwork{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteCoreNetwork{}, 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 = addOpDeleteCoreNetworkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCoreNetwork(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_opDeleteCoreNetwork(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteCoreNetwork",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a policy version from a core network. You can't delete the current LIVE
// policy.
func (c *Client) DeleteCoreNetworkPolicyVersion(ctx context.Context, params *DeleteCoreNetworkPolicyVersionInput, optFns ...func(*Options)) (*DeleteCoreNetworkPolicyVersionOutput, error) {
if params == nil {
params = &DeleteCoreNetworkPolicyVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteCoreNetworkPolicyVersion", params, optFns, c.addOperationDeleteCoreNetworkPolicyVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteCoreNetworkPolicyVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteCoreNetworkPolicyVersionInput struct {
// The ID of a core network for the deleted policy.
//
// This member is required.
CoreNetworkId *string
// The version ID of the deleted policy.
//
// This member is required.
PolicyVersionId *int32
noSmithyDocumentSerde
}
type DeleteCoreNetworkPolicyVersionOutput struct {
// Returns information about the deleted policy version.
CoreNetworkPolicy *types.CoreNetworkPolicy
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteCoreNetworkPolicyVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteCoreNetworkPolicyVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteCoreNetworkPolicyVersion{}, 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 = addOpDeleteCoreNetworkPolicyVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCoreNetworkPolicyVersion(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_opDeleteCoreNetworkPolicyVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteCoreNetworkPolicyVersion",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing device. You must first disassociate the device from any
// links and customer gateways.
func (c *Client) DeleteDevice(ctx context.Context, params *DeleteDeviceInput, optFns ...func(*Options)) (*DeleteDeviceOutput, error) {
if params == nil {
params = &DeleteDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDevice", params, optFns, c.addOperationDeleteDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDeviceInput struct {
// The ID of the device.
//
// This member is required.
DeviceId *string
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
noSmithyDocumentSerde
}
type DeleteDeviceOutput struct {
// Information about the device.
Device *types.Device
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDevice{}, 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 = addOpDeleteDeviceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDevice(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_opDeleteDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteDevice",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing global network. You must first delete all global network
// objects (devices, links, and sites), deregister all transit gateways, and delete
// any core networks.
func (c *Client) DeleteGlobalNetwork(ctx context.Context, params *DeleteGlobalNetworkInput, optFns ...func(*Options)) (*DeleteGlobalNetworkOutput, error) {
if params == nil {
params = &DeleteGlobalNetworkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteGlobalNetwork", params, optFns, c.addOperationDeleteGlobalNetworkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteGlobalNetworkOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteGlobalNetworkInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
noSmithyDocumentSerde
}
type DeleteGlobalNetworkOutput struct {
// Information about the global network.
GlobalNetwork *types.GlobalNetwork
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteGlobalNetworkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteGlobalNetwork{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteGlobalNetwork{}, 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 = addOpDeleteGlobalNetworkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteGlobalNetwork(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_opDeleteGlobalNetwork(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteGlobalNetwork",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing link. You must first disassociate the link from any devices
// and customer gateways.
func (c *Client) DeleteLink(ctx context.Context, params *DeleteLinkInput, optFns ...func(*Options)) (*DeleteLinkOutput, error) {
if params == nil {
params = &DeleteLinkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteLink", params, optFns, c.addOperationDeleteLinkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteLinkOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteLinkInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the link.
//
// This member is required.
LinkId *string
noSmithyDocumentSerde
}
type DeleteLinkOutput struct {
// Information about the link.
Link *types.Link
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteLinkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteLink{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteLink{}, 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 = addOpDeleteLinkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteLink(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_opDeleteLink(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteLink",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing peering connection.
func (c *Client) DeletePeering(ctx context.Context, params *DeletePeeringInput, optFns ...func(*Options)) (*DeletePeeringOutput, error) {
if params == nil {
params = &DeletePeeringInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeletePeering", params, optFns, c.addOperationDeletePeeringMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeletePeeringOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeletePeeringInput struct {
// The ID of the peering connection to delete.
//
// This member is required.
PeeringId *string
noSmithyDocumentSerde
}
type DeletePeeringOutput struct {
// Information about a deleted peering connection.
Peering *types.Peering
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeletePeeringMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeletePeering{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeletePeering{}, 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 = addOpDeletePeeringValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeletePeering(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_opDeletePeering(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeletePeering",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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 resource policy for the specified resource. This revokes the access
// of the principals specified in the resource policy.
func (c *Client) DeleteResourcePolicy(ctx context.Context, params *DeleteResourcePolicyInput, optFns ...func(*Options)) (*DeleteResourcePolicyOutput, error) {
if params == nil {
params = &DeleteResourcePolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteResourcePolicy", params, optFns, c.addOperationDeleteResourcePolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteResourcePolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteResourcePolicyInput struct {
// The ARN of the policy to delete.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type DeleteResourcePolicyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteResourcePolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteResourcePolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteResourcePolicy{}, 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 = addOpDeleteResourcePolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteResourcePolicy(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_opDeleteResourcePolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteResourcePolicy",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing site. The site cannot be associated with any device or link.
func (c *Client) DeleteSite(ctx context.Context, params *DeleteSiteInput, optFns ...func(*Options)) (*DeleteSiteOutput, error) {
if params == nil {
params = &DeleteSiteInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSite", params, optFns, c.addOperationDeleteSiteMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSiteOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSiteInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the site.
//
// This member is required.
SiteId *string
noSmithyDocumentSerde
}
type DeleteSiteOutput struct {
// Information about the site.
Site *types.Site
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSiteMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteSite{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteSite{}, 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 = addOpDeleteSiteValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSite(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_opDeleteSite(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeleteSite",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deregisters a transit gateway from your global network. This action does not
// delete your transit gateway, or modify any of its attachments. This action
// removes any customer gateway associations.
func (c *Client) DeregisterTransitGateway(ctx context.Context, params *DeregisterTransitGatewayInput, optFns ...func(*Options)) (*DeregisterTransitGatewayOutput, error) {
if params == nil {
params = &DeregisterTransitGatewayInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeregisterTransitGateway", params, optFns, c.addOperationDeregisterTransitGatewayMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeregisterTransitGatewayOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeregisterTransitGatewayInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The Amazon Resource Name (ARN) of the transit gateway.
//
// This member is required.
TransitGatewayArn *string
noSmithyDocumentSerde
}
type DeregisterTransitGatewayOutput struct {
// The transit gateway registration information.
TransitGatewayRegistration *types.TransitGatewayRegistration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeregisterTransitGatewayMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeregisterTransitGateway{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeregisterTransitGateway{}, 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 = addOpDeregisterTransitGatewayValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeregisterTransitGateway(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_opDeregisterTransitGateway(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DeregisterTransitGateway",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes one or more global networks. By default, all global networks are
// described. To describe the objects in your global network, you must use the
// appropriate Get* action. For example, to list the transit gateways in your
// global network, use GetTransitGatewayRegistrations .
func (c *Client) DescribeGlobalNetworks(ctx context.Context, params *DescribeGlobalNetworksInput, optFns ...func(*Options)) (*DescribeGlobalNetworksOutput, error) {
if params == nil {
params = &DescribeGlobalNetworksInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeGlobalNetworks", params, optFns, c.addOperationDescribeGlobalNetworksMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeGlobalNetworksOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeGlobalNetworksInput struct {
// The IDs of one or more global networks. The maximum is 10.
GlobalNetworkIds []string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type DescribeGlobalNetworksOutput struct {
// Information about the global networks.
GlobalNetworks []types.GlobalNetwork
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeGlobalNetworksMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeGlobalNetworks{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeGlobalNetworks{}, 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_opDescribeGlobalNetworks(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
}
// DescribeGlobalNetworksAPIClient is a client that implements the
// DescribeGlobalNetworks operation.
type DescribeGlobalNetworksAPIClient interface {
DescribeGlobalNetworks(context.Context, *DescribeGlobalNetworksInput, ...func(*Options)) (*DescribeGlobalNetworksOutput, error)
}
var _ DescribeGlobalNetworksAPIClient = (*Client)(nil)
// DescribeGlobalNetworksPaginatorOptions is the paginator options for
// DescribeGlobalNetworks
type DescribeGlobalNetworksPaginatorOptions struct {
// The maximum number of results 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
}
// DescribeGlobalNetworksPaginator is a paginator for DescribeGlobalNetworks
type DescribeGlobalNetworksPaginator struct {
options DescribeGlobalNetworksPaginatorOptions
client DescribeGlobalNetworksAPIClient
params *DescribeGlobalNetworksInput
nextToken *string
firstPage bool
}
// NewDescribeGlobalNetworksPaginator returns a new DescribeGlobalNetworksPaginator
func NewDescribeGlobalNetworksPaginator(client DescribeGlobalNetworksAPIClient, params *DescribeGlobalNetworksInput, optFns ...func(*DescribeGlobalNetworksPaginatorOptions)) *DescribeGlobalNetworksPaginator {
if params == nil {
params = &DescribeGlobalNetworksInput{}
}
options := DescribeGlobalNetworksPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeGlobalNetworksPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeGlobalNetworksPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeGlobalNetworks page.
func (p *DescribeGlobalNetworksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeGlobalNetworksOutput, 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.DescribeGlobalNetworks(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_opDescribeGlobalNetworks(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DescribeGlobalNetworks",
}
}
| 224 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disassociates a core network Connect peer from a device and a link.
func (c *Client) DisassociateConnectPeer(ctx context.Context, params *DisassociateConnectPeerInput, optFns ...func(*Options)) (*DisassociateConnectPeerOutput, error) {
if params == nil {
params = &DisassociateConnectPeerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateConnectPeer", params, optFns, c.addOperationDisassociateConnectPeerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateConnectPeerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateConnectPeerInput struct {
// The ID of the Connect peer to disassociate from a device.
//
// This member is required.
ConnectPeerId *string
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
noSmithyDocumentSerde
}
type DisassociateConnectPeerOutput struct {
// Describes the Connect peer association.
ConnectPeerAssociation *types.ConnectPeerAssociation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateConnectPeerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisassociateConnectPeer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisassociateConnectPeer{}, 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 = addOpDisassociateConnectPeerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateConnectPeer(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_opDisassociateConnectPeer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DisassociateConnectPeer",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disassociates a customer gateway from a device and a link.
func (c *Client) DisassociateCustomerGateway(ctx context.Context, params *DisassociateCustomerGatewayInput, optFns ...func(*Options)) (*DisassociateCustomerGatewayOutput, error) {
if params == nil {
params = &DisassociateCustomerGatewayInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateCustomerGateway", params, optFns, c.addOperationDisassociateCustomerGatewayMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateCustomerGatewayOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateCustomerGatewayInput struct {
// The Amazon Resource Name (ARN) of the customer gateway.
//
// This member is required.
CustomerGatewayArn *string
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
noSmithyDocumentSerde
}
type DisassociateCustomerGatewayOutput struct {
// Information about the customer gateway association.
CustomerGatewayAssociation *types.CustomerGatewayAssociation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateCustomerGatewayMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisassociateCustomerGateway{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisassociateCustomerGateway{}, 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 = addOpDisassociateCustomerGatewayValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateCustomerGateway(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_opDisassociateCustomerGateway(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DisassociateCustomerGateway",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disassociates an existing device from a link. You must first disassociate any
// customer gateways that are associated with the link.
func (c *Client) DisassociateLink(ctx context.Context, params *DisassociateLinkInput, optFns ...func(*Options)) (*DisassociateLinkOutput, error) {
if params == nil {
params = &DisassociateLinkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateLink", params, optFns, c.addOperationDisassociateLinkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateLinkOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateLinkInput struct {
// The ID of the device.
//
// This member is required.
DeviceId *string
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the link.
//
// This member is required.
LinkId *string
noSmithyDocumentSerde
}
type DisassociateLinkOutput struct {
// Information about the link association.
LinkAssociation *types.LinkAssociation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateLinkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisassociateLink{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisassociateLink{}, 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 = addOpDisassociateLinkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateLink(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_opDisassociateLink(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DisassociateLink",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disassociates a transit gateway Connect peer from a device and link.
func (c *Client) DisassociateTransitGatewayConnectPeer(ctx context.Context, params *DisassociateTransitGatewayConnectPeerInput, optFns ...func(*Options)) (*DisassociateTransitGatewayConnectPeerOutput, error) {
if params == nil {
params = &DisassociateTransitGatewayConnectPeerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateTransitGatewayConnectPeer", params, optFns, c.addOperationDisassociateTransitGatewayConnectPeerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateTransitGatewayConnectPeerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateTransitGatewayConnectPeerInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The Amazon Resource Name (ARN) of the transit gateway Connect peer.
//
// This member is required.
TransitGatewayConnectPeerArn *string
noSmithyDocumentSerde
}
type DisassociateTransitGatewayConnectPeerOutput struct {
// The transit gateway Connect peer association.
TransitGatewayConnectPeerAssociation *types.TransitGatewayConnectPeerAssociation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateTransitGatewayConnectPeerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisassociateTransitGatewayConnectPeer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisassociateTransitGatewayConnectPeer{}, 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 = addOpDisassociateTransitGatewayConnectPeerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateTransitGatewayConnectPeer(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_opDisassociateTransitGatewayConnectPeer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "DisassociateTransitGatewayConnectPeer",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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"
)
// Executes a change set on your core network. Deploys changes globally based on
// the policy submitted..
func (c *Client) ExecuteCoreNetworkChangeSet(ctx context.Context, params *ExecuteCoreNetworkChangeSetInput, optFns ...func(*Options)) (*ExecuteCoreNetworkChangeSetOutput, error) {
if params == nil {
params = &ExecuteCoreNetworkChangeSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ExecuteCoreNetworkChangeSet", params, optFns, c.addOperationExecuteCoreNetworkChangeSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ExecuteCoreNetworkChangeSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type ExecuteCoreNetworkChangeSetInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The ID of the policy version.
//
// This member is required.
PolicyVersionId *int32
noSmithyDocumentSerde
}
type ExecuteCoreNetworkChangeSetOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationExecuteCoreNetworkChangeSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpExecuteCoreNetworkChangeSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpExecuteCoreNetworkChangeSet{}, 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 = addOpExecuteCoreNetworkChangeSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opExecuteCoreNetworkChangeSet(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_opExecuteCoreNetworkChangeSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ExecuteCoreNetworkChangeSet",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a core network Connect attachment.
func (c *Client) GetConnectAttachment(ctx context.Context, params *GetConnectAttachmentInput, optFns ...func(*Options)) (*GetConnectAttachmentOutput, error) {
if params == nil {
params = &GetConnectAttachmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetConnectAttachment", params, optFns, c.addOperationGetConnectAttachmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetConnectAttachmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetConnectAttachmentInput struct {
// The ID of the attachment.
//
// This member is required.
AttachmentId *string
noSmithyDocumentSerde
}
type GetConnectAttachmentOutput struct {
// Details about the Connect attachment.
ConnectAttachment *types.ConnectAttachment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetConnectAttachmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetConnectAttachment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetConnectAttachment{}, 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 = addOpGetConnectAttachmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetConnectAttachment(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_opGetConnectAttachment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetConnectAttachment",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about one or more of your connections in a global network.
func (c *Client) GetConnections(ctx context.Context, params *GetConnectionsInput, optFns ...func(*Options)) (*GetConnectionsOutput, error) {
if params == nil {
params = &GetConnectionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetConnections", params, optFns, c.addOperationGetConnectionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetConnectionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetConnectionsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// One or more connection IDs.
ConnectionIds []string
// The ID of the device.
DeviceId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type GetConnectionsOutput struct {
// Information about the connections.
Connections []types.Connection
// The token to use for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetConnectionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetConnections{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetConnections{}, 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 = addOpGetConnectionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetConnections(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
}
// GetConnectionsAPIClient is a client that implements the GetConnections
// operation.
type GetConnectionsAPIClient interface {
GetConnections(context.Context, *GetConnectionsInput, ...func(*Options)) (*GetConnectionsOutput, error)
}
var _ GetConnectionsAPIClient = (*Client)(nil)
// GetConnectionsPaginatorOptions is the paginator options for GetConnections
type GetConnectionsPaginatorOptions struct {
// The maximum number of results 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
}
// GetConnectionsPaginator is a paginator for GetConnections
type GetConnectionsPaginator struct {
options GetConnectionsPaginatorOptions
client GetConnectionsAPIClient
params *GetConnectionsInput
nextToken *string
firstPage bool
}
// NewGetConnectionsPaginator returns a new GetConnectionsPaginator
func NewGetConnectionsPaginator(client GetConnectionsAPIClient, params *GetConnectionsInput, optFns ...func(*GetConnectionsPaginatorOptions)) *GetConnectionsPaginator {
if params == nil {
params = &GetConnectionsInput{}
}
options := GetConnectionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetConnectionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetConnectionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetConnections page.
func (p *GetConnectionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetConnectionsOutput, 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.GetConnections(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_opGetConnections(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetConnections",
}
}
| 231 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a core network Connect peer.
func (c *Client) GetConnectPeer(ctx context.Context, params *GetConnectPeerInput, optFns ...func(*Options)) (*GetConnectPeerOutput, error) {
if params == nil {
params = &GetConnectPeerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetConnectPeer", params, optFns, c.addOperationGetConnectPeerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetConnectPeerOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetConnectPeerInput struct {
// The ID of the Connect peer.
//
// This member is required.
ConnectPeerId *string
noSmithyDocumentSerde
}
type GetConnectPeerOutput struct {
// Returns information about a core network Connect peer.
ConnectPeer *types.ConnectPeer
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetConnectPeerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetConnectPeer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetConnectPeer{}, 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 = addOpGetConnectPeerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetConnectPeer(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_opGetConnectPeer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetConnectPeer",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a core network Connect peer associations.
func (c *Client) GetConnectPeerAssociations(ctx context.Context, params *GetConnectPeerAssociationsInput, optFns ...func(*Options)) (*GetConnectPeerAssociationsOutput, error) {
if params == nil {
params = &GetConnectPeerAssociationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetConnectPeerAssociations", params, optFns, c.addOperationGetConnectPeerAssociationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetConnectPeerAssociationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetConnectPeerAssociationsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The IDs of the Connect peers.
ConnectPeerIds []string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type GetConnectPeerAssociationsOutput struct {
// Displays a list of Connect peer associations.
ConnectPeerAssociations []types.ConnectPeerAssociation
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetConnectPeerAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetConnectPeerAssociations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetConnectPeerAssociations{}, 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 = addOpGetConnectPeerAssociationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetConnectPeerAssociations(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
}
// GetConnectPeerAssociationsAPIClient is a client that implements the
// GetConnectPeerAssociations operation.
type GetConnectPeerAssociationsAPIClient interface {
GetConnectPeerAssociations(context.Context, *GetConnectPeerAssociationsInput, ...func(*Options)) (*GetConnectPeerAssociationsOutput, error)
}
var _ GetConnectPeerAssociationsAPIClient = (*Client)(nil)
// GetConnectPeerAssociationsPaginatorOptions is the paginator options for
// GetConnectPeerAssociations
type GetConnectPeerAssociationsPaginatorOptions struct {
// The maximum number of results 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
}
// GetConnectPeerAssociationsPaginator is a paginator for
// GetConnectPeerAssociations
type GetConnectPeerAssociationsPaginator struct {
options GetConnectPeerAssociationsPaginatorOptions
client GetConnectPeerAssociationsAPIClient
params *GetConnectPeerAssociationsInput
nextToken *string
firstPage bool
}
// NewGetConnectPeerAssociationsPaginator returns a new
// GetConnectPeerAssociationsPaginator
func NewGetConnectPeerAssociationsPaginator(client GetConnectPeerAssociationsAPIClient, params *GetConnectPeerAssociationsInput, optFns ...func(*GetConnectPeerAssociationsPaginatorOptions)) *GetConnectPeerAssociationsPaginator {
if params == nil {
params = &GetConnectPeerAssociationsInput{}
}
options := GetConnectPeerAssociationsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetConnectPeerAssociationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetConnectPeerAssociationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetConnectPeerAssociations page.
func (p *GetConnectPeerAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetConnectPeerAssociationsOutput, 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.GetConnectPeerAssociations(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_opGetConnectPeerAssociations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetConnectPeerAssociations",
}
}
| 231 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the LIVE policy for a core network.
func (c *Client) GetCoreNetwork(ctx context.Context, params *GetCoreNetworkInput, optFns ...func(*Options)) (*GetCoreNetworkOutput, error) {
if params == nil {
params = &GetCoreNetworkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetCoreNetwork", params, optFns, c.addOperationGetCoreNetworkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetCoreNetworkOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetCoreNetworkInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
noSmithyDocumentSerde
}
type GetCoreNetworkOutput struct {
// Details about a core network.
CoreNetwork *types.CoreNetwork
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetCoreNetworkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetCoreNetwork{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetCoreNetwork{}, 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 = addOpGetCoreNetworkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCoreNetwork(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_opGetCoreNetwork(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetCoreNetwork",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a core network change event.
func (c *Client) GetCoreNetworkChangeEvents(ctx context.Context, params *GetCoreNetworkChangeEventsInput, optFns ...func(*Options)) (*GetCoreNetworkChangeEventsOutput, error) {
if params == nil {
params = &GetCoreNetworkChangeEventsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetCoreNetworkChangeEvents", params, optFns, c.addOperationGetCoreNetworkChangeEventsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetCoreNetworkChangeEventsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetCoreNetworkChangeEventsInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The ID of the policy version.
//
// This member is required.
PolicyVersionId *int32
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type GetCoreNetworkChangeEventsOutput struct {
// The response to GetCoreNetworkChangeEventsRequest .
CoreNetworkChangeEvents []types.CoreNetworkChangeEvent
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetCoreNetworkChangeEventsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetCoreNetworkChangeEvents{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetCoreNetworkChangeEvents{}, 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 = addOpGetCoreNetworkChangeEventsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCoreNetworkChangeEvents(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
}
// GetCoreNetworkChangeEventsAPIClient is a client that implements the
// GetCoreNetworkChangeEvents operation.
type GetCoreNetworkChangeEventsAPIClient interface {
GetCoreNetworkChangeEvents(context.Context, *GetCoreNetworkChangeEventsInput, ...func(*Options)) (*GetCoreNetworkChangeEventsOutput, error)
}
var _ GetCoreNetworkChangeEventsAPIClient = (*Client)(nil)
// GetCoreNetworkChangeEventsPaginatorOptions is the paginator options for
// GetCoreNetworkChangeEvents
type GetCoreNetworkChangeEventsPaginatorOptions struct {
// The maximum number of results 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
}
// GetCoreNetworkChangeEventsPaginator is a paginator for
// GetCoreNetworkChangeEvents
type GetCoreNetworkChangeEventsPaginator struct {
options GetCoreNetworkChangeEventsPaginatorOptions
client GetCoreNetworkChangeEventsAPIClient
params *GetCoreNetworkChangeEventsInput
nextToken *string
firstPage bool
}
// NewGetCoreNetworkChangeEventsPaginator returns a new
// GetCoreNetworkChangeEventsPaginator
func NewGetCoreNetworkChangeEventsPaginator(client GetCoreNetworkChangeEventsAPIClient, params *GetCoreNetworkChangeEventsInput, optFns ...func(*GetCoreNetworkChangeEventsPaginatorOptions)) *GetCoreNetworkChangeEventsPaginator {
if params == nil {
params = &GetCoreNetworkChangeEventsInput{}
}
options := GetCoreNetworkChangeEventsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetCoreNetworkChangeEventsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetCoreNetworkChangeEventsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetCoreNetworkChangeEvents page.
func (p *GetCoreNetworkChangeEventsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetCoreNetworkChangeEventsOutput, 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.GetCoreNetworkChangeEvents(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_opGetCoreNetworkChangeEvents(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetCoreNetworkChangeEvents",
}
}
| 233 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a change set between the LIVE core network policy and a submitted
// policy.
func (c *Client) GetCoreNetworkChangeSet(ctx context.Context, params *GetCoreNetworkChangeSetInput, optFns ...func(*Options)) (*GetCoreNetworkChangeSetOutput, error) {
if params == nil {
params = &GetCoreNetworkChangeSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetCoreNetworkChangeSet", params, optFns, c.addOperationGetCoreNetworkChangeSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetCoreNetworkChangeSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetCoreNetworkChangeSetInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The ID of the policy version.
//
// This member is required.
PolicyVersionId *int32
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type GetCoreNetworkChangeSetOutput struct {
// Describes a core network changes.
CoreNetworkChanges []types.CoreNetworkChange
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetCoreNetworkChangeSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetCoreNetworkChangeSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetCoreNetworkChangeSet{}, 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 = addOpGetCoreNetworkChangeSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCoreNetworkChangeSet(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
}
// GetCoreNetworkChangeSetAPIClient is a client that implements the
// GetCoreNetworkChangeSet operation.
type GetCoreNetworkChangeSetAPIClient interface {
GetCoreNetworkChangeSet(context.Context, *GetCoreNetworkChangeSetInput, ...func(*Options)) (*GetCoreNetworkChangeSetOutput, error)
}
var _ GetCoreNetworkChangeSetAPIClient = (*Client)(nil)
// GetCoreNetworkChangeSetPaginatorOptions is the paginator options for
// GetCoreNetworkChangeSet
type GetCoreNetworkChangeSetPaginatorOptions struct {
// The maximum number of results 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
}
// GetCoreNetworkChangeSetPaginator is a paginator for GetCoreNetworkChangeSet
type GetCoreNetworkChangeSetPaginator struct {
options GetCoreNetworkChangeSetPaginatorOptions
client GetCoreNetworkChangeSetAPIClient
params *GetCoreNetworkChangeSetInput
nextToken *string
firstPage bool
}
// NewGetCoreNetworkChangeSetPaginator returns a new
// GetCoreNetworkChangeSetPaginator
func NewGetCoreNetworkChangeSetPaginator(client GetCoreNetworkChangeSetAPIClient, params *GetCoreNetworkChangeSetInput, optFns ...func(*GetCoreNetworkChangeSetPaginatorOptions)) *GetCoreNetworkChangeSetPaginator {
if params == nil {
params = &GetCoreNetworkChangeSetInput{}
}
options := GetCoreNetworkChangeSetPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetCoreNetworkChangeSetPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetCoreNetworkChangeSetPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetCoreNetworkChangeSet page.
func (p *GetCoreNetworkChangeSetPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetCoreNetworkChangeSetOutput, 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.GetCoreNetworkChangeSet(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_opGetCoreNetworkChangeSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetCoreNetworkChangeSet",
}
}
| 233 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns details about a core network policy. You can get details about your
// current live policy or any previous policy version.
func (c *Client) GetCoreNetworkPolicy(ctx context.Context, params *GetCoreNetworkPolicyInput, optFns ...func(*Options)) (*GetCoreNetworkPolicyOutput, error) {
if params == nil {
params = &GetCoreNetworkPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetCoreNetworkPolicy", params, optFns, c.addOperationGetCoreNetworkPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetCoreNetworkPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetCoreNetworkPolicyInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The alias of a core network policy
Alias types.CoreNetworkPolicyAlias
// The ID of a core network policy version.
PolicyVersionId *int32
noSmithyDocumentSerde
}
type GetCoreNetworkPolicyOutput struct {
// The details about a core network policy.
CoreNetworkPolicy *types.CoreNetworkPolicy
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetCoreNetworkPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetCoreNetworkPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetCoreNetworkPolicy{}, 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 = addOpGetCoreNetworkPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCoreNetworkPolicy(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_opGetCoreNetworkPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetCoreNetworkPolicy",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the association information for customer gateways that are associated with
// devices and links in your global network.
func (c *Client) GetCustomerGatewayAssociations(ctx context.Context, params *GetCustomerGatewayAssociationsInput, optFns ...func(*Options)) (*GetCustomerGatewayAssociationsOutput, error) {
if params == nil {
params = &GetCustomerGatewayAssociationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetCustomerGatewayAssociations", params, optFns, c.addOperationGetCustomerGatewayAssociationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetCustomerGatewayAssociationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetCustomerGatewayAssociationsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// One or more customer gateway Amazon Resource Names (ARNs). The maximum is 10.
CustomerGatewayArns []string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type GetCustomerGatewayAssociationsOutput struct {
// The customer gateway associations.
CustomerGatewayAssociations []types.CustomerGatewayAssociation
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetCustomerGatewayAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetCustomerGatewayAssociations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetCustomerGatewayAssociations{}, 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 = addOpGetCustomerGatewayAssociationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetCustomerGatewayAssociations(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
}
// GetCustomerGatewayAssociationsAPIClient is a client that implements the
// GetCustomerGatewayAssociations operation.
type GetCustomerGatewayAssociationsAPIClient interface {
GetCustomerGatewayAssociations(context.Context, *GetCustomerGatewayAssociationsInput, ...func(*Options)) (*GetCustomerGatewayAssociationsOutput, error)
}
var _ GetCustomerGatewayAssociationsAPIClient = (*Client)(nil)
// GetCustomerGatewayAssociationsPaginatorOptions is the paginator options for
// GetCustomerGatewayAssociations
type GetCustomerGatewayAssociationsPaginatorOptions struct {
// The maximum number of results 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
}
// GetCustomerGatewayAssociationsPaginator is a paginator for
// GetCustomerGatewayAssociations
type GetCustomerGatewayAssociationsPaginator struct {
options GetCustomerGatewayAssociationsPaginatorOptions
client GetCustomerGatewayAssociationsAPIClient
params *GetCustomerGatewayAssociationsInput
nextToken *string
firstPage bool
}
// NewGetCustomerGatewayAssociationsPaginator returns a new
// GetCustomerGatewayAssociationsPaginator
func NewGetCustomerGatewayAssociationsPaginator(client GetCustomerGatewayAssociationsAPIClient, params *GetCustomerGatewayAssociationsInput, optFns ...func(*GetCustomerGatewayAssociationsPaginatorOptions)) *GetCustomerGatewayAssociationsPaginator {
if params == nil {
params = &GetCustomerGatewayAssociationsInput{}
}
options := GetCustomerGatewayAssociationsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetCustomerGatewayAssociationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetCustomerGatewayAssociationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetCustomerGatewayAssociations page.
func (p *GetCustomerGatewayAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetCustomerGatewayAssociationsOutput, 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.GetCustomerGatewayAssociations(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_opGetCustomerGatewayAssociations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetCustomerGatewayAssociations",
}
}
| 232 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about one or more of your devices in a global network.
func (c *Client) GetDevices(ctx context.Context, params *GetDevicesInput, optFns ...func(*Options)) (*GetDevicesOutput, error) {
if params == nil {
params = &GetDevicesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDevices", params, optFns, c.addOperationGetDevicesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDevicesOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDevicesInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// One or more device IDs. The maximum is 10.
DeviceIds []string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The ID of the site.
SiteId *string
noSmithyDocumentSerde
}
type GetDevicesOutput struct {
// The devices.
Devices []types.Device
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDevicesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDevices{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDevices{}, 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 = addOpGetDevicesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDevices(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
}
// GetDevicesAPIClient is a client that implements the GetDevices operation.
type GetDevicesAPIClient interface {
GetDevices(context.Context, *GetDevicesInput, ...func(*Options)) (*GetDevicesOutput, error)
}
var _ GetDevicesAPIClient = (*Client)(nil)
// GetDevicesPaginatorOptions is the paginator options for GetDevices
type GetDevicesPaginatorOptions struct {
// The maximum number of results 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
}
// GetDevicesPaginator is a paginator for GetDevices
type GetDevicesPaginator struct {
options GetDevicesPaginatorOptions
client GetDevicesAPIClient
params *GetDevicesInput
nextToken *string
firstPage bool
}
// NewGetDevicesPaginator returns a new GetDevicesPaginator
func NewGetDevicesPaginator(client GetDevicesAPIClient, params *GetDevicesInput, optFns ...func(*GetDevicesPaginatorOptions)) *GetDevicesPaginator {
if params == nil {
params = &GetDevicesInput{}
}
options := GetDevicesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetDevicesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetDevicesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetDevices page.
func (p *GetDevicesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetDevicesOutput, 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.GetDevices(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_opGetDevices(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetDevices",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the link associations for a device or a link. Either the device ID or the
// link ID must be specified.
func (c *Client) GetLinkAssociations(ctx context.Context, params *GetLinkAssociationsInput, optFns ...func(*Options)) (*GetLinkAssociationsOutput, error) {
if params == nil {
params = &GetLinkAssociationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLinkAssociations", params, optFns, c.addOperationGetLinkAssociationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLinkAssociationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLinkAssociationsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the device.
DeviceId *string
// The ID of the link.
LinkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type GetLinkAssociationsOutput struct {
// The link associations.
LinkAssociations []types.LinkAssociation
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLinkAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLinkAssociations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLinkAssociations{}, 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 = addOpGetLinkAssociationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLinkAssociations(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
}
// GetLinkAssociationsAPIClient is a client that implements the
// GetLinkAssociations operation.
type GetLinkAssociationsAPIClient interface {
GetLinkAssociations(context.Context, *GetLinkAssociationsInput, ...func(*Options)) (*GetLinkAssociationsOutput, error)
}
var _ GetLinkAssociationsAPIClient = (*Client)(nil)
// GetLinkAssociationsPaginatorOptions is the paginator options for
// GetLinkAssociations
type GetLinkAssociationsPaginatorOptions struct {
// The maximum number of results 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
}
// GetLinkAssociationsPaginator is a paginator for GetLinkAssociations
type GetLinkAssociationsPaginator struct {
options GetLinkAssociationsPaginatorOptions
client GetLinkAssociationsAPIClient
params *GetLinkAssociationsInput
nextToken *string
firstPage bool
}
// NewGetLinkAssociationsPaginator returns a new GetLinkAssociationsPaginator
func NewGetLinkAssociationsPaginator(client GetLinkAssociationsAPIClient, params *GetLinkAssociationsInput, optFns ...func(*GetLinkAssociationsPaginatorOptions)) *GetLinkAssociationsPaginator {
if params == nil {
params = &GetLinkAssociationsInput{}
}
options := GetLinkAssociationsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetLinkAssociationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetLinkAssociationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetLinkAssociations page.
func (p *GetLinkAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetLinkAssociationsOutput, 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.GetLinkAssociations(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_opGetLinkAssociations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetLinkAssociations",
}
}
| 233 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about one or more links in a specified global network. If you
// specify the site ID, you cannot specify the type or provider in the same
// request. You can specify the type and provider in the same request.
func (c *Client) GetLinks(ctx context.Context, params *GetLinksInput, optFns ...func(*Options)) (*GetLinksOutput, error) {
if params == nil {
params = &GetLinksInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLinks", params, optFns, c.addOperationGetLinksMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLinksOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLinksInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// One or more link IDs. The maximum is 10.
LinkIds []string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The link provider.
Provider *string
// The ID of the site.
SiteId *string
// The link type.
Type *string
noSmithyDocumentSerde
}
type GetLinksOutput struct {
// The links.
Links []types.Link
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLinksMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLinks{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLinks{}, 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 = addOpGetLinksValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLinks(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
}
// GetLinksAPIClient is a client that implements the GetLinks operation.
type GetLinksAPIClient interface {
GetLinks(context.Context, *GetLinksInput, ...func(*Options)) (*GetLinksOutput, error)
}
var _ GetLinksAPIClient = (*Client)(nil)
// GetLinksPaginatorOptions is the paginator options for GetLinks
type GetLinksPaginatorOptions struct {
// The maximum number of results 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
}
// GetLinksPaginator is a paginator for GetLinks
type GetLinksPaginator struct {
options GetLinksPaginatorOptions
client GetLinksAPIClient
params *GetLinksInput
nextToken *string
firstPage bool
}
// NewGetLinksPaginator returns a new GetLinksPaginator
func NewGetLinksPaginator(client GetLinksAPIClient, params *GetLinksInput, optFns ...func(*GetLinksPaginatorOptions)) *GetLinksPaginator {
if params == nil {
params = &GetLinksInput{}
}
options := GetLinksPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetLinksPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetLinksPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetLinks page.
func (p *GetLinksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetLinksOutput, 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.GetLinks(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_opGetLinks(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetLinks",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the count of network resources, by resource type, for the specified global
// network.
func (c *Client) GetNetworkResourceCounts(ctx context.Context, params *GetNetworkResourceCountsInput, optFns ...func(*Options)) (*GetNetworkResourceCountsOutput, error) {
if params == nil {
params = &GetNetworkResourceCountsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetNetworkResourceCounts", params, optFns, c.addOperationGetNetworkResourceCountsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetNetworkResourceCountsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetNetworkResourceCountsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The resource type. The following are the supported resource types for Direct
// Connect:
// - dxcon
// - dx-gateway
// - dx-vif
// The following are the supported resource types for Network Manager:
// - connection
// - device
// - link
// - site
// The following are the supported resource types for Amazon VPC:
// - customer-gateway
// - transit-gateway
// - transit-gateway-attachment
// - transit-gateway-connect-peer
// - transit-gateway-route-table
// - vpn-connection
ResourceType *string
noSmithyDocumentSerde
}
type GetNetworkResourceCountsOutput struct {
// The count of resources.
NetworkResourceCounts []types.NetworkResourceCount
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetNetworkResourceCountsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetNetworkResourceCounts{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetNetworkResourceCounts{}, 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 = addOpGetNetworkResourceCountsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetNetworkResourceCounts(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
}
// GetNetworkResourceCountsAPIClient is a client that implements the
// GetNetworkResourceCounts operation.
type GetNetworkResourceCountsAPIClient interface {
GetNetworkResourceCounts(context.Context, *GetNetworkResourceCountsInput, ...func(*Options)) (*GetNetworkResourceCountsOutput, error)
}
var _ GetNetworkResourceCountsAPIClient = (*Client)(nil)
// GetNetworkResourceCountsPaginatorOptions is the paginator options for
// GetNetworkResourceCounts
type GetNetworkResourceCountsPaginatorOptions struct {
// The maximum number of results 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
}
// GetNetworkResourceCountsPaginator is a paginator for GetNetworkResourceCounts
type GetNetworkResourceCountsPaginator struct {
options GetNetworkResourceCountsPaginatorOptions
client GetNetworkResourceCountsAPIClient
params *GetNetworkResourceCountsInput
nextToken *string
firstPage bool
}
// NewGetNetworkResourceCountsPaginator returns a new
// GetNetworkResourceCountsPaginator
func NewGetNetworkResourceCountsPaginator(client GetNetworkResourceCountsAPIClient, params *GetNetworkResourceCountsInput, optFns ...func(*GetNetworkResourceCountsPaginatorOptions)) *GetNetworkResourceCountsPaginator {
if params == nil {
params = &GetNetworkResourceCountsInput{}
}
options := GetNetworkResourceCountsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetNetworkResourceCountsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetNetworkResourceCountsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetNetworkResourceCounts page.
func (p *GetNetworkResourceCountsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetNetworkResourceCountsOutput, 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.GetNetworkResourceCounts(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_opGetNetworkResourceCounts(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetNetworkResourceCounts",
}
}
| 247 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the network resource relationships for the specified global network.
func (c *Client) GetNetworkResourceRelationships(ctx context.Context, params *GetNetworkResourceRelationshipsInput, optFns ...func(*Options)) (*GetNetworkResourceRelationshipsOutput, error) {
if params == nil {
params = &GetNetworkResourceRelationshipsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetNetworkResourceRelationships", params, optFns, c.addOperationGetNetworkResourceRelationshipsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetNetworkResourceRelationshipsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetNetworkResourceRelationshipsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The Amazon Web Services account ID.
AccountId *string
// The Amazon Web Services Region.
AwsRegion *string
// The ID of a core network.
CoreNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The ARN of the registered gateway.
RegisteredGatewayArn *string
// The ARN of the gateway.
ResourceArn *string
// The resource type. The following are the supported resource types for Direct
// Connect:
// - dxcon
// - dx-gateway
// - dx-vif
// The following are the supported resource types for Network Manager:
// - connection
// - device
// - link
// - site
// The following are the supported resource types for Amazon VPC:
// - customer-gateway
// - transit-gateway
// - transit-gateway-attachment
// - transit-gateway-connect-peer
// - transit-gateway-route-table
// - vpn-connection
ResourceType *string
noSmithyDocumentSerde
}
type GetNetworkResourceRelationshipsOutput struct {
// The token for the next page of results.
NextToken *string
// The resource relationships.
Relationships []types.Relationship
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetNetworkResourceRelationshipsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetNetworkResourceRelationships{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetNetworkResourceRelationships{}, 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 = addOpGetNetworkResourceRelationshipsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetNetworkResourceRelationships(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
}
// GetNetworkResourceRelationshipsAPIClient is a client that implements the
// GetNetworkResourceRelationships operation.
type GetNetworkResourceRelationshipsAPIClient interface {
GetNetworkResourceRelationships(context.Context, *GetNetworkResourceRelationshipsInput, ...func(*Options)) (*GetNetworkResourceRelationshipsOutput, error)
}
var _ GetNetworkResourceRelationshipsAPIClient = (*Client)(nil)
// GetNetworkResourceRelationshipsPaginatorOptions is the paginator options for
// GetNetworkResourceRelationships
type GetNetworkResourceRelationshipsPaginatorOptions struct {
// The maximum number of results 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
}
// GetNetworkResourceRelationshipsPaginator is a paginator for
// GetNetworkResourceRelationships
type GetNetworkResourceRelationshipsPaginator struct {
options GetNetworkResourceRelationshipsPaginatorOptions
client GetNetworkResourceRelationshipsAPIClient
params *GetNetworkResourceRelationshipsInput
nextToken *string
firstPage bool
}
// NewGetNetworkResourceRelationshipsPaginator returns a new
// GetNetworkResourceRelationshipsPaginator
func NewGetNetworkResourceRelationshipsPaginator(client GetNetworkResourceRelationshipsAPIClient, params *GetNetworkResourceRelationshipsInput, optFns ...func(*GetNetworkResourceRelationshipsPaginatorOptions)) *GetNetworkResourceRelationshipsPaginator {
if params == nil {
params = &GetNetworkResourceRelationshipsInput{}
}
options := GetNetworkResourceRelationshipsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetNetworkResourceRelationshipsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetNetworkResourceRelationshipsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetNetworkResourceRelationships page.
func (p *GetNetworkResourceRelationshipsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetNetworkResourceRelationshipsOutput, 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.GetNetworkResourceRelationships(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_opGetNetworkResourceRelationships(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetNetworkResourceRelationships",
}
}
| 262 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes the network resources for the specified global network. The results
// include information from the corresponding Describe call for the resource, minus
// any sensitive information such as pre-shared keys.
func (c *Client) GetNetworkResources(ctx context.Context, params *GetNetworkResourcesInput, optFns ...func(*Options)) (*GetNetworkResourcesOutput, error) {
if params == nil {
params = &GetNetworkResourcesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetNetworkResources", params, optFns, c.addOperationGetNetworkResourcesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetNetworkResourcesOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetNetworkResourcesInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The Amazon Web Services account ID.
AccountId *string
// The Amazon Web Services Region.
AwsRegion *string
// The ID of a core network.
CoreNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The ARN of the gateway.
RegisteredGatewayArn *string
// The ARN of the resource.
ResourceArn *string
// The resource type. The following are the supported resource types for Direct
// Connect:
// - dxcon - The definition model is Connection (https://docs.aws.amazon.com/directconnect/latest/APIReference/API_Connection.html)
// .
// - dx-gateway - The definition model is DirectConnectGateway (https://docs.aws.amazon.com/directconnect/latest/APIReference/API_DirectConnectGateway.html)
// .
// - dx-vif - The definition model is VirtualInterface (https://docs.aws.amazon.com/directconnect/latest/APIReference/API_VirtualInterface.html)
// .
// The following are the supported resource types for Network Manager:
// - connection - The definition model is Connection (https://docs.aws.amazon.com/networkmanager/latest/APIReference/API_Connection.html)
// .
// - device - The definition model is Device (https://docs.aws.amazon.com/networkmanager/latest/APIReference/API_Device.html)
// .
// - link - The definition model is Link (https://docs.aws.amazon.com/networkmanager/latest/APIReference/API_Link.html)
// .
// - site - The definition model is Site (https://docs.aws.amazon.com/networkmanager/latest/APIReference/API_Site.html)
// .
// The following are the supported resource types for Amazon VPC:
// - customer-gateway - The definition model is CustomerGateway (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CustomerGateway.html)
// .
// - transit-gateway - The definition model is TransitGateway (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_TransitGateway.html)
// .
// - transit-gateway-attachment - The definition model is
// TransitGatewayAttachment (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_TransitGatewayAttachment.html)
// .
// - transit-gateway-connect-peer - The definition model is
// TransitGatewayConnectPeer (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_TransitGatewayConnectPeer.html)
// .
// - transit-gateway-route-table - The definition model is
// TransitGatewayRouteTable (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_TransitGatewayRouteTable.html)
// .
// - vpn-connection - The definition model is VpnConnection (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_VpnConnection.html)
// .
ResourceType *string
noSmithyDocumentSerde
}
type GetNetworkResourcesOutput struct {
// The network resources.
NetworkResources []types.NetworkResource
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetNetworkResourcesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetNetworkResources{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetNetworkResources{}, 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 = addOpGetNetworkResourcesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetNetworkResources(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
}
// GetNetworkResourcesAPIClient is a client that implements the
// GetNetworkResources operation.
type GetNetworkResourcesAPIClient interface {
GetNetworkResources(context.Context, *GetNetworkResourcesInput, ...func(*Options)) (*GetNetworkResourcesOutput, error)
}
var _ GetNetworkResourcesAPIClient = (*Client)(nil)
// GetNetworkResourcesPaginatorOptions is the paginator options for
// GetNetworkResources
type GetNetworkResourcesPaginatorOptions struct {
// The maximum number of results 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
}
// GetNetworkResourcesPaginator is a paginator for GetNetworkResources
type GetNetworkResourcesPaginator struct {
options GetNetworkResourcesPaginatorOptions
client GetNetworkResourcesAPIClient
params *GetNetworkResourcesInput
nextToken *string
firstPage bool
}
// NewGetNetworkResourcesPaginator returns a new GetNetworkResourcesPaginator
func NewGetNetworkResourcesPaginator(client GetNetworkResourcesAPIClient, params *GetNetworkResourcesInput, optFns ...func(*GetNetworkResourcesPaginatorOptions)) *GetNetworkResourcesPaginator {
if params == nil {
params = &GetNetworkResourcesInput{}
}
options := GetNetworkResourcesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetNetworkResourcesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetNetworkResourcesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetNetworkResources page.
func (p *GetNetworkResourcesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetNetworkResourcesOutput, 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.GetNetworkResources(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_opGetNetworkResources(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetNetworkResources",
}
}
| 278 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets the network routes of the specified global network.
func (c *Client) GetNetworkRoutes(ctx context.Context, params *GetNetworkRoutesInput, optFns ...func(*Options)) (*GetNetworkRoutesOutput, error) {
if params == nil {
params = &GetNetworkRoutesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetNetworkRoutes", params, optFns, c.addOperationGetNetworkRoutesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetNetworkRoutesOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetNetworkRoutesInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the route table.
//
// This member is required.
RouteTableIdentifier *types.RouteTableIdentifier
// Filter by route table destination. Possible Values:
// TRANSIT_GATEWAY_ATTACHMENT_ID, RESOURCE_ID, or RESOURCE_TYPE.
DestinationFilters map[string][]string
// An exact CIDR block.
ExactCidrMatches []string
// The most specific route that matches the traffic (longest prefix match).
LongestPrefixMatches []string
// The IDs of the prefix lists.
PrefixListIds []string
// The route states.
States []types.RouteState
// The routes with a subnet that match the specified CIDR filter.
SubnetOfMatches []string
// The routes with a CIDR that encompasses the CIDR filter. Example: If you
// specify 10.0.1.0/30, then the result returns 10.0.1.0/29.
SupernetOfMatches []string
// The route types.
Types []types.RouteType
noSmithyDocumentSerde
}
type GetNetworkRoutesOutput struct {
// Describes a core network segment edge.
CoreNetworkSegmentEdge *types.CoreNetworkSegmentEdgeIdentifier
// The network routes.
NetworkRoutes []types.NetworkRoute
// The ARN of the route table.
RouteTableArn *string
// The route table creation time.
RouteTableTimestamp *time.Time
// The route table type.
RouteTableType types.RouteTableType
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetNetworkRoutesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetNetworkRoutes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetNetworkRoutes{}, 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 = addOpGetNetworkRoutesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetNetworkRoutes(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_opGetNetworkRoutes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetNetworkRoutes",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the network telemetry of the specified global network.
func (c *Client) GetNetworkTelemetry(ctx context.Context, params *GetNetworkTelemetryInput, optFns ...func(*Options)) (*GetNetworkTelemetryOutput, error) {
if params == nil {
params = &GetNetworkTelemetryInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetNetworkTelemetry", params, optFns, c.addOperationGetNetworkTelemetryMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetNetworkTelemetryOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetNetworkTelemetryInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The Amazon Web Services account ID.
AccountId *string
// The Amazon Web Services Region.
AwsRegion *string
// The ID of a core network.
CoreNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The ARN of the gateway.
RegisteredGatewayArn *string
// The ARN of the resource.
ResourceArn *string
// The resource type. The following are the supported resource types for Direct
// Connect:
// - dxcon
// - dx-gateway
// - dx-vif
// The following are the supported resource types for Network Manager:
// - connection
// - device
// - link
// - site
// The following are the supported resource types for Amazon VPC:
// - customer-gateway
// - transit-gateway
// - transit-gateway-attachment
// - transit-gateway-connect-peer
// - transit-gateway-route-table
// - vpn-connection
ResourceType *string
noSmithyDocumentSerde
}
type GetNetworkTelemetryOutput struct {
// The network telemetry.
NetworkTelemetry []types.NetworkTelemetry
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetNetworkTelemetryMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetNetworkTelemetry{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetNetworkTelemetry{}, 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 = addOpGetNetworkTelemetryValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetNetworkTelemetry(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
}
// GetNetworkTelemetryAPIClient is a client that implements the
// GetNetworkTelemetry operation.
type GetNetworkTelemetryAPIClient interface {
GetNetworkTelemetry(context.Context, *GetNetworkTelemetryInput, ...func(*Options)) (*GetNetworkTelemetryOutput, error)
}
var _ GetNetworkTelemetryAPIClient = (*Client)(nil)
// GetNetworkTelemetryPaginatorOptions is the paginator options for
// GetNetworkTelemetry
type GetNetworkTelemetryPaginatorOptions struct {
// The maximum number of results 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
}
// GetNetworkTelemetryPaginator is a paginator for GetNetworkTelemetry
type GetNetworkTelemetryPaginator struct {
options GetNetworkTelemetryPaginatorOptions
client GetNetworkTelemetryAPIClient
params *GetNetworkTelemetryInput
nextToken *string
firstPage bool
}
// NewGetNetworkTelemetryPaginator returns a new GetNetworkTelemetryPaginator
func NewGetNetworkTelemetryPaginator(client GetNetworkTelemetryAPIClient, params *GetNetworkTelemetryInput, optFns ...func(*GetNetworkTelemetryPaginatorOptions)) *GetNetworkTelemetryPaginator {
if params == nil {
params = &GetNetworkTelemetryInput{}
}
options := GetNetworkTelemetryPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetNetworkTelemetryPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetNetworkTelemetryPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetNetworkTelemetry page.
func (p *GetNetworkTelemetryPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetNetworkTelemetryOutput, 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.GetNetworkTelemetry(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_opGetNetworkTelemetry(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetNetworkTelemetry",
}
}
| 260 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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"
)
// Returns information about a resource policy.
func (c *Client) GetResourcePolicy(ctx context.Context, params *GetResourcePolicyInput, optFns ...func(*Options)) (*GetResourcePolicyOutput, error) {
if params == nil {
params = &GetResourcePolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetResourcePolicy", params, optFns, c.addOperationGetResourcePolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetResourcePolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetResourcePolicyInput struct {
// The ARN of the resource.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type GetResourcePolicyOutput struct {
// The resource policy document.
//
// This value conforms to the media type: application/json
PolicyDocument *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetResourcePolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetResourcePolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetResourcePolicy{}, 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 = addOpGetResourcePolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetResourcePolicy(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_opGetResourcePolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetResourcePolicy",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about the specified route analysis.
func (c *Client) GetRouteAnalysis(ctx context.Context, params *GetRouteAnalysisInput, optFns ...func(*Options)) (*GetRouteAnalysisOutput, error) {
if params == nil {
params = &GetRouteAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRouteAnalysis", params, optFns, c.addOperationGetRouteAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRouteAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRouteAnalysisInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the route analysis.
//
// This member is required.
RouteAnalysisId *string
noSmithyDocumentSerde
}
type GetRouteAnalysisOutput struct {
// The route analysis.
RouteAnalysis *types.RouteAnalysis
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRouteAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRouteAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRouteAnalysis{}, 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 = addOpGetRouteAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRouteAnalysis(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_opGetRouteAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetRouteAnalysis",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about one or more of your sites in a global network.
func (c *Client) GetSites(ctx context.Context, params *GetSitesInput, optFns ...func(*Options)) (*GetSitesOutput, error) {
if params == nil {
params = &GetSitesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSites", params, optFns, c.addOperationGetSitesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSitesOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSitesInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// One or more site IDs. The maximum is 10.
SiteIds []string
noSmithyDocumentSerde
}
type GetSitesOutput struct {
// The token for the next page of results.
NextToken *string
// The sites.
Sites []types.Site
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSitesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSites{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSites{}, 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 = addOpGetSitesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSites(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
}
// GetSitesAPIClient is a client that implements the GetSites operation.
type GetSitesAPIClient interface {
GetSites(context.Context, *GetSitesInput, ...func(*Options)) (*GetSitesOutput, error)
}
var _ GetSitesAPIClient = (*Client)(nil)
// GetSitesPaginatorOptions is the paginator options for GetSites
type GetSitesPaginatorOptions struct {
// The maximum number of results 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
}
// GetSitesPaginator is a paginator for GetSites
type GetSitesPaginator struct {
options GetSitesPaginatorOptions
client GetSitesAPIClient
params *GetSitesInput
nextToken *string
firstPage bool
}
// NewGetSitesPaginator returns a new GetSitesPaginator
func NewGetSitesPaginator(client GetSitesAPIClient, params *GetSitesInput, optFns ...func(*GetSitesPaginatorOptions)) *GetSitesPaginator {
if params == nil {
params = &GetSitesInput{}
}
options := GetSitesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetSitesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetSitesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetSites page.
func (p *GetSitesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetSitesOutput, 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.GetSites(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_opGetSites(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetSites",
}
}
| 227 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a site-to-site VPN attachment.
func (c *Client) GetSiteToSiteVpnAttachment(ctx context.Context, params *GetSiteToSiteVpnAttachmentInput, optFns ...func(*Options)) (*GetSiteToSiteVpnAttachmentOutput, error) {
if params == nil {
params = &GetSiteToSiteVpnAttachmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSiteToSiteVpnAttachment", params, optFns, c.addOperationGetSiteToSiteVpnAttachmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSiteToSiteVpnAttachmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSiteToSiteVpnAttachmentInput struct {
// The ID of the attachment.
//
// This member is required.
AttachmentId *string
noSmithyDocumentSerde
}
type GetSiteToSiteVpnAttachmentOutput struct {
// Describes the site-to-site attachment.
SiteToSiteVpnAttachment *types.SiteToSiteVpnAttachment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSiteToSiteVpnAttachmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSiteToSiteVpnAttachment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSiteToSiteVpnAttachment{}, 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 = addOpGetSiteToSiteVpnAttachmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSiteToSiteVpnAttachment(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_opGetSiteToSiteVpnAttachment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetSiteToSiteVpnAttachment",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about one or more of your transit gateway Connect peer
// associations in a global network.
func (c *Client) GetTransitGatewayConnectPeerAssociations(ctx context.Context, params *GetTransitGatewayConnectPeerAssociationsInput, optFns ...func(*Options)) (*GetTransitGatewayConnectPeerAssociationsOutput, error) {
if params == nil {
params = &GetTransitGatewayConnectPeerAssociationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTransitGatewayConnectPeerAssociations", params, optFns, c.addOperationGetTransitGatewayConnectPeerAssociationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTransitGatewayConnectPeerAssociationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTransitGatewayConnectPeerAssociationsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// One or more transit gateway Connect peer Amazon Resource Names (ARNs).
TransitGatewayConnectPeerArns []string
noSmithyDocumentSerde
}
type GetTransitGatewayConnectPeerAssociationsOutput struct {
// The token to use for the next page of results.
NextToken *string
// Information about the transit gateway Connect peer associations.
TransitGatewayConnectPeerAssociations []types.TransitGatewayConnectPeerAssociation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTransitGatewayConnectPeerAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTransitGatewayConnectPeerAssociations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTransitGatewayConnectPeerAssociations{}, 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 = addOpGetTransitGatewayConnectPeerAssociationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTransitGatewayConnectPeerAssociations(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
}
// GetTransitGatewayConnectPeerAssociationsAPIClient is a client that implements
// the GetTransitGatewayConnectPeerAssociations operation.
type GetTransitGatewayConnectPeerAssociationsAPIClient interface {
GetTransitGatewayConnectPeerAssociations(context.Context, *GetTransitGatewayConnectPeerAssociationsInput, ...func(*Options)) (*GetTransitGatewayConnectPeerAssociationsOutput, error)
}
var _ GetTransitGatewayConnectPeerAssociationsAPIClient = (*Client)(nil)
// GetTransitGatewayConnectPeerAssociationsPaginatorOptions is the paginator
// options for GetTransitGatewayConnectPeerAssociations
type GetTransitGatewayConnectPeerAssociationsPaginatorOptions struct {
// The maximum number of results 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
}
// GetTransitGatewayConnectPeerAssociationsPaginator is a paginator for
// GetTransitGatewayConnectPeerAssociations
type GetTransitGatewayConnectPeerAssociationsPaginator struct {
options GetTransitGatewayConnectPeerAssociationsPaginatorOptions
client GetTransitGatewayConnectPeerAssociationsAPIClient
params *GetTransitGatewayConnectPeerAssociationsInput
nextToken *string
firstPage bool
}
// NewGetTransitGatewayConnectPeerAssociationsPaginator returns a new
// GetTransitGatewayConnectPeerAssociationsPaginator
func NewGetTransitGatewayConnectPeerAssociationsPaginator(client GetTransitGatewayConnectPeerAssociationsAPIClient, params *GetTransitGatewayConnectPeerAssociationsInput, optFns ...func(*GetTransitGatewayConnectPeerAssociationsPaginatorOptions)) *GetTransitGatewayConnectPeerAssociationsPaginator {
if params == nil {
params = &GetTransitGatewayConnectPeerAssociationsInput{}
}
options := GetTransitGatewayConnectPeerAssociationsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetTransitGatewayConnectPeerAssociationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetTransitGatewayConnectPeerAssociationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetTransitGatewayConnectPeerAssociations page.
func (p *GetTransitGatewayConnectPeerAssociationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetTransitGatewayConnectPeerAssociationsOutput, 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.GetTransitGatewayConnectPeerAssociations(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_opGetTransitGatewayConnectPeerAssociations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetTransitGatewayConnectPeerAssociations",
}
}
| 232 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a transit gateway peer.
func (c *Client) GetTransitGatewayPeering(ctx context.Context, params *GetTransitGatewayPeeringInput, optFns ...func(*Options)) (*GetTransitGatewayPeeringOutput, error) {
if params == nil {
params = &GetTransitGatewayPeeringInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTransitGatewayPeering", params, optFns, c.addOperationGetTransitGatewayPeeringMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTransitGatewayPeeringOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTransitGatewayPeeringInput struct {
// The ID of the peering request.
//
// This member is required.
PeeringId *string
noSmithyDocumentSerde
}
type GetTransitGatewayPeeringOutput struct {
// Returns information about a transit gateway peering.
TransitGatewayPeering *types.TransitGatewayPeering
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTransitGatewayPeeringMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTransitGatewayPeering{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTransitGatewayPeering{}, 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 = addOpGetTransitGatewayPeeringValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTransitGatewayPeering(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_opGetTransitGatewayPeering(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetTransitGatewayPeering",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about the transit gateway registrations in a specified global
// network.
func (c *Client) GetTransitGatewayRegistrations(ctx context.Context, params *GetTransitGatewayRegistrationsInput, optFns ...func(*Options)) (*GetTransitGatewayRegistrationsOutput, error) {
if params == nil {
params = &GetTransitGatewayRegistrationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTransitGatewayRegistrations", params, optFns, c.addOperationGetTransitGatewayRegistrationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTransitGatewayRegistrationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTransitGatewayRegistrationsInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The Amazon Resource Names (ARNs) of one or more transit gateways. The maximum
// is 10.
TransitGatewayArns []string
noSmithyDocumentSerde
}
type GetTransitGatewayRegistrationsOutput struct {
// The token for the next page of results.
NextToken *string
// The transit gateway registrations.
TransitGatewayRegistrations []types.TransitGatewayRegistration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTransitGatewayRegistrationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTransitGatewayRegistrations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTransitGatewayRegistrations{}, 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 = addOpGetTransitGatewayRegistrationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTransitGatewayRegistrations(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
}
// GetTransitGatewayRegistrationsAPIClient is a client that implements the
// GetTransitGatewayRegistrations operation.
type GetTransitGatewayRegistrationsAPIClient interface {
GetTransitGatewayRegistrations(context.Context, *GetTransitGatewayRegistrationsInput, ...func(*Options)) (*GetTransitGatewayRegistrationsOutput, error)
}
var _ GetTransitGatewayRegistrationsAPIClient = (*Client)(nil)
// GetTransitGatewayRegistrationsPaginatorOptions is the paginator options for
// GetTransitGatewayRegistrations
type GetTransitGatewayRegistrationsPaginatorOptions struct {
// The maximum number of results 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
}
// GetTransitGatewayRegistrationsPaginator is a paginator for
// GetTransitGatewayRegistrations
type GetTransitGatewayRegistrationsPaginator struct {
options GetTransitGatewayRegistrationsPaginatorOptions
client GetTransitGatewayRegistrationsAPIClient
params *GetTransitGatewayRegistrationsInput
nextToken *string
firstPage bool
}
// NewGetTransitGatewayRegistrationsPaginator returns a new
// GetTransitGatewayRegistrationsPaginator
func NewGetTransitGatewayRegistrationsPaginator(client GetTransitGatewayRegistrationsAPIClient, params *GetTransitGatewayRegistrationsInput, optFns ...func(*GetTransitGatewayRegistrationsPaginatorOptions)) *GetTransitGatewayRegistrationsPaginator {
if params == nil {
params = &GetTransitGatewayRegistrationsInput{}
}
options := GetTransitGatewayRegistrationsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &GetTransitGatewayRegistrationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *GetTransitGatewayRegistrationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next GetTransitGatewayRegistrations page.
func (p *GetTransitGatewayRegistrationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetTransitGatewayRegistrationsOutput, 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.GetTransitGatewayRegistrations(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_opGetTransitGatewayRegistrations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetTransitGatewayRegistrations",
}
}
| 233 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a transit gateway route table attachment.
func (c *Client) GetTransitGatewayRouteTableAttachment(ctx context.Context, params *GetTransitGatewayRouteTableAttachmentInput, optFns ...func(*Options)) (*GetTransitGatewayRouteTableAttachmentOutput, error) {
if params == nil {
params = &GetTransitGatewayRouteTableAttachmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTransitGatewayRouteTableAttachment", params, optFns, c.addOperationGetTransitGatewayRouteTableAttachmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTransitGatewayRouteTableAttachmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTransitGatewayRouteTableAttachmentInput struct {
// The ID of the transit gateway route table attachment.
//
// This member is required.
AttachmentId *string
noSmithyDocumentSerde
}
type GetTransitGatewayRouteTableAttachmentOutput struct {
// Returns information about the transit gateway route table attachment.
TransitGatewayRouteTableAttachment *types.TransitGatewayRouteTableAttachment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTransitGatewayRouteTableAttachmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTransitGatewayRouteTableAttachment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTransitGatewayRouteTableAttachment{}, 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 = addOpGetTransitGatewayRouteTableAttachmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTransitGatewayRouteTableAttachment(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_opGetTransitGatewayRouteTableAttachment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetTransitGatewayRouteTableAttachment",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about a VPC attachment.
func (c *Client) GetVpcAttachment(ctx context.Context, params *GetVpcAttachmentInput, optFns ...func(*Options)) (*GetVpcAttachmentOutput, error) {
if params == nil {
params = &GetVpcAttachmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetVpcAttachment", params, optFns, c.addOperationGetVpcAttachmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetVpcAttachmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetVpcAttachmentInput struct {
// The ID of the attachment.
//
// This member is required.
AttachmentId *string
noSmithyDocumentSerde
}
type GetVpcAttachmentOutput struct {
// Returns details about a VPC attachment.
VpcAttachment *types.VpcAttachment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetVpcAttachmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetVpcAttachment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetVpcAttachment{}, 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 = addOpGetVpcAttachmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetVpcAttachment(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_opGetVpcAttachment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "GetVpcAttachment",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of core network attachments.
func (c *Client) ListAttachments(ctx context.Context, params *ListAttachmentsInput, optFns ...func(*Options)) (*ListAttachmentsOutput, error) {
if params == nil {
params = &ListAttachmentsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAttachments", params, optFns, c.addOperationListAttachmentsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAttachmentsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAttachmentsInput struct {
// The type of attachment.
AttachmentType types.AttachmentType
// The ID of a core network.
CoreNetworkId *string
// The Region where the edge is located.
EdgeLocation *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The state of the attachment.
State types.AttachmentState
noSmithyDocumentSerde
}
type ListAttachmentsOutput struct {
// Describes the list of attachments.
Attachments []types.Attachment
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAttachmentsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAttachments{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAttachments{}, 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_opListAttachments(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
}
// ListAttachmentsAPIClient is a client that implements the ListAttachments
// operation.
type ListAttachmentsAPIClient interface {
ListAttachments(context.Context, *ListAttachmentsInput, ...func(*Options)) (*ListAttachmentsOutput, error)
}
var _ ListAttachmentsAPIClient = (*Client)(nil)
// ListAttachmentsPaginatorOptions is the paginator options for ListAttachments
type ListAttachmentsPaginatorOptions struct {
// The maximum number of results 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
}
// ListAttachmentsPaginator is a paginator for ListAttachments
type ListAttachmentsPaginator struct {
options ListAttachmentsPaginatorOptions
client ListAttachmentsAPIClient
params *ListAttachmentsInput
nextToken *string
firstPage bool
}
// NewListAttachmentsPaginator returns a new ListAttachmentsPaginator
func NewListAttachmentsPaginator(client ListAttachmentsAPIClient, params *ListAttachmentsInput, optFns ...func(*ListAttachmentsPaginatorOptions)) *ListAttachmentsPaginator {
if params == nil {
params = &ListAttachmentsInput{}
}
options := ListAttachmentsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAttachmentsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAttachmentsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAttachments page.
func (p *ListAttachmentsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAttachmentsOutput, 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.ListAttachments(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_opListAttachments(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ListAttachments",
}
}
| 229 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of core network Connect peers.
func (c *Client) ListConnectPeers(ctx context.Context, params *ListConnectPeersInput, optFns ...func(*Options)) (*ListConnectPeersOutput, error) {
if params == nil {
params = &ListConnectPeersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListConnectPeers", params, optFns, c.addOperationListConnectPeersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListConnectPeersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListConnectPeersInput struct {
// The ID of the attachment.
ConnectAttachmentId *string
// The ID of a core network.
CoreNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type ListConnectPeersOutput struct {
// Describes the Connect peers.
ConnectPeers []types.ConnectPeerSummary
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListConnectPeersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListConnectPeers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListConnectPeers{}, 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_opListConnectPeers(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
}
// ListConnectPeersAPIClient is a client that implements the ListConnectPeers
// operation.
type ListConnectPeersAPIClient interface {
ListConnectPeers(context.Context, *ListConnectPeersInput, ...func(*Options)) (*ListConnectPeersOutput, error)
}
var _ ListConnectPeersAPIClient = (*Client)(nil)
// ListConnectPeersPaginatorOptions is the paginator options for ListConnectPeers
type ListConnectPeersPaginatorOptions struct {
// The maximum number of results 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
}
// ListConnectPeersPaginator is a paginator for ListConnectPeers
type ListConnectPeersPaginator struct {
options ListConnectPeersPaginatorOptions
client ListConnectPeersAPIClient
params *ListConnectPeersInput
nextToken *string
firstPage bool
}
// NewListConnectPeersPaginator returns a new ListConnectPeersPaginator
func NewListConnectPeersPaginator(client ListConnectPeersAPIClient, params *ListConnectPeersInput, optFns ...func(*ListConnectPeersPaginatorOptions)) *ListConnectPeersPaginator {
if params == nil {
params = &ListConnectPeersInput{}
}
options := ListConnectPeersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListConnectPeersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListConnectPeersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListConnectPeers page.
func (p *ListConnectPeersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListConnectPeersOutput, 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.ListConnectPeers(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_opListConnectPeers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ListConnectPeers",
}
}
| 223 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of core network policy versions.
func (c *Client) ListCoreNetworkPolicyVersions(ctx context.Context, params *ListCoreNetworkPolicyVersionsInput, optFns ...func(*Options)) (*ListCoreNetworkPolicyVersionsOutput, error) {
if params == nil {
params = &ListCoreNetworkPolicyVersionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCoreNetworkPolicyVersions", params, optFns, c.addOperationListCoreNetworkPolicyVersionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListCoreNetworkPolicyVersionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListCoreNetworkPolicyVersionsInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type ListCoreNetworkPolicyVersionsOutput struct {
// Describes core network policy versions.
CoreNetworkPolicyVersions []types.CoreNetworkPolicyVersion
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListCoreNetworkPolicyVersionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListCoreNetworkPolicyVersions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListCoreNetworkPolicyVersions{}, 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 = addOpListCoreNetworkPolicyVersionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCoreNetworkPolicyVersions(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
}
// ListCoreNetworkPolicyVersionsAPIClient is a client that implements the
// ListCoreNetworkPolicyVersions operation.
type ListCoreNetworkPolicyVersionsAPIClient interface {
ListCoreNetworkPolicyVersions(context.Context, *ListCoreNetworkPolicyVersionsInput, ...func(*Options)) (*ListCoreNetworkPolicyVersionsOutput, error)
}
var _ ListCoreNetworkPolicyVersionsAPIClient = (*Client)(nil)
// ListCoreNetworkPolicyVersionsPaginatorOptions is the paginator options for
// ListCoreNetworkPolicyVersions
type ListCoreNetworkPolicyVersionsPaginatorOptions struct {
// The maximum number of results 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
}
// ListCoreNetworkPolicyVersionsPaginator is a paginator for
// ListCoreNetworkPolicyVersions
type ListCoreNetworkPolicyVersionsPaginator struct {
options ListCoreNetworkPolicyVersionsPaginatorOptions
client ListCoreNetworkPolicyVersionsAPIClient
params *ListCoreNetworkPolicyVersionsInput
nextToken *string
firstPage bool
}
// NewListCoreNetworkPolicyVersionsPaginator returns a new
// ListCoreNetworkPolicyVersionsPaginator
func NewListCoreNetworkPolicyVersionsPaginator(client ListCoreNetworkPolicyVersionsAPIClient, params *ListCoreNetworkPolicyVersionsInput, optFns ...func(*ListCoreNetworkPolicyVersionsPaginatorOptions)) *ListCoreNetworkPolicyVersionsPaginator {
if params == nil {
params = &ListCoreNetworkPolicyVersionsInput{}
}
options := ListCoreNetworkPolicyVersionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListCoreNetworkPolicyVersionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListCoreNetworkPolicyVersionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListCoreNetworkPolicyVersions page.
func (p *ListCoreNetworkPolicyVersionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCoreNetworkPolicyVersionsOutput, 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.ListCoreNetworkPolicyVersions(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_opListCoreNetworkPolicyVersions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ListCoreNetworkPolicyVersions",
}
}
| 228 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of owned and shared core networks.
func (c *Client) ListCoreNetworks(ctx context.Context, params *ListCoreNetworksInput, optFns ...func(*Options)) (*ListCoreNetworksOutput, error) {
if params == nil {
params = &ListCoreNetworksInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCoreNetworks", params, optFns, c.addOperationListCoreNetworksMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListCoreNetworksOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListCoreNetworksInput struct {
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type ListCoreNetworksOutput struct {
// Describes the list of core networks.
CoreNetworks []types.CoreNetworkSummary
// The token for the next page of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListCoreNetworksMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListCoreNetworks{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListCoreNetworks{}, 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_opListCoreNetworks(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
}
// ListCoreNetworksAPIClient is a client that implements the ListCoreNetworks
// operation.
type ListCoreNetworksAPIClient interface {
ListCoreNetworks(context.Context, *ListCoreNetworksInput, ...func(*Options)) (*ListCoreNetworksOutput, error)
}
var _ ListCoreNetworksAPIClient = (*Client)(nil)
// ListCoreNetworksPaginatorOptions is the paginator options for ListCoreNetworks
type ListCoreNetworksPaginatorOptions struct {
// The maximum number of results 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
}
// ListCoreNetworksPaginator is a paginator for ListCoreNetworks
type ListCoreNetworksPaginator struct {
options ListCoreNetworksPaginatorOptions
client ListCoreNetworksAPIClient
params *ListCoreNetworksInput
nextToken *string
firstPage bool
}
// NewListCoreNetworksPaginator returns a new ListCoreNetworksPaginator
func NewListCoreNetworksPaginator(client ListCoreNetworksAPIClient, params *ListCoreNetworksInput, optFns ...func(*ListCoreNetworksPaginatorOptions)) *ListCoreNetworksPaginator {
if params == nil {
params = &ListCoreNetworksInput{}
}
options := ListCoreNetworksPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListCoreNetworksPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListCoreNetworksPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListCoreNetworks page.
func (p *ListCoreNetworksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCoreNetworksOutput, 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.ListCoreNetworks(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_opListCoreNetworks(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ListCoreNetworks",
}
}
| 217 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the status of the Service Linked Role (SLR) deployment for the accounts in
// a given Amazon Web Services Organization.
func (c *Client) ListOrganizationServiceAccessStatus(ctx context.Context, params *ListOrganizationServiceAccessStatusInput, optFns ...func(*Options)) (*ListOrganizationServiceAccessStatusOutput, error) {
if params == nil {
params = &ListOrganizationServiceAccessStatusInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListOrganizationServiceAccessStatus", params, optFns, c.addOperationListOrganizationServiceAccessStatusMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListOrganizationServiceAccessStatusOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListOrganizationServiceAccessStatusInput struct {
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
noSmithyDocumentSerde
}
type ListOrganizationServiceAccessStatusOutput struct {
// The token for the next page of results.
NextToken *string
// Displays the status of an Amazon Web Services Organization.
OrganizationStatus *types.OrganizationStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListOrganizationServiceAccessStatusMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListOrganizationServiceAccessStatus{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListOrganizationServiceAccessStatus{}, 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_opListOrganizationServiceAccessStatus(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_opListOrganizationServiceAccessStatus(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ListOrganizationServiceAccessStatus",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the peerings for a core network.
func (c *Client) ListPeerings(ctx context.Context, params *ListPeeringsInput, optFns ...func(*Options)) (*ListPeeringsOutput, error) {
if params == nil {
params = &ListPeeringsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListPeerings", params, optFns, c.addOperationListPeeringsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListPeeringsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListPeeringsInput struct {
// The ID of a core network.
CoreNetworkId *string
// Returns a list edge locations for the
EdgeLocation *string
// The maximum number of results to return.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// Returns a list of a peering requests.
PeeringType types.PeeringType
// Returns a list of the peering request states.
State types.PeeringState
noSmithyDocumentSerde
}
type ListPeeringsOutput struct {
// The token for the next page of results.
NextToken *string
// Lists the transit gateway peerings for the ListPeerings request.
Peerings []types.Peering
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListPeeringsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListPeerings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListPeerings{}, 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_opListPeerings(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
}
// ListPeeringsAPIClient is a client that implements the ListPeerings operation.
type ListPeeringsAPIClient interface {
ListPeerings(context.Context, *ListPeeringsInput, ...func(*Options)) (*ListPeeringsOutput, error)
}
var _ ListPeeringsAPIClient = (*Client)(nil)
// ListPeeringsPaginatorOptions is the paginator options for ListPeerings
type ListPeeringsPaginatorOptions struct {
// The maximum number of results 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
}
// ListPeeringsPaginator is a paginator for ListPeerings
type ListPeeringsPaginator struct {
options ListPeeringsPaginatorOptions
client ListPeeringsAPIClient
params *ListPeeringsInput
nextToken *string
firstPage bool
}
// NewListPeeringsPaginator returns a new ListPeeringsPaginator
func NewListPeeringsPaginator(client ListPeeringsAPIClient, params *ListPeeringsInput, optFns ...func(*ListPeeringsPaginatorOptions)) *ListPeeringsPaginator {
if params == nil {
params = &ListPeeringsInput{}
}
options := ListPeeringsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListPeeringsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListPeeringsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListPeerings page.
func (p *ListPeeringsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPeeringsOutput, 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.ListPeerings(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_opListPeerings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ListPeerings",
}
}
| 228 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the tags for a specified resource.
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 Amazon Resource Name (ARN) of the resource.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The list of tags.
TagList []types.Tag
// 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(&awsRestjson1_serializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_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
}
func newServiceMetadataMiddleware_opListTagsForResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "ListTagsForResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new, immutable version of a core network policy. A subsequent change
// set is created showing the differences between the LIVE policy and the submitted
// policy.
func (c *Client) PutCoreNetworkPolicy(ctx context.Context, params *PutCoreNetworkPolicyInput, optFns ...func(*Options)) (*PutCoreNetworkPolicyOutput, error) {
if params == nil {
params = &PutCoreNetworkPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutCoreNetworkPolicy", params, optFns, c.addOperationPutCoreNetworkPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutCoreNetworkPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutCoreNetworkPolicyInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The policy document.
//
// This value conforms to the media type: application/json
//
// This member is required.
PolicyDocument *string
// The client token associated with the request.
ClientToken *string
// a core network policy description.
Description *string
// The ID of a core network policy.
LatestVersionId *int32
noSmithyDocumentSerde
}
type PutCoreNetworkPolicyOutput struct {
// Describes the changed core network policy.
CoreNetworkPolicy *types.CoreNetworkPolicy
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutCoreNetworkPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutCoreNetworkPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutCoreNetworkPolicy{}, 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 = addIdempotencyToken_opPutCoreNetworkPolicyMiddleware(stack, options); err != nil {
return err
}
if err = addOpPutCoreNetworkPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutCoreNetworkPolicy(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
}
type idempotencyToken_initializeOpPutCoreNetworkPolicy struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpPutCoreNetworkPolicy) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpPutCoreNetworkPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*PutCoreNetworkPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *PutCoreNetworkPolicyInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opPutCoreNetworkPolicyMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpPutCoreNetworkPolicy{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opPutCoreNetworkPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "PutCoreNetworkPolicy",
}
}
| 180 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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"
)
// Creates or updates a resource policy.
func (c *Client) PutResourcePolicy(ctx context.Context, params *PutResourcePolicyInput, optFns ...func(*Options)) (*PutResourcePolicyOutput, error) {
if params == nil {
params = &PutResourcePolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutResourcePolicy", params, optFns, c.addOperationPutResourcePolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutResourcePolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutResourcePolicyInput struct {
// The JSON resource policy document.
//
// This value conforms to the media type: application/json
//
// This member is required.
PolicyDocument *string
// The ARN of the resource policy.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type PutResourcePolicyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutResourcePolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutResourcePolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutResourcePolicy{}, 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 = addOpPutResourcePolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutResourcePolicy(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_opPutResourcePolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "PutResourcePolicy",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Registers a transit gateway in your global network. Not all Regions support
// transit gateways for global networks. For a list of the supported Regions, see
// Region Availability (https://docs.aws.amazon.com/network-manager/latest/tgwnm/what-are-global-networks.html#nm-available-regions)
// in the Amazon Web Services Transit Gateways for Global Networks User Guide. The
// transit gateway can be in any of the supported Amazon Web Services Regions, but
// it must be owned by the same Amazon Web Services account that owns the global
// network. You cannot register a transit gateway in more than one global network.
func (c *Client) RegisterTransitGateway(ctx context.Context, params *RegisterTransitGatewayInput, optFns ...func(*Options)) (*RegisterTransitGatewayOutput, error) {
if params == nil {
params = &RegisterTransitGatewayInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RegisterTransitGateway", params, optFns, c.addOperationRegisterTransitGatewayMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RegisterTransitGatewayOutput)
out.ResultMetadata = metadata
return out, nil
}
type RegisterTransitGatewayInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The Amazon Resource Name (ARN) of the transit gateway.
//
// This member is required.
TransitGatewayArn *string
noSmithyDocumentSerde
}
type RegisterTransitGatewayOutput struct {
// Information about the transit gateway registration.
TransitGatewayRegistration *types.TransitGatewayRegistration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRegisterTransitGatewayMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpRegisterTransitGateway{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpRegisterTransitGateway{}, 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 = addOpRegisterTransitGatewayValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRegisterTransitGateway(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_opRegisterTransitGateway(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "RegisterTransitGateway",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Rejects a core network attachment request.
func (c *Client) RejectAttachment(ctx context.Context, params *RejectAttachmentInput, optFns ...func(*Options)) (*RejectAttachmentOutput, error) {
if params == nil {
params = &RejectAttachmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RejectAttachment", params, optFns, c.addOperationRejectAttachmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RejectAttachmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type RejectAttachmentInput struct {
// The ID of the attachment.
//
// This member is required.
AttachmentId *string
noSmithyDocumentSerde
}
type RejectAttachmentOutput struct {
// Describes the rejected attachment request.
Attachment *types.Attachment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRejectAttachmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpRejectAttachment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpRejectAttachment{}, 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 = addOpRejectAttachmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRejectAttachment(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_opRejectAttachment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "RejectAttachment",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Restores a previous policy version as a new, immutable version of a core
// network policy. A subsequent change set is created showing the differences
// between the LIVE policy and restored policy.
func (c *Client) RestoreCoreNetworkPolicyVersion(ctx context.Context, params *RestoreCoreNetworkPolicyVersionInput, optFns ...func(*Options)) (*RestoreCoreNetworkPolicyVersionOutput, error) {
if params == nil {
params = &RestoreCoreNetworkPolicyVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "RestoreCoreNetworkPolicyVersion", params, optFns, c.addOperationRestoreCoreNetworkPolicyVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*RestoreCoreNetworkPolicyVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type RestoreCoreNetworkPolicyVersionInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The ID of the policy version to restore.
//
// This member is required.
PolicyVersionId *int32
noSmithyDocumentSerde
}
type RestoreCoreNetworkPolicyVersionOutput struct {
// Describes the restored core network policy.
CoreNetworkPolicy *types.CoreNetworkPolicy
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationRestoreCoreNetworkPolicyVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpRestoreCoreNetworkPolicyVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpRestoreCoreNetworkPolicyVersion{}, 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 = addOpRestoreCoreNetworkPolicyVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opRestoreCoreNetworkPolicyVersion(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_opRestoreCoreNetworkPolicyVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "RestoreCoreNetworkPolicyVersion",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Enables the Network Manager service for an Amazon Web Services Organization.
// This can only be called by a management account within the organization.
func (c *Client) StartOrganizationServiceAccessUpdate(ctx context.Context, params *StartOrganizationServiceAccessUpdateInput, optFns ...func(*Options)) (*StartOrganizationServiceAccessUpdateOutput, error) {
if params == nil {
params = &StartOrganizationServiceAccessUpdateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartOrganizationServiceAccessUpdate", params, optFns, c.addOperationStartOrganizationServiceAccessUpdateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartOrganizationServiceAccessUpdateOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartOrganizationServiceAccessUpdateInput struct {
// The action to take for the update request. This can be either ENABLE or DISABLE .
//
// This member is required.
Action *string
noSmithyDocumentSerde
}
type StartOrganizationServiceAccessUpdateOutput struct {
// The status of the service access update request for an Amazon Web Services
// Organization.
OrganizationStatus *types.OrganizationStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartOrganizationServiceAccessUpdateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartOrganizationServiceAccessUpdate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartOrganizationServiceAccessUpdate{}, 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 = addOpStartOrganizationServiceAccessUpdateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartOrganizationServiceAccessUpdate(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_opStartOrganizationServiceAccessUpdate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "StartOrganizationServiceAccessUpdate",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts analyzing the routing path between the specified source and destination.
// For more information, see Route Analyzer (https://docs.aws.amazon.com/vpc/latest/tgw/route-analyzer.html)
// .
func (c *Client) StartRouteAnalysis(ctx context.Context, params *StartRouteAnalysisInput, optFns ...func(*Options)) (*StartRouteAnalysisOutput, error) {
if params == nil {
params = &StartRouteAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartRouteAnalysis", params, optFns, c.addOperationStartRouteAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartRouteAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartRouteAnalysisInput struct {
// The destination.
//
// This member is required.
Destination *types.RouteAnalysisEndpointOptionsSpecification
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The source from which traffic originates.
//
// This member is required.
Source *types.RouteAnalysisEndpointOptionsSpecification
// Indicates whether to analyze the return path. The default is false .
IncludeReturnPath bool
// Indicates whether to include the location of middlebox appliances in the route
// analysis. The default is false .
UseMiddleboxes bool
noSmithyDocumentSerde
}
type StartRouteAnalysisOutput struct {
// The route analysis.
RouteAnalysis *types.RouteAnalysis
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartRouteAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartRouteAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartRouteAnalysis{}, 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 = addOpStartRouteAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartRouteAnalysis(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_opStartRouteAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "StartRouteAnalysis",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Tags a specified resource.
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 Amazon Resource Name (ARN) of the resource.
//
// This member is required.
ResourceArn *string
// The tags to apply to the specified resource.
//
// 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(&awsRestjson1_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_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: "networkmanager",
OperationName: "TagResource",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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 tags from a specified resource.
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 Amazon Resource Name (ARN) of the resource.
//
// This member is required.
ResourceArn *string
// The tag keys to remove from the specified resource.
//
// 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(&awsRestjson1_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_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: "networkmanager",
OperationName: "UntagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the information for an existing connection. To remove information for
// any of the parameters, specify an empty string.
func (c *Client) UpdateConnection(ctx context.Context, params *UpdateConnectionInput, optFns ...func(*Options)) (*UpdateConnectionOutput, error) {
if params == nil {
params = &UpdateConnectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateConnection", params, optFns, c.addOperationUpdateConnectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateConnectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateConnectionInput struct {
// The ID of the connection.
//
// This member is required.
ConnectionId *string
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the link for the second device in the connection.
ConnectedLinkId *string
// A description of the connection. Length Constraints: Maximum length of 256
// characters.
Description *string
// The ID of the link for the first device in the connection.
LinkId *string
noSmithyDocumentSerde
}
type UpdateConnectionOutput struct {
// Information about the connection.
Connection *types.Connection
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateConnectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateConnection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateConnection{}, 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 = addOpUpdateConnectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateConnection(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_opUpdateConnection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateConnection",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the description of a core network.
func (c *Client) UpdateCoreNetwork(ctx context.Context, params *UpdateCoreNetworkInput, optFns ...func(*Options)) (*UpdateCoreNetworkOutput, error) {
if params == nil {
params = &UpdateCoreNetworkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateCoreNetwork", params, optFns, c.addOperationUpdateCoreNetworkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateCoreNetworkOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateCoreNetworkInput struct {
// The ID of a core network.
//
// This member is required.
CoreNetworkId *string
// The description of the update.
Description *string
noSmithyDocumentSerde
}
type UpdateCoreNetworkOutput struct {
// Returns information about a core network update.
CoreNetwork *types.CoreNetwork
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateCoreNetworkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateCoreNetwork{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateCoreNetwork{}, 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 = addOpUpdateCoreNetworkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateCoreNetwork(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_opUpdateCoreNetwork(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateCoreNetwork",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the details for an existing device. To remove information for any of
// the parameters, specify an empty string.
func (c *Client) UpdateDevice(ctx context.Context, params *UpdateDeviceInput, optFns ...func(*Options)) (*UpdateDeviceOutput, error) {
if params == nil {
params = &UpdateDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateDevice", params, optFns, c.addOperationUpdateDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateDeviceInput struct {
// The ID of the device.
//
// This member is required.
DeviceId *string
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The Amazon Web Services location of the device, if applicable. For an
// on-premises device, you can omit this parameter.
AWSLocation *types.AWSLocation
// A description of the device. Constraints: Maximum length of 256 characters.
Description *string
// Describes a location.
Location *types.Location
// The model of the device. Constraints: Maximum length of 128 characters.
Model *string
// The serial number of the device. Constraints: Maximum length of 128 characters.
SerialNumber *string
// The ID of the site.
SiteId *string
// The type of the device.
Type *string
// The vendor of the device. Constraints: Maximum length of 128 characters.
Vendor *string
noSmithyDocumentSerde
}
type UpdateDeviceOutput struct {
// Information about the device.
Device *types.Device
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateDevice{}, 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 = addOpUpdateDeviceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateDevice(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_opUpdateDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateDevice",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates an existing global network. To remove information for any of the
// parameters, specify an empty string.
func (c *Client) UpdateGlobalNetwork(ctx context.Context, params *UpdateGlobalNetworkInput, optFns ...func(*Options)) (*UpdateGlobalNetworkOutput, error) {
if params == nil {
params = &UpdateGlobalNetworkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateGlobalNetwork", params, optFns, c.addOperationUpdateGlobalNetworkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateGlobalNetworkOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateGlobalNetworkInput struct {
// The ID of your global network.
//
// This member is required.
GlobalNetworkId *string
// A description of the global network. Constraints: Maximum length of 256
// characters.
Description *string
noSmithyDocumentSerde
}
type UpdateGlobalNetworkOutput struct {
// Information about the global network object.
GlobalNetwork *types.GlobalNetwork
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateGlobalNetworkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateGlobalNetwork{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateGlobalNetwork{}, 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 = addOpUpdateGlobalNetworkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateGlobalNetwork(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_opUpdateGlobalNetwork(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateGlobalNetwork",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the details for an existing link. To remove information for any of the
// parameters, specify an empty string.
func (c *Client) UpdateLink(ctx context.Context, params *UpdateLinkInput, optFns ...func(*Options)) (*UpdateLinkOutput, error) {
if params == nil {
params = &UpdateLinkInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateLink", params, optFns, c.addOperationUpdateLinkMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateLinkOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateLinkInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of the link.
//
// This member is required.
LinkId *string
// The upload and download speed in Mbps.
Bandwidth *types.Bandwidth
// A description of the link. Constraints: Maximum length of 256 characters.
Description *string
// The provider of the link. Constraints: Maximum length of 128 characters.
Provider *string
// The type of the link. Constraints: Maximum length of 128 characters.
Type *string
noSmithyDocumentSerde
}
type UpdateLinkOutput struct {
// Information about the link.
Link *types.Link
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateLinkMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateLink{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateLink{}, 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 = addOpUpdateLinkValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateLink(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_opUpdateLink(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateLink",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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"
)
// Updates the resource metadata for the specified global network.
func (c *Client) UpdateNetworkResourceMetadata(ctx context.Context, params *UpdateNetworkResourceMetadataInput, optFns ...func(*Options)) (*UpdateNetworkResourceMetadataOutput, error) {
if params == nil {
params = &UpdateNetworkResourceMetadataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateNetworkResourceMetadata", params, optFns, c.addOperationUpdateNetworkResourceMetadataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateNetworkResourceMetadataOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateNetworkResourceMetadataInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The resource metadata.
//
// This member is required.
Metadata map[string]string
// The ARN of the resource.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type UpdateNetworkResourceMetadataOutput struct {
// The updated resource metadata.
Metadata map[string]string
// The ARN of the resource.
ResourceArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateNetworkResourceMetadataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateNetworkResourceMetadata{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateNetworkResourceMetadata{}, 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 = addOpUpdateNetworkResourceMetadataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateNetworkResourceMetadata(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_opUpdateNetworkResourceMetadata(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateNetworkResourceMetadata",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the information for an existing site. To remove information for any of
// the parameters, specify an empty string.
func (c *Client) UpdateSite(ctx context.Context, params *UpdateSiteInput, optFns ...func(*Options)) (*UpdateSiteOutput, error) {
if params == nil {
params = &UpdateSiteInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateSite", params, optFns, c.addOperationUpdateSiteMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateSiteOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateSiteInput struct {
// The ID of the global network.
//
// This member is required.
GlobalNetworkId *string
// The ID of your site.
//
// This member is required.
SiteId *string
// A description of your site. Constraints: Maximum length of 256 characters.
Description *string
// The site location:
// - Address : The physical address of the site.
// - Latitude : The latitude of the site.
// - Longitude : The longitude of the site.
Location *types.Location
noSmithyDocumentSerde
}
type UpdateSiteOutput struct {
// Information about the site.
Site *types.Site
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateSiteMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateSite{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateSite{}, 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 = addOpUpdateSiteValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateSite(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_opUpdateSite(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateSite",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates a VPC attachment.
func (c *Client) UpdateVpcAttachment(ctx context.Context, params *UpdateVpcAttachmentInput, optFns ...func(*Options)) (*UpdateVpcAttachmentOutput, error) {
if params == nil {
params = &UpdateVpcAttachmentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateVpcAttachment", params, optFns, c.addOperationUpdateVpcAttachmentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateVpcAttachmentOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateVpcAttachmentInput struct {
// The ID of the attachment.
//
// This member is required.
AttachmentId *string
// Adds a subnet ARN to the VPC attachment.
AddSubnetArns []string
// Additional options for updating the VPC attachment.
Options *types.VpcOptions
// Removes a subnet ARN from the attachment.
RemoveSubnetArns []string
noSmithyDocumentSerde
}
type UpdateVpcAttachmentOutput struct {
// Describes the updated VPC attachment.
VpcAttachment *types.VpcAttachment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateVpcAttachmentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateVpcAttachment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateVpcAttachment{}, 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 = addOpUpdateVpcAttachmentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateVpcAttachment(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_opUpdateVpcAttachment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "networkmanager",
OperationName: "UpdateVpcAttachment",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package networkmanager provides the API client, operations, and parameter types
// for AWS Network Manager.
//
// Amazon Web Services enables you to centrally manage your Amazon Web Services
// Cloud WAN core network and your Transit Gateway network across Amazon Web
// Services accounts, Regions, and on-premises locations.
package networkmanager
| 10 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
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/networkmanager/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 = "networkmanager"
}
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 networkmanager
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.17.14"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/networkmanager/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_serializeOpAcceptAttachment struct {
}
func (*awsRestjson1_serializeOpAcceptAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAcceptAttachment) 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.(*AcceptAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/attachments/{AttachmentId}/accept")
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_serializeOpHttpBindingsAcceptAttachmentInput(input, restEncoder); 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_serializeOpHttpBindingsAcceptAttachmentInput(v *AcceptAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpAssociateConnectPeer struct {
}
func (*awsRestjson1_serializeOpAssociateConnectPeer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateConnectPeer) 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.(*AssociateConnectPeerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/connect-peer-associations")
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_serializeOpHttpBindingsAssociateConnectPeerInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateConnectPeerInput(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_serializeOpHttpBindingsAssociateConnectPeerInput(v *AssociateConnectPeerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateConnectPeerInput(v *AssociateConnectPeerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConnectPeerId != nil {
ok := object.Key("ConnectPeerId")
ok.String(*v.ConnectPeerId)
}
if v.DeviceId != nil {
ok := object.Key("DeviceId")
ok.String(*v.DeviceId)
}
if v.LinkId != nil {
ok := object.Key("LinkId")
ok.String(*v.LinkId)
}
return nil
}
type awsRestjson1_serializeOpAssociateCustomerGateway struct {
}
func (*awsRestjson1_serializeOpAssociateCustomerGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateCustomerGateway) 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.(*AssociateCustomerGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/customer-gateway-associations")
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_serializeOpHttpBindingsAssociateCustomerGatewayInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateCustomerGatewayInput(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_serializeOpHttpBindingsAssociateCustomerGatewayInput(v *AssociateCustomerGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateCustomerGatewayInput(v *AssociateCustomerGatewayInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CustomerGatewayArn != nil {
ok := object.Key("CustomerGatewayArn")
ok.String(*v.CustomerGatewayArn)
}
if v.DeviceId != nil {
ok := object.Key("DeviceId")
ok.String(*v.DeviceId)
}
if v.LinkId != nil {
ok := object.Key("LinkId")
ok.String(*v.LinkId)
}
return nil
}
type awsRestjson1_serializeOpAssociateLink struct {
}
func (*awsRestjson1_serializeOpAssociateLink) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateLink) 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.(*AssociateLinkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/link-associations")
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_serializeOpHttpBindingsAssociateLinkInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateLinkInput(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_serializeOpHttpBindingsAssociateLinkInput(v *AssociateLinkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateLinkInput(v *AssociateLinkInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeviceId != nil {
ok := object.Key("DeviceId")
ok.String(*v.DeviceId)
}
if v.LinkId != nil {
ok := object.Key("LinkId")
ok.String(*v.LinkId)
}
return nil
}
type awsRestjson1_serializeOpAssociateTransitGatewayConnectPeer struct {
}
func (*awsRestjson1_serializeOpAssociateTransitGatewayConnectPeer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateTransitGatewayConnectPeer) 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.(*AssociateTransitGatewayConnectPeerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations")
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_serializeOpHttpBindingsAssociateTransitGatewayConnectPeerInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateTransitGatewayConnectPeerInput(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_serializeOpHttpBindingsAssociateTransitGatewayConnectPeerInput(v *AssociateTransitGatewayConnectPeerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateTransitGatewayConnectPeerInput(v *AssociateTransitGatewayConnectPeerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeviceId != nil {
ok := object.Key("DeviceId")
ok.String(*v.DeviceId)
}
if v.LinkId != nil {
ok := object.Key("LinkId")
ok.String(*v.LinkId)
}
if v.TransitGatewayConnectPeerArn != nil {
ok := object.Key("TransitGatewayConnectPeerArn")
ok.String(*v.TransitGatewayConnectPeerArn)
}
return nil
}
type awsRestjson1_serializeOpCreateConnectAttachment struct {
}
func (*awsRestjson1_serializeOpCreateConnectAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateConnectAttachment) 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.(*CreateConnectAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/connect-attachments")
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_serializeOpDocumentCreateConnectAttachmentInput(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_serializeOpHttpBindingsCreateConnectAttachmentInput(v *CreateConnectAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateConnectAttachmentInput(v *CreateConnectAttachmentInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.CoreNetworkId != nil {
ok := object.Key("CoreNetworkId")
ok.String(*v.CoreNetworkId)
}
if v.EdgeLocation != nil {
ok := object.Key("EdgeLocation")
ok.String(*v.EdgeLocation)
}
if v.Options != nil {
ok := object.Key("Options")
if err := awsRestjson1_serializeDocumentConnectAttachmentOptions(v.Options, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.TransportAttachmentId != nil {
ok := object.Key("TransportAttachmentId")
ok.String(*v.TransportAttachmentId)
}
return nil
}
type awsRestjson1_serializeOpCreateConnection struct {
}
func (*awsRestjson1_serializeOpCreateConnection) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateConnection) 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.(*CreateConnectionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/connections")
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_serializeOpHttpBindingsCreateConnectionInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateConnectionInput(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_serializeOpHttpBindingsCreateConnectionInput(v *CreateConnectionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateConnectionInput(v *CreateConnectionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConnectedDeviceId != nil {
ok := object.Key("ConnectedDeviceId")
ok.String(*v.ConnectedDeviceId)
}
if v.ConnectedLinkId != nil {
ok := object.Key("ConnectedLinkId")
ok.String(*v.ConnectedLinkId)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.DeviceId != nil {
ok := object.Key("DeviceId")
ok.String(*v.DeviceId)
}
if v.LinkId != nil {
ok := object.Key("LinkId")
ok.String(*v.LinkId)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateConnectPeer struct {
}
func (*awsRestjson1_serializeOpCreateConnectPeer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateConnectPeer) 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.(*CreateConnectPeerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/connect-peers")
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_serializeOpDocumentCreateConnectPeerInput(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_serializeOpHttpBindingsCreateConnectPeerInput(v *CreateConnectPeerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateConnectPeerInput(v *CreateConnectPeerInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BgpOptions != nil {
ok := object.Key("BgpOptions")
if err := awsRestjson1_serializeDocumentBgpOptions(v.BgpOptions, ok); err != nil {
return err
}
}
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.ConnectAttachmentId != nil {
ok := object.Key("ConnectAttachmentId")
ok.String(*v.ConnectAttachmentId)
}
if v.CoreNetworkAddress != nil {
ok := object.Key("CoreNetworkAddress")
ok.String(*v.CoreNetworkAddress)
}
if v.InsideCidrBlocks != nil {
ok := object.Key("InsideCidrBlocks")
if err := awsRestjson1_serializeDocumentConstrainedStringList(v.InsideCidrBlocks, ok); err != nil {
return err
}
}
if v.PeerAddress != nil {
ok := object.Key("PeerAddress")
ok.String(*v.PeerAddress)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateCoreNetwork struct {
}
func (*awsRestjson1_serializeOpCreateCoreNetwork) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateCoreNetwork) 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.(*CreateCoreNetworkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks")
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_serializeOpDocumentCreateCoreNetworkInput(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_serializeOpHttpBindingsCreateCoreNetworkInput(v *CreateCoreNetworkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateCoreNetworkInput(v *CreateCoreNetworkInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.GlobalNetworkId != nil {
ok := object.Key("GlobalNetworkId")
ok.String(*v.GlobalNetworkId)
}
if v.PolicyDocument != nil {
ok := object.Key("PolicyDocument")
ok.String(*v.PolicyDocument)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateDevice struct {
}
func (*awsRestjson1_serializeOpCreateDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateDevice) 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.(*CreateDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/devices")
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_serializeOpHttpBindingsCreateDeviceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateDeviceInput(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_serializeOpHttpBindingsCreateDeviceInput(v *CreateDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateDeviceInput(v *CreateDeviceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AWSLocation != nil {
ok := object.Key("AWSLocation")
if err := awsRestjson1_serializeDocumentAWSLocation(v.AWSLocation, ok); err != nil {
return err
}
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Location != nil {
ok := object.Key("Location")
if err := awsRestjson1_serializeDocumentLocation(v.Location, ok); err != nil {
return err
}
}
if v.Model != nil {
ok := object.Key("Model")
ok.String(*v.Model)
}
if v.SerialNumber != nil {
ok := object.Key("SerialNumber")
ok.String(*v.SerialNumber)
}
if v.SiteId != nil {
ok := object.Key("SiteId")
ok.String(*v.SiteId)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.Type != nil {
ok := object.Key("Type")
ok.String(*v.Type)
}
if v.Vendor != nil {
ok := object.Key("Vendor")
ok.String(*v.Vendor)
}
return nil
}
type awsRestjson1_serializeOpCreateGlobalNetwork struct {
}
func (*awsRestjson1_serializeOpCreateGlobalNetwork) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateGlobalNetwork) 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.(*CreateGlobalNetworkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks")
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_serializeOpDocumentCreateGlobalNetworkInput(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_serializeOpHttpBindingsCreateGlobalNetworkInput(v *CreateGlobalNetworkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateGlobalNetworkInput(v *CreateGlobalNetworkInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateLink struct {
}
func (*awsRestjson1_serializeOpCreateLink) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateLink) 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.(*CreateLinkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/links")
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_serializeOpHttpBindingsCreateLinkInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateLinkInput(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_serializeOpHttpBindingsCreateLinkInput(v *CreateLinkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateLinkInput(v *CreateLinkInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Bandwidth != nil {
ok := object.Key("Bandwidth")
if err := awsRestjson1_serializeDocumentBandwidth(v.Bandwidth, ok); err != nil {
return err
}
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Provider != nil {
ok := object.Key("Provider")
ok.String(*v.Provider)
}
if v.SiteId != nil {
ok := object.Key("SiteId")
ok.String(*v.SiteId)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.Type != nil {
ok := object.Key("Type")
ok.String(*v.Type)
}
return nil
}
type awsRestjson1_serializeOpCreateSite struct {
}
func (*awsRestjson1_serializeOpCreateSite) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateSite) 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.(*CreateSiteInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/sites")
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_serializeOpHttpBindingsCreateSiteInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateSiteInput(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_serializeOpHttpBindingsCreateSiteInput(v *CreateSiteInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateSiteInput(v *CreateSiteInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Location != nil {
ok := object.Key("Location")
if err := awsRestjson1_serializeDocumentLocation(v.Location, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateSiteToSiteVpnAttachment struct {
}
func (*awsRestjson1_serializeOpCreateSiteToSiteVpnAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateSiteToSiteVpnAttachment) 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.(*CreateSiteToSiteVpnAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/site-to-site-vpn-attachments")
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_serializeOpDocumentCreateSiteToSiteVpnAttachmentInput(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_serializeOpHttpBindingsCreateSiteToSiteVpnAttachmentInput(v *CreateSiteToSiteVpnAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateSiteToSiteVpnAttachmentInput(v *CreateSiteToSiteVpnAttachmentInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.CoreNetworkId != nil {
ok := object.Key("CoreNetworkId")
ok.String(*v.CoreNetworkId)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.VpnConnectionArn != nil {
ok := object.Key("VpnConnectionArn")
ok.String(*v.VpnConnectionArn)
}
return nil
}
type awsRestjson1_serializeOpCreateTransitGatewayPeering struct {
}
func (*awsRestjson1_serializeOpCreateTransitGatewayPeering) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateTransitGatewayPeering) 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.(*CreateTransitGatewayPeeringInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/transit-gateway-peerings")
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_serializeOpDocumentCreateTransitGatewayPeeringInput(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_serializeOpHttpBindingsCreateTransitGatewayPeeringInput(v *CreateTransitGatewayPeeringInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateTransitGatewayPeeringInput(v *CreateTransitGatewayPeeringInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.CoreNetworkId != nil {
ok := object.Key("CoreNetworkId")
ok.String(*v.CoreNetworkId)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.TransitGatewayArn != nil {
ok := object.Key("TransitGatewayArn")
ok.String(*v.TransitGatewayArn)
}
return nil
}
type awsRestjson1_serializeOpCreateTransitGatewayRouteTableAttachment struct {
}
func (*awsRestjson1_serializeOpCreateTransitGatewayRouteTableAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateTransitGatewayRouteTableAttachment) 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.(*CreateTransitGatewayRouteTableAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/transit-gateway-route-table-attachments")
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_serializeOpDocumentCreateTransitGatewayRouteTableAttachmentInput(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_serializeOpHttpBindingsCreateTransitGatewayRouteTableAttachmentInput(v *CreateTransitGatewayRouteTableAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateTransitGatewayRouteTableAttachmentInput(v *CreateTransitGatewayRouteTableAttachmentInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.PeeringId != nil {
ok := object.Key("PeeringId")
ok.String(*v.PeeringId)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.TransitGatewayRouteTableArn != nil {
ok := object.Key("TransitGatewayRouteTableArn")
ok.String(*v.TransitGatewayRouteTableArn)
}
return nil
}
type awsRestjson1_serializeOpCreateVpcAttachment struct {
}
func (*awsRestjson1_serializeOpCreateVpcAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateVpcAttachment) 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.(*CreateVpcAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vpc-attachments")
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_serializeOpDocumentCreateVpcAttachmentInput(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_serializeOpHttpBindingsCreateVpcAttachmentInput(v *CreateVpcAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateVpcAttachmentInput(v *CreateVpcAttachmentInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.CoreNetworkId != nil {
ok := object.Key("CoreNetworkId")
ok.String(*v.CoreNetworkId)
}
if v.Options != nil {
ok := object.Key("Options")
if err := awsRestjson1_serializeDocumentVpcOptions(v.Options, ok); err != nil {
return err
}
}
if v.SubnetArns != nil {
ok := object.Key("SubnetArns")
if err := awsRestjson1_serializeDocumentSubnetArnList(v.SubnetArns, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.VpcArn != nil {
ok := object.Key("VpcArn")
ok.String(*v.VpcArn)
}
return nil
}
type awsRestjson1_serializeOpDeleteAttachment struct {
}
func (*awsRestjson1_serializeOpDeleteAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteAttachment) 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.(*DeleteAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/attachments/{AttachmentId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteAttachmentInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteAttachmentInput(v *DeleteAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteConnection struct {
}
func (*awsRestjson1_serializeOpDeleteConnection) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteConnection) 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.(*DeleteConnectionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/connections/{ConnectionId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteConnectionInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteConnectionInput(v *DeleteConnectionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectionId == nil || len(*v.ConnectionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectionId must not be empty")}
}
if v.ConnectionId != nil {
if err := encoder.SetURI("ConnectionId").String(*v.ConnectionId); err != nil {
return err
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteConnectPeer struct {
}
func (*awsRestjson1_serializeOpDeleteConnectPeer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteConnectPeer) 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.(*DeleteConnectPeerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/connect-peers/{ConnectPeerId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteConnectPeerInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteConnectPeerInput(v *DeleteConnectPeerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectPeerId == nil || len(*v.ConnectPeerId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectPeerId must not be empty")}
}
if v.ConnectPeerId != nil {
if err := encoder.SetURI("ConnectPeerId").String(*v.ConnectPeerId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteCoreNetwork struct {
}
func (*awsRestjson1_serializeOpDeleteCoreNetwork) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteCoreNetwork) 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.(*DeleteCoreNetworkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteCoreNetworkInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteCoreNetworkInput(v *DeleteCoreNetworkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteCoreNetworkPolicyVersion struct {
}
func (*awsRestjson1_serializeOpDeleteCoreNetworkPolicyVersion) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteCoreNetworkPolicyVersion) 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.(*DeleteCoreNetworkPolicyVersionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteCoreNetworkPolicyVersionInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteCoreNetworkPolicyVersionInput(v *DeleteCoreNetworkPolicyVersionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
if v.PolicyVersionId == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyVersionId must not be empty")}
}
if v.PolicyVersionId != nil {
if err := encoder.SetURI("PolicyVersionId").Integer(*v.PolicyVersionId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteDevice struct {
}
func (*awsRestjson1_serializeOpDeleteDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteDevice) 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.(*DeleteDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/devices/{DeviceId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteDeviceInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteDeviceInput(v *DeleteDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DeviceId == nil || len(*v.DeviceId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceId must not be empty")}
}
if v.DeviceId != nil {
if err := encoder.SetURI("DeviceId").String(*v.DeviceId); err != nil {
return err
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteGlobalNetwork struct {
}
func (*awsRestjson1_serializeOpDeleteGlobalNetwork) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteGlobalNetwork) 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.(*DeleteGlobalNetworkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteGlobalNetworkInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteGlobalNetworkInput(v *DeleteGlobalNetworkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteLink struct {
}
func (*awsRestjson1_serializeOpDeleteLink) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteLink) 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.(*DeleteLinkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/links/{LinkId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteLinkInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteLinkInput(v *DeleteLinkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.LinkId == nil || len(*v.LinkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member LinkId must not be empty")}
}
if v.LinkId != nil {
if err := encoder.SetURI("LinkId").String(*v.LinkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeletePeering struct {
}
func (*awsRestjson1_serializeOpDeletePeering) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeletePeering) 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.(*DeletePeeringInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/peerings/{PeeringId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeletePeeringInput(input, restEncoder); 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_serializeOpHttpBindingsDeletePeeringInput(v *DeletePeeringInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.PeeringId == nil || len(*v.PeeringId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PeeringId must not be empty")}
}
if v.PeeringId != nil {
if err := encoder.SetURI("PeeringId").String(*v.PeeringId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteResourcePolicy struct {
}
func (*awsRestjson1_serializeOpDeleteResourcePolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteResourcePolicy) 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.(*DeleteResourcePolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/resource-policy/{ResourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteResourcePolicyInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteResourcePolicyInput(v *DeleteResourcePolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteSite struct {
}
func (*awsRestjson1_serializeOpDeleteSite) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteSite) 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.(*DeleteSiteInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/sites/{SiteId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeleteSiteInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteSiteInput(v *DeleteSiteInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.SiteId == nil || len(*v.SiteId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SiteId must not be empty")}
}
if v.SiteId != nil {
if err := encoder.SetURI("SiteId").String(*v.SiteId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeregisterTransitGateway struct {
}
func (*awsRestjson1_serializeOpDeregisterTransitGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeregisterTransitGateway) 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.(*DeregisterTransitGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/transit-gateway-registrations/{TransitGatewayArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDeregisterTransitGatewayInput(input, restEncoder); 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_serializeOpHttpBindingsDeregisterTransitGatewayInput(v *DeregisterTransitGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.TransitGatewayArn == nil || len(*v.TransitGatewayArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member TransitGatewayArn must not be empty")}
}
if v.TransitGatewayArn != nil {
if err := encoder.SetURI("TransitGatewayArn").String(*v.TransitGatewayArn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeGlobalNetworks struct {
}
func (*awsRestjson1_serializeOpDescribeGlobalNetworks) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeGlobalNetworks) 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.(*DescribeGlobalNetworksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsDescribeGlobalNetworksInput(input, restEncoder); 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_serializeOpHttpBindingsDescribeGlobalNetworksInput(v *DescribeGlobalNetworksInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkIds != nil {
for i := range v.GlobalNetworkIds {
encoder.AddQuery("globalNetworkIds").String(v.GlobalNetworkIds[i])
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpDisassociateConnectPeer struct {
}
func (*awsRestjson1_serializeOpDisassociateConnectPeer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateConnectPeer) 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.(*DisassociateConnectPeerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/connect-peer-associations/{ConnectPeerId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDisassociateConnectPeerInput(input, restEncoder); 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_serializeOpHttpBindingsDisassociateConnectPeerInput(v *DisassociateConnectPeerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectPeerId == nil || len(*v.ConnectPeerId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectPeerId must not be empty")}
}
if v.ConnectPeerId != nil {
if err := encoder.SetURI("ConnectPeerId").String(*v.ConnectPeerId); err != nil {
return err
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisassociateCustomerGateway struct {
}
func (*awsRestjson1_serializeOpDisassociateCustomerGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateCustomerGateway) 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.(*DisassociateCustomerGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/customer-gateway-associations/{CustomerGatewayArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDisassociateCustomerGatewayInput(input, restEncoder); 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_serializeOpHttpBindingsDisassociateCustomerGatewayInput(v *DisassociateCustomerGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CustomerGatewayArn == nil || len(*v.CustomerGatewayArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CustomerGatewayArn must not be empty")}
}
if v.CustomerGatewayArn != nil {
if err := encoder.SetURI("CustomerGatewayArn").String(*v.CustomerGatewayArn); err != nil {
return err
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisassociateLink struct {
}
func (*awsRestjson1_serializeOpDisassociateLink) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateLink) 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.(*DisassociateLinkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/link-associations")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDisassociateLinkInput(input, restEncoder); 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_serializeOpHttpBindingsDisassociateLinkInput(v *DisassociateLinkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DeviceId != nil {
encoder.SetQuery("deviceId").String(*v.DeviceId)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.LinkId != nil {
encoder.SetQuery("linkId").String(*v.LinkId)
}
return nil
}
type awsRestjson1_serializeOpDisassociateTransitGatewayConnectPeer struct {
}
func (*awsRestjson1_serializeOpDisassociateTransitGatewayConnectPeer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateTransitGatewayConnectPeer) 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.(*DisassociateTransitGatewayConnectPeerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations/{TransitGatewayConnectPeerArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsDisassociateTransitGatewayConnectPeerInput(input, restEncoder); 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_serializeOpHttpBindingsDisassociateTransitGatewayConnectPeerInput(v *DisassociateTransitGatewayConnectPeerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.TransitGatewayConnectPeerArn == nil || len(*v.TransitGatewayConnectPeerArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member TransitGatewayConnectPeerArn must not be empty")}
}
if v.TransitGatewayConnectPeerArn != nil {
if err := encoder.SetURI("TransitGatewayConnectPeerArn").String(*v.TransitGatewayConnectPeerArn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpExecuteCoreNetworkChangeSet struct {
}
func (*awsRestjson1_serializeOpExecuteCoreNetworkChangeSet) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpExecuteCoreNetworkChangeSet) 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.(*ExecuteCoreNetworkChangeSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}/execute")
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_serializeOpHttpBindingsExecuteCoreNetworkChangeSetInput(input, restEncoder); 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_serializeOpHttpBindingsExecuteCoreNetworkChangeSetInput(v *ExecuteCoreNetworkChangeSetInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
if v.PolicyVersionId == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyVersionId must not be empty")}
}
if v.PolicyVersionId != nil {
if err := encoder.SetURI("PolicyVersionId").Integer(*v.PolicyVersionId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetConnectAttachment struct {
}
func (*awsRestjson1_serializeOpGetConnectAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetConnectAttachment) 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.(*GetConnectAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/connect-attachments/{AttachmentId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetConnectAttachmentInput(input, restEncoder); 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_serializeOpHttpBindingsGetConnectAttachmentInput(v *GetConnectAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetConnections struct {
}
func (*awsRestjson1_serializeOpGetConnections) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetConnections) 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.(*GetConnectionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/connections")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetConnectionsInput(input, restEncoder); 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_serializeOpHttpBindingsGetConnectionsInput(v *GetConnectionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectionIds != nil {
for i := range v.ConnectionIds {
encoder.AddQuery("connectionIds").String(v.ConnectionIds[i])
}
}
if v.DeviceId != nil {
encoder.SetQuery("deviceId").String(*v.DeviceId)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpGetConnectPeer struct {
}
func (*awsRestjson1_serializeOpGetConnectPeer) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetConnectPeer) 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.(*GetConnectPeerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/connect-peers/{ConnectPeerId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetConnectPeerInput(input, restEncoder); 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_serializeOpHttpBindingsGetConnectPeerInput(v *GetConnectPeerInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectPeerId == nil || len(*v.ConnectPeerId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectPeerId must not be empty")}
}
if v.ConnectPeerId != nil {
if err := encoder.SetURI("ConnectPeerId").String(*v.ConnectPeerId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetConnectPeerAssociations struct {
}
func (*awsRestjson1_serializeOpGetConnectPeerAssociations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetConnectPeerAssociations) 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.(*GetConnectPeerAssociationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/connect-peer-associations")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetConnectPeerAssociationsInput(input, restEncoder); 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_serializeOpHttpBindingsGetConnectPeerAssociationsInput(v *GetConnectPeerAssociationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectPeerIds != nil {
for i := range v.ConnectPeerIds {
encoder.AddQuery("connectPeerIds").String(v.ConnectPeerIds[i])
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpGetCoreNetwork struct {
}
func (*awsRestjson1_serializeOpGetCoreNetwork) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetCoreNetwork) 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.(*GetCoreNetworkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetCoreNetworkInput(input, restEncoder); 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_serializeOpHttpBindingsGetCoreNetworkInput(v *GetCoreNetworkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetCoreNetworkChangeEvents struct {
}
func (*awsRestjson1_serializeOpGetCoreNetworkChangeEvents) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetCoreNetworkChangeEvents) 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.(*GetCoreNetworkChangeEventsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-change-events/{PolicyVersionId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetCoreNetworkChangeEventsInput(input, restEncoder); 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_serializeOpHttpBindingsGetCoreNetworkChangeEventsInput(v *GetCoreNetworkChangeEventsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.PolicyVersionId == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyVersionId must not be empty")}
}
if v.PolicyVersionId != nil {
if err := encoder.SetURI("PolicyVersionId").Integer(*v.PolicyVersionId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetCoreNetworkChangeSet struct {
}
func (*awsRestjson1_serializeOpGetCoreNetworkChangeSet) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetCoreNetworkChangeSet) 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.(*GetCoreNetworkChangeSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetCoreNetworkChangeSetInput(input, restEncoder); 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_serializeOpHttpBindingsGetCoreNetworkChangeSetInput(v *GetCoreNetworkChangeSetInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.PolicyVersionId == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyVersionId must not be empty")}
}
if v.PolicyVersionId != nil {
if err := encoder.SetURI("PolicyVersionId").Integer(*v.PolicyVersionId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetCoreNetworkPolicy struct {
}
func (*awsRestjson1_serializeOpGetCoreNetworkPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetCoreNetworkPolicy) 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.(*GetCoreNetworkPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-policy")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetCoreNetworkPolicyInput(input, restEncoder); 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_serializeOpHttpBindingsGetCoreNetworkPolicyInput(v *GetCoreNetworkPolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.Alias) > 0 {
encoder.SetQuery("alias").String(string(v.Alias))
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
if v.PolicyVersionId != nil {
encoder.SetQuery("policyVersionId").Integer(*v.PolicyVersionId)
}
return nil
}
type awsRestjson1_serializeOpGetCustomerGatewayAssociations struct {
}
func (*awsRestjson1_serializeOpGetCustomerGatewayAssociations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetCustomerGatewayAssociations) 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.(*GetCustomerGatewayAssociationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/customer-gateway-associations")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetCustomerGatewayAssociationsInput(input, restEncoder); 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_serializeOpHttpBindingsGetCustomerGatewayAssociationsInput(v *GetCustomerGatewayAssociationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CustomerGatewayArns != nil {
for i := range v.CustomerGatewayArns {
encoder.AddQuery("customerGatewayArns").String(v.CustomerGatewayArns[i])
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpGetDevices struct {
}
func (*awsRestjson1_serializeOpGetDevices) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDevices) 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.(*GetDevicesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/devices")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetDevicesInput(input, restEncoder); 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_serializeOpHttpBindingsGetDevicesInput(v *GetDevicesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DeviceIds != nil {
for i := range v.DeviceIds {
encoder.AddQuery("deviceIds").String(v.DeviceIds[i])
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SiteId != nil {
encoder.SetQuery("siteId").String(*v.SiteId)
}
return nil
}
type awsRestjson1_serializeOpGetLinkAssociations struct {
}
func (*awsRestjson1_serializeOpGetLinkAssociations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetLinkAssociations) 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.(*GetLinkAssociationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/link-associations")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetLinkAssociationsInput(input, restEncoder); 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_serializeOpHttpBindingsGetLinkAssociationsInput(v *GetLinkAssociationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DeviceId != nil {
encoder.SetQuery("deviceId").String(*v.DeviceId)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.LinkId != nil {
encoder.SetQuery("linkId").String(*v.LinkId)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpGetLinks struct {
}
func (*awsRestjson1_serializeOpGetLinks) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetLinks) 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.(*GetLinksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/links")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetLinksInput(input, restEncoder); 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_serializeOpHttpBindingsGetLinksInput(v *GetLinksInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.LinkIds != nil {
for i := range v.LinkIds {
encoder.AddQuery("linkIds").String(v.LinkIds[i])
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.Provider != nil {
encoder.SetQuery("provider").String(*v.Provider)
}
if v.SiteId != nil {
encoder.SetQuery("siteId").String(*v.SiteId)
}
if v.Type != nil {
encoder.SetQuery("type").String(*v.Type)
}
return nil
}
type awsRestjson1_serializeOpGetNetworkResourceCounts struct {
}
func (*awsRestjson1_serializeOpGetNetworkResourceCounts) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetNetworkResourceCounts) 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.(*GetNetworkResourceCountsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/network-resource-count")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetNetworkResourceCountsInput(input, restEncoder); 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_serializeOpHttpBindingsGetNetworkResourceCountsInput(v *GetNetworkResourceCountsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.ResourceType != nil {
encoder.SetQuery("resourceType").String(*v.ResourceType)
}
return nil
}
type awsRestjson1_serializeOpGetNetworkResourceRelationships struct {
}
func (*awsRestjson1_serializeOpGetNetworkResourceRelationships) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetNetworkResourceRelationships) 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.(*GetNetworkResourceRelationshipsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/network-resource-relationships")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetNetworkResourceRelationshipsInput(input, restEncoder); 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_serializeOpHttpBindingsGetNetworkResourceRelationshipsInput(v *GetNetworkResourceRelationshipsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AccountId != nil {
encoder.SetQuery("accountId").String(*v.AccountId)
}
if v.AwsRegion != nil {
encoder.SetQuery("awsRegion").String(*v.AwsRegion)
}
if v.CoreNetworkId != nil {
encoder.SetQuery("coreNetworkId").String(*v.CoreNetworkId)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.RegisteredGatewayArn != nil {
encoder.SetQuery("registeredGatewayArn").String(*v.RegisteredGatewayArn)
}
if v.ResourceArn != nil {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
if v.ResourceType != nil {
encoder.SetQuery("resourceType").String(*v.ResourceType)
}
return nil
}
type awsRestjson1_serializeOpGetNetworkResources struct {
}
func (*awsRestjson1_serializeOpGetNetworkResources) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetNetworkResources) 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.(*GetNetworkResourcesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/network-resources")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetNetworkResourcesInput(input, restEncoder); 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_serializeOpHttpBindingsGetNetworkResourcesInput(v *GetNetworkResourcesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AccountId != nil {
encoder.SetQuery("accountId").String(*v.AccountId)
}
if v.AwsRegion != nil {
encoder.SetQuery("awsRegion").String(*v.AwsRegion)
}
if v.CoreNetworkId != nil {
encoder.SetQuery("coreNetworkId").String(*v.CoreNetworkId)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.RegisteredGatewayArn != nil {
encoder.SetQuery("registeredGatewayArn").String(*v.RegisteredGatewayArn)
}
if v.ResourceArn != nil {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
if v.ResourceType != nil {
encoder.SetQuery("resourceType").String(*v.ResourceType)
}
return nil
}
type awsRestjson1_serializeOpGetNetworkRoutes struct {
}
func (*awsRestjson1_serializeOpGetNetworkRoutes) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetNetworkRoutes) 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.(*GetNetworkRoutesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/network-routes")
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_serializeOpHttpBindingsGetNetworkRoutesInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetNetworkRoutesInput(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_serializeOpHttpBindingsGetNetworkRoutesInput(v *GetNetworkRoutesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentGetNetworkRoutesInput(v *GetNetworkRoutesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DestinationFilters != nil {
ok := object.Key("DestinationFilters")
if err := awsRestjson1_serializeDocumentFilterMap(v.DestinationFilters, ok); err != nil {
return err
}
}
if v.ExactCidrMatches != nil {
ok := object.Key("ExactCidrMatches")
if err := awsRestjson1_serializeDocumentConstrainedStringList(v.ExactCidrMatches, ok); err != nil {
return err
}
}
if v.LongestPrefixMatches != nil {
ok := object.Key("LongestPrefixMatches")
if err := awsRestjson1_serializeDocumentConstrainedStringList(v.LongestPrefixMatches, ok); err != nil {
return err
}
}
if v.PrefixListIds != nil {
ok := object.Key("PrefixListIds")
if err := awsRestjson1_serializeDocumentConstrainedStringList(v.PrefixListIds, ok); err != nil {
return err
}
}
if v.RouteTableIdentifier != nil {
ok := object.Key("RouteTableIdentifier")
if err := awsRestjson1_serializeDocumentRouteTableIdentifier(v.RouteTableIdentifier, ok); err != nil {
return err
}
}
if v.States != nil {
ok := object.Key("States")
if err := awsRestjson1_serializeDocumentRouteStateList(v.States, ok); err != nil {
return err
}
}
if v.SubnetOfMatches != nil {
ok := object.Key("SubnetOfMatches")
if err := awsRestjson1_serializeDocumentConstrainedStringList(v.SubnetOfMatches, ok); err != nil {
return err
}
}
if v.SupernetOfMatches != nil {
ok := object.Key("SupernetOfMatches")
if err := awsRestjson1_serializeDocumentConstrainedStringList(v.SupernetOfMatches, ok); err != nil {
return err
}
}
if v.Types != nil {
ok := object.Key("Types")
if err := awsRestjson1_serializeDocumentRouteTypeList(v.Types, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetNetworkTelemetry struct {
}
func (*awsRestjson1_serializeOpGetNetworkTelemetry) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetNetworkTelemetry) 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.(*GetNetworkTelemetryInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/network-telemetry")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetNetworkTelemetryInput(input, restEncoder); 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_serializeOpHttpBindingsGetNetworkTelemetryInput(v *GetNetworkTelemetryInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AccountId != nil {
encoder.SetQuery("accountId").String(*v.AccountId)
}
if v.AwsRegion != nil {
encoder.SetQuery("awsRegion").String(*v.AwsRegion)
}
if v.CoreNetworkId != nil {
encoder.SetQuery("coreNetworkId").String(*v.CoreNetworkId)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.RegisteredGatewayArn != nil {
encoder.SetQuery("registeredGatewayArn").String(*v.RegisteredGatewayArn)
}
if v.ResourceArn != nil {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
if v.ResourceType != nil {
encoder.SetQuery("resourceType").String(*v.ResourceType)
}
return nil
}
type awsRestjson1_serializeOpGetResourcePolicy struct {
}
func (*awsRestjson1_serializeOpGetResourcePolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetResourcePolicy) 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.(*GetResourcePolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/resource-policy/{ResourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetResourcePolicyInput(input, restEncoder); 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_serializeOpHttpBindingsGetResourcePolicyInput(v *GetResourcePolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetRouteAnalysis struct {
}
func (*awsRestjson1_serializeOpGetRouteAnalysis) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetRouteAnalysis) 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.(*GetRouteAnalysisInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/route-analyses/{RouteAnalysisId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetRouteAnalysisInput(input, restEncoder); 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_serializeOpHttpBindingsGetRouteAnalysisInput(v *GetRouteAnalysisInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.RouteAnalysisId == nil || len(*v.RouteAnalysisId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member RouteAnalysisId must not be empty")}
}
if v.RouteAnalysisId != nil {
if err := encoder.SetURI("RouteAnalysisId").String(*v.RouteAnalysisId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetSites struct {
}
func (*awsRestjson1_serializeOpGetSites) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetSites) 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.(*GetSitesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/sites")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetSitesInput(input, restEncoder); 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_serializeOpHttpBindingsGetSitesInput(v *GetSitesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SiteIds != nil {
for i := range v.SiteIds {
encoder.AddQuery("siteIds").String(v.SiteIds[i])
}
}
return nil
}
type awsRestjson1_serializeOpGetSiteToSiteVpnAttachment struct {
}
func (*awsRestjson1_serializeOpGetSiteToSiteVpnAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetSiteToSiteVpnAttachment) 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.(*GetSiteToSiteVpnAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/site-to-site-vpn-attachments/{AttachmentId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetSiteToSiteVpnAttachmentInput(input, restEncoder); 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_serializeOpHttpBindingsGetSiteToSiteVpnAttachmentInput(v *GetSiteToSiteVpnAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetTransitGatewayConnectPeerAssociations struct {
}
func (*awsRestjson1_serializeOpGetTransitGatewayConnectPeerAssociations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTransitGatewayConnectPeerAssociations) 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.(*GetTransitGatewayConnectPeerAssociationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetTransitGatewayConnectPeerAssociationsInput(input, restEncoder); 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_serializeOpHttpBindingsGetTransitGatewayConnectPeerAssociationsInput(v *GetTransitGatewayConnectPeerAssociationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.TransitGatewayConnectPeerArns != nil {
for i := range v.TransitGatewayConnectPeerArns {
encoder.AddQuery("transitGatewayConnectPeerArns").String(v.TransitGatewayConnectPeerArns[i])
}
}
return nil
}
type awsRestjson1_serializeOpGetTransitGatewayPeering struct {
}
func (*awsRestjson1_serializeOpGetTransitGatewayPeering) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTransitGatewayPeering) 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.(*GetTransitGatewayPeeringInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/transit-gateway-peerings/{PeeringId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetTransitGatewayPeeringInput(input, restEncoder); 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_serializeOpHttpBindingsGetTransitGatewayPeeringInput(v *GetTransitGatewayPeeringInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.PeeringId == nil || len(*v.PeeringId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PeeringId must not be empty")}
}
if v.PeeringId != nil {
if err := encoder.SetURI("PeeringId").String(*v.PeeringId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetTransitGatewayRegistrations struct {
}
func (*awsRestjson1_serializeOpGetTransitGatewayRegistrations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTransitGatewayRegistrations) 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.(*GetTransitGatewayRegistrationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/transit-gateway-registrations")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetTransitGatewayRegistrationsInput(input, restEncoder); 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_serializeOpHttpBindingsGetTransitGatewayRegistrationsInput(v *GetTransitGatewayRegistrationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.TransitGatewayArns != nil {
for i := range v.TransitGatewayArns {
encoder.AddQuery("transitGatewayArns").String(v.TransitGatewayArns[i])
}
}
return nil
}
type awsRestjson1_serializeOpGetTransitGatewayRouteTableAttachment struct {
}
func (*awsRestjson1_serializeOpGetTransitGatewayRouteTableAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTransitGatewayRouteTableAttachment) 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.(*GetTransitGatewayRouteTableAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/transit-gateway-route-table-attachments/{AttachmentId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetTransitGatewayRouteTableAttachmentInput(input, restEncoder); 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_serializeOpHttpBindingsGetTransitGatewayRouteTableAttachmentInput(v *GetTransitGatewayRouteTableAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetVpcAttachment struct {
}
func (*awsRestjson1_serializeOpGetVpcAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetVpcAttachment) 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.(*GetVpcAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vpc-attachments/{AttachmentId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsGetVpcAttachmentInput(input, restEncoder); 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_serializeOpHttpBindingsGetVpcAttachmentInput(v *GetVpcAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListAttachments struct {
}
func (*awsRestjson1_serializeOpListAttachments) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAttachments) 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.(*ListAttachmentsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/attachments")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsListAttachmentsInput(input, restEncoder); 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_serializeOpHttpBindingsListAttachmentsInput(v *ListAttachmentsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.AttachmentType) > 0 {
encoder.SetQuery("attachmentType").String(string(v.AttachmentType))
}
if v.CoreNetworkId != nil {
encoder.SetQuery("coreNetworkId").String(*v.CoreNetworkId)
}
if v.EdgeLocation != nil {
encoder.SetQuery("edgeLocation").String(*v.EdgeLocation)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if len(v.State) > 0 {
encoder.SetQuery("state").String(string(v.State))
}
return nil
}
type awsRestjson1_serializeOpListConnectPeers struct {
}
func (*awsRestjson1_serializeOpListConnectPeers) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListConnectPeers) 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.(*ListConnectPeersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/connect-peers")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsListConnectPeersInput(input, restEncoder); 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_serializeOpHttpBindingsListConnectPeersInput(v *ListConnectPeersInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectAttachmentId != nil {
encoder.SetQuery("connectAttachmentId").String(*v.ConnectAttachmentId)
}
if v.CoreNetworkId != nil {
encoder.SetQuery("coreNetworkId").String(*v.CoreNetworkId)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListCoreNetworkPolicyVersions struct {
}
func (*awsRestjson1_serializeOpListCoreNetworkPolicyVersions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListCoreNetworkPolicyVersions) 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.(*ListCoreNetworkPolicyVersionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-policy-versions")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsListCoreNetworkPolicyVersionsInput(input, restEncoder); 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_serializeOpHttpBindingsListCoreNetworkPolicyVersionsInput(v *ListCoreNetworkPolicyVersionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListCoreNetworks struct {
}
func (*awsRestjson1_serializeOpListCoreNetworks) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListCoreNetworks) 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.(*ListCoreNetworksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsListCoreNetworksInput(input, restEncoder); 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_serializeOpHttpBindingsListCoreNetworksInput(v *ListCoreNetworksInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListOrganizationServiceAccessStatus struct {
}
func (*awsRestjson1_serializeOpListOrganizationServiceAccessStatus) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListOrganizationServiceAccessStatus) 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.(*ListOrganizationServiceAccessStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/organizations/service-access")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsListOrganizationServiceAccessStatusInput(input, restEncoder); 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_serializeOpHttpBindingsListOrganizationServiceAccessStatusInput(v *ListOrganizationServiceAccessStatusInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListPeerings struct {
}
func (*awsRestjson1_serializeOpListPeerings) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListPeerings) 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.(*ListPeeringsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/peerings")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsListPeeringsInput(input, restEncoder); 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_serializeOpHttpBindingsListPeeringsInput(v *ListPeeringsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId != nil {
encoder.SetQuery("coreNetworkId").String(*v.CoreNetworkId)
}
if v.EdgeLocation != nil {
encoder.SetQuery("edgeLocation").String(*v.EdgeLocation)
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if len(v.PeeringType) > 0 {
encoder.SetQuery("peeringType").String(string(v.PeeringType))
}
if len(v.State) > 0 {
encoder.SetQuery("state").String(string(v.State))
}
return nil
}
type awsRestjson1_serializeOpListTagsForResource struct {
}
func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_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)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
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_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); 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_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpPutCoreNetworkPolicy struct {
}
func (*awsRestjson1_serializeOpPutCoreNetworkPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutCoreNetworkPolicy) 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.(*PutCoreNetworkPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-policy")
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_serializeOpHttpBindingsPutCoreNetworkPolicyInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentPutCoreNetworkPolicyInput(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_serializeOpHttpBindingsPutCoreNetworkPolicyInput(v *PutCoreNetworkPolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentPutCoreNetworkPolicyInput(v *PutCoreNetworkPolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.LatestVersionId != nil {
ok := object.Key("LatestVersionId")
ok.Integer(*v.LatestVersionId)
}
if v.PolicyDocument != nil {
ok := object.Key("PolicyDocument")
ok.String(*v.PolicyDocument)
}
return nil
}
type awsRestjson1_serializeOpPutResourcePolicy struct {
}
func (*awsRestjson1_serializeOpPutResourcePolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutResourcePolicy) 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.(*PutResourcePolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/resource-policy/{ResourceArn}")
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_serializeOpHttpBindingsPutResourcePolicyInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentPutResourcePolicyInput(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_serializeOpHttpBindingsPutResourcePolicyInput(v *PutResourcePolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentPutResourcePolicyInput(v *PutResourcePolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PolicyDocument != nil {
ok := object.Key("PolicyDocument")
ok.String(*v.PolicyDocument)
}
return nil
}
type awsRestjson1_serializeOpRegisterTransitGateway struct {
}
func (*awsRestjson1_serializeOpRegisterTransitGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpRegisterTransitGateway) 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.(*RegisterTransitGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/transit-gateway-registrations")
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_serializeOpHttpBindingsRegisterTransitGatewayInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentRegisterTransitGatewayInput(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_serializeOpHttpBindingsRegisterTransitGatewayInput(v *RegisterTransitGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentRegisterTransitGatewayInput(v *RegisterTransitGatewayInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TransitGatewayArn != nil {
ok := object.Key("TransitGatewayArn")
ok.String(*v.TransitGatewayArn)
}
return nil
}
type awsRestjson1_serializeOpRejectAttachment struct {
}
func (*awsRestjson1_serializeOpRejectAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpRejectAttachment) 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.(*RejectAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/attachments/{AttachmentId}/reject")
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_serializeOpHttpBindingsRejectAttachmentInput(input, restEncoder); 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_serializeOpHttpBindingsRejectAttachmentInput(v *RejectAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpRestoreCoreNetworkPolicyVersion struct {
}
func (*awsRestjson1_serializeOpRestoreCoreNetworkPolicyVersion) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpRestoreCoreNetworkPolicyVersion) 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.(*RestoreCoreNetworkPolicyVersionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}/restore")
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_serializeOpHttpBindingsRestoreCoreNetworkPolicyVersionInput(input, restEncoder); 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_serializeOpHttpBindingsRestoreCoreNetworkPolicyVersionInput(v *RestoreCoreNetworkPolicyVersionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
if v.PolicyVersionId == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyVersionId must not be empty")}
}
if v.PolicyVersionId != nil {
if err := encoder.SetURI("PolicyVersionId").Integer(*v.PolicyVersionId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartOrganizationServiceAccessUpdate struct {
}
func (*awsRestjson1_serializeOpStartOrganizationServiceAccessUpdate) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartOrganizationServiceAccessUpdate) 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.(*StartOrganizationServiceAccessUpdateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/organizations/service-access")
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_serializeOpDocumentStartOrganizationServiceAccessUpdateInput(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_serializeOpHttpBindingsStartOrganizationServiceAccessUpdateInput(v *StartOrganizationServiceAccessUpdateInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartOrganizationServiceAccessUpdateInput(v *StartOrganizationServiceAccessUpdateInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Action != nil {
ok := object.Key("Action")
ok.String(*v.Action)
}
return nil
}
type awsRestjson1_serializeOpStartRouteAnalysis struct {
}
func (*awsRestjson1_serializeOpStartRouteAnalysis) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartRouteAnalysis) 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.(*StartRouteAnalysisInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/route-analyses")
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_serializeOpHttpBindingsStartRouteAnalysisInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartRouteAnalysisInput(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_serializeOpHttpBindingsStartRouteAnalysisInput(v *StartRouteAnalysisInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartRouteAnalysisInput(v *StartRouteAnalysisInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Destination != nil {
ok := object.Key("Destination")
if err := awsRestjson1_serializeDocumentRouteAnalysisEndpointOptionsSpecification(v.Destination, ok); err != nil {
return err
}
}
if v.IncludeReturnPath {
ok := object.Key("IncludeReturnPath")
ok.Boolean(v.IncludeReturnPath)
}
if v.Source != nil {
ok := object.Key("Source")
if err := awsRestjson1_serializeDocumentRouteAnalysisEndpointOptionsSpecification(v.Source, ok); err != nil {
return err
}
}
if v.UseMiddleboxes {
ok := object.Key("UseMiddleboxes")
ok.Boolean(v.UseMiddleboxes)
}
return nil
}
type awsRestjson1_serializeOpTagResource struct {
}
func (*awsRestjson1_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_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)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
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_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_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 = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUntagResource struct {
}
func (*awsRestjson1_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_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)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
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_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); 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_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
if v.TagKeys != nil {
for i := range v.TagKeys {
encoder.AddQuery("tagKeys").String(v.TagKeys[i])
}
}
return nil
}
type awsRestjson1_serializeOpUpdateConnection struct {
}
func (*awsRestjson1_serializeOpUpdateConnection) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateConnection) 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.(*UpdateConnectionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/connections/{ConnectionId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateConnectionInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateConnectionInput(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_serializeOpHttpBindingsUpdateConnectionInput(v *UpdateConnectionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConnectionId == nil || len(*v.ConnectionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConnectionId must not be empty")}
}
if v.ConnectionId != nil {
if err := encoder.SetURI("ConnectionId").String(*v.ConnectionId); err != nil {
return err
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateConnectionInput(v *UpdateConnectionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConnectedLinkId != nil {
ok := object.Key("ConnectedLinkId")
ok.String(*v.ConnectedLinkId)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.LinkId != nil {
ok := object.Key("LinkId")
ok.String(*v.LinkId)
}
return nil
}
type awsRestjson1_serializeOpUpdateCoreNetwork struct {
}
func (*awsRestjson1_serializeOpUpdateCoreNetwork) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateCoreNetwork) 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.(*UpdateCoreNetworkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/core-networks/{CoreNetworkId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateCoreNetworkInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateCoreNetworkInput(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_serializeOpHttpBindingsUpdateCoreNetworkInput(v *UpdateCoreNetworkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.CoreNetworkId == nil || len(*v.CoreNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member CoreNetworkId must not be empty")}
}
if v.CoreNetworkId != nil {
if err := encoder.SetURI("CoreNetworkId").String(*v.CoreNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateCoreNetworkInput(v *UpdateCoreNetworkInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
return nil
}
type awsRestjson1_serializeOpUpdateDevice struct {
}
func (*awsRestjson1_serializeOpUpdateDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateDevice) 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.(*UpdateDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/devices/{DeviceId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateDeviceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateDeviceInput(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_serializeOpHttpBindingsUpdateDeviceInput(v *UpdateDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DeviceId == nil || len(*v.DeviceId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member DeviceId must not be empty")}
}
if v.DeviceId != nil {
if err := encoder.SetURI("DeviceId").String(*v.DeviceId); err != nil {
return err
}
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateDeviceInput(v *UpdateDeviceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AWSLocation != nil {
ok := object.Key("AWSLocation")
if err := awsRestjson1_serializeDocumentAWSLocation(v.AWSLocation, ok); err != nil {
return err
}
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Location != nil {
ok := object.Key("Location")
if err := awsRestjson1_serializeDocumentLocation(v.Location, ok); err != nil {
return err
}
}
if v.Model != nil {
ok := object.Key("Model")
ok.String(*v.Model)
}
if v.SerialNumber != nil {
ok := object.Key("SerialNumber")
ok.String(*v.SerialNumber)
}
if v.SiteId != nil {
ok := object.Key("SiteId")
ok.String(*v.SiteId)
}
if v.Type != nil {
ok := object.Key("Type")
ok.String(*v.Type)
}
if v.Vendor != nil {
ok := object.Key("Vendor")
ok.String(*v.Vendor)
}
return nil
}
type awsRestjson1_serializeOpUpdateGlobalNetwork struct {
}
func (*awsRestjson1_serializeOpUpdateGlobalNetwork) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateGlobalNetwork) 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.(*UpdateGlobalNetworkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateGlobalNetworkInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateGlobalNetworkInput(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_serializeOpHttpBindingsUpdateGlobalNetworkInput(v *UpdateGlobalNetworkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateGlobalNetworkInput(v *UpdateGlobalNetworkInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
return nil
}
type awsRestjson1_serializeOpUpdateLink struct {
}
func (*awsRestjson1_serializeOpUpdateLink) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateLink) 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.(*UpdateLinkInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/links/{LinkId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateLinkInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateLinkInput(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_serializeOpHttpBindingsUpdateLinkInput(v *UpdateLinkInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.LinkId == nil || len(*v.LinkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member LinkId must not be empty")}
}
if v.LinkId != nil {
if err := encoder.SetURI("LinkId").String(*v.LinkId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateLinkInput(v *UpdateLinkInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Bandwidth != nil {
ok := object.Key("Bandwidth")
if err := awsRestjson1_serializeDocumentBandwidth(v.Bandwidth, ok); err != nil {
return err
}
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Provider != nil {
ok := object.Key("Provider")
ok.String(*v.Provider)
}
if v.Type != nil {
ok := object.Key("Type")
ok.String(*v.Type)
}
return nil
}
type awsRestjson1_serializeOpUpdateNetworkResourceMetadata struct {
}
func (*awsRestjson1_serializeOpUpdateNetworkResourceMetadata) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateNetworkResourceMetadata) 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.(*UpdateNetworkResourceMetadataInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/network-resources/{ResourceArn}/metadata")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateNetworkResourceMetadataInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateNetworkResourceMetadataInput(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_serializeOpHttpBindingsUpdateNetworkResourceMetadataInput(v *UpdateNetworkResourceMetadataInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateNetworkResourceMetadataInput(v *UpdateNetworkResourceMetadataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Metadata != nil {
ok := object.Key("Metadata")
if err := awsRestjson1_serializeDocumentNetworkResourceMetadataMap(v.Metadata, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateSite struct {
}
func (*awsRestjson1_serializeOpUpdateSite) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateSite) 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.(*UpdateSiteInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/global-networks/{GlobalNetworkId}/sites/{SiteId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateSiteInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateSiteInput(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_serializeOpHttpBindingsUpdateSiteInput(v *UpdateSiteInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.GlobalNetworkId == nil || len(*v.GlobalNetworkId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member GlobalNetworkId must not be empty")}
}
if v.GlobalNetworkId != nil {
if err := encoder.SetURI("GlobalNetworkId").String(*v.GlobalNetworkId); err != nil {
return err
}
}
if v.SiteId == nil || len(*v.SiteId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SiteId must not be empty")}
}
if v.SiteId != nil {
if err := encoder.SetURI("SiteId").String(*v.SiteId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateSiteInput(v *UpdateSiteInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Location != nil {
ok := object.Key("Location")
if err := awsRestjson1_serializeDocumentLocation(v.Location, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateVpcAttachment struct {
}
func (*awsRestjson1_serializeOpUpdateVpcAttachment) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateVpcAttachment) 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.(*UpdateVpcAttachmentInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vpc-attachments/{AttachmentId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateVpcAttachmentInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateVpcAttachmentInput(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_serializeOpHttpBindingsUpdateVpcAttachmentInput(v *UpdateVpcAttachmentInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AttachmentId == nil || len(*v.AttachmentId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member AttachmentId must not be empty")}
}
if v.AttachmentId != nil {
if err := encoder.SetURI("AttachmentId").String(*v.AttachmentId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateVpcAttachmentInput(v *UpdateVpcAttachmentInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AddSubnetArns != nil {
ok := object.Key("AddSubnetArns")
if err := awsRestjson1_serializeDocumentSubnetArnList(v.AddSubnetArns, ok); err != nil {
return err
}
}
if v.Options != nil {
ok := object.Key("Options")
if err := awsRestjson1_serializeDocumentVpcOptions(v.Options, ok); err != nil {
return err
}
}
if v.RemoveSubnetArns != nil {
ok := object.Key("RemoveSubnetArns")
if err := awsRestjson1_serializeDocumentSubnetArnList(v.RemoveSubnetArns, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAWSLocation(v *types.AWSLocation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SubnetArn != nil {
ok := object.Key("SubnetArn")
ok.String(*v.SubnetArn)
}
if v.Zone != nil {
ok := object.Key("Zone")
ok.String(*v.Zone)
}
return nil
}
func awsRestjson1_serializeDocumentBandwidth(v *types.Bandwidth, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DownloadSpeed != nil {
ok := object.Key("DownloadSpeed")
ok.Integer(*v.DownloadSpeed)
}
if v.UploadSpeed != nil {
ok := object.Key("UploadSpeed")
ok.Integer(*v.UploadSpeed)
}
return nil
}
func awsRestjson1_serializeDocumentBgpOptions(v *types.BgpOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PeerAsn != nil {
ok := object.Key("PeerAsn")
ok.Long(*v.PeerAsn)
}
return nil
}
func awsRestjson1_serializeDocumentConnectAttachmentOptions(v *types.ConnectAttachmentOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Protocol) > 0 {
ok := object.Key("Protocol")
ok.String(string(v.Protocol))
}
return nil
}
func awsRestjson1_serializeDocumentConstrainedStringList(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 awsRestjson1_serializeDocumentCoreNetworkSegmentEdgeIdentifier(v *types.CoreNetworkSegmentEdgeIdentifier, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CoreNetworkId != nil {
ok := object.Key("CoreNetworkId")
ok.String(*v.CoreNetworkId)
}
if v.EdgeLocation != nil {
ok := object.Key("EdgeLocation")
ok.String(*v.EdgeLocation)
}
if v.SegmentName != nil {
ok := object.Key("SegmentName")
ok.String(*v.SegmentName)
}
return nil
}
func awsRestjson1_serializeDocumentFilterMap(v map[string][]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
if vv := v[key]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocumentFilterValues(v[key], om); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFilterValues(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 awsRestjson1_serializeDocumentLocation(v *types.Location, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Address != nil {
ok := object.Key("Address")
ok.String(*v.Address)
}
if v.Latitude != nil {
ok := object.Key("Latitude")
ok.String(*v.Latitude)
}
if v.Longitude != nil {
ok := object.Key("Longitude")
ok.String(*v.Longitude)
}
return nil
}
func awsRestjson1_serializeDocumentNetworkResourceMetadataMap(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentRouteAnalysisEndpointOptionsSpecification(v *types.RouteAnalysisEndpointOptionsSpecification, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IpAddress != nil {
ok := object.Key("IpAddress")
ok.String(*v.IpAddress)
}
if v.TransitGatewayAttachmentArn != nil {
ok := object.Key("TransitGatewayAttachmentArn")
ok.String(*v.TransitGatewayAttachmentArn)
}
return nil
}
func awsRestjson1_serializeDocumentRouteStateList(v []types.RouteState, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsRestjson1_serializeDocumentRouteTableIdentifier(v *types.RouteTableIdentifier, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CoreNetworkSegmentEdge != nil {
ok := object.Key("CoreNetworkSegmentEdge")
if err := awsRestjson1_serializeDocumentCoreNetworkSegmentEdgeIdentifier(v.CoreNetworkSegmentEdge, ok); err != nil {
return err
}
}
if v.TransitGatewayRouteTableArn != nil {
ok := object.Key("TransitGatewayRouteTableArn")
ok.String(*v.TransitGatewayRouteTableArn)
}
return nil
}
func awsRestjson1_serializeDocumentRouteTypeList(v []types.RouteType, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsRestjson1_serializeDocumentSubnetArnList(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 awsRestjson1_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 awsRestjson1_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentVpcOptions(v *types.VpcOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ApplianceModeSupport {
ok := object.Key("ApplianceModeSupport")
ok.Boolean(v.ApplianceModeSupport)
}
if v.Ipv6Support {
ok := object.Key("Ipv6Support")
ok.Boolean(v.Ipv6Support)
}
return nil
}
| 6,834 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package networkmanager
import (
"context"
"fmt"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpAcceptAttachment struct {
}
func (*validateOpAcceptAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAcceptAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AcceptAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAcceptAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateConnectPeer struct {
}
func (*validateOpAssociateConnectPeer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateConnectPeer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateConnectPeerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateConnectPeerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateCustomerGateway struct {
}
func (*validateOpAssociateCustomerGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateCustomerGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateCustomerGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateCustomerGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateLink struct {
}
func (*validateOpAssociateLink) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateLinkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateLinkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateTransitGatewayConnectPeer struct {
}
func (*validateOpAssociateTransitGatewayConnectPeer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateTransitGatewayConnectPeer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateTransitGatewayConnectPeerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateTransitGatewayConnectPeerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateConnectAttachment struct {
}
func (*validateOpCreateConnectAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateConnectAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateConnectAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateConnectAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateConnection struct {
}
func (*validateOpCreateConnection) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateConnectionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateConnectionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateConnectPeer struct {
}
func (*validateOpCreateConnectPeer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateConnectPeer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateConnectPeerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateConnectPeerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateCoreNetwork struct {
}
func (*validateOpCreateCoreNetwork) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateCoreNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateCoreNetworkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateCoreNetworkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateDevice struct {
}
func (*validateOpCreateDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateLink struct {
}
func (*validateOpCreateLink) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateLinkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateLinkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSite struct {
}
func (*validateOpCreateSite) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSite) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSiteInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSiteInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSiteToSiteVpnAttachment struct {
}
func (*validateOpCreateSiteToSiteVpnAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSiteToSiteVpnAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSiteToSiteVpnAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSiteToSiteVpnAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateTransitGatewayPeering struct {
}
func (*validateOpCreateTransitGatewayPeering) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateTransitGatewayPeering) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateTransitGatewayPeeringInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateTransitGatewayPeeringInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateTransitGatewayRouteTableAttachment struct {
}
func (*validateOpCreateTransitGatewayRouteTableAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateTransitGatewayRouteTableAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateTransitGatewayRouteTableAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateTransitGatewayRouteTableAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateVpcAttachment struct {
}
func (*validateOpCreateVpcAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateVpcAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateVpcAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateVpcAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAttachment struct {
}
func (*validateOpDeleteAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteConnection struct {
}
func (*validateOpDeleteConnection) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteConnectionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteConnectionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteConnectPeer struct {
}
func (*validateOpDeleteConnectPeer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteConnectPeer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteConnectPeerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteConnectPeerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteCoreNetwork struct {
}
func (*validateOpDeleteCoreNetwork) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteCoreNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteCoreNetworkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteCoreNetworkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteCoreNetworkPolicyVersion struct {
}
func (*validateOpDeleteCoreNetworkPolicyVersion) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteCoreNetworkPolicyVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteCoreNetworkPolicyVersionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteCoreNetworkPolicyVersionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteDevice struct {
}
func (*validateOpDeleteDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteGlobalNetwork struct {
}
func (*validateOpDeleteGlobalNetwork) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteGlobalNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteGlobalNetworkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteGlobalNetworkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteLink struct {
}
func (*validateOpDeleteLink) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteLinkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteLinkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeletePeering struct {
}
func (*validateOpDeletePeering) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeletePeering) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeletePeeringInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeletePeeringInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteResourcePolicy struct {
}
func (*validateOpDeleteResourcePolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteResourcePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteResourcePolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteResourcePolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteSite struct {
}
func (*validateOpDeleteSite) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteSite) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteSiteInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteSiteInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeregisterTransitGateway struct {
}
func (*validateOpDeregisterTransitGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeregisterTransitGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeregisterTransitGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeregisterTransitGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateConnectPeer struct {
}
func (*validateOpDisassociateConnectPeer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateConnectPeer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateConnectPeerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateConnectPeerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateCustomerGateway struct {
}
func (*validateOpDisassociateCustomerGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateCustomerGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateCustomerGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateCustomerGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateLink struct {
}
func (*validateOpDisassociateLink) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateLinkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateLinkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateTransitGatewayConnectPeer struct {
}
func (*validateOpDisassociateTransitGatewayConnectPeer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateTransitGatewayConnectPeer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateTransitGatewayConnectPeerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateTransitGatewayConnectPeerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpExecuteCoreNetworkChangeSet struct {
}
func (*validateOpExecuteCoreNetworkChangeSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpExecuteCoreNetworkChangeSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ExecuteCoreNetworkChangeSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpExecuteCoreNetworkChangeSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetConnectAttachment struct {
}
func (*validateOpGetConnectAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetConnectAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetConnectAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetConnectAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetConnections struct {
}
func (*validateOpGetConnections) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetConnections) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetConnectionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetConnectionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetConnectPeerAssociations struct {
}
func (*validateOpGetConnectPeerAssociations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetConnectPeerAssociations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetConnectPeerAssociationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetConnectPeerAssociationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetConnectPeer struct {
}
func (*validateOpGetConnectPeer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetConnectPeer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetConnectPeerInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetConnectPeerInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetCoreNetworkChangeEvents struct {
}
func (*validateOpGetCoreNetworkChangeEvents) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetCoreNetworkChangeEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetCoreNetworkChangeEventsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetCoreNetworkChangeEventsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetCoreNetworkChangeSet struct {
}
func (*validateOpGetCoreNetworkChangeSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetCoreNetworkChangeSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetCoreNetworkChangeSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetCoreNetworkChangeSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetCoreNetwork struct {
}
func (*validateOpGetCoreNetwork) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetCoreNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetCoreNetworkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetCoreNetworkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetCoreNetworkPolicy struct {
}
func (*validateOpGetCoreNetworkPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetCoreNetworkPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetCoreNetworkPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetCoreNetworkPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetCustomerGatewayAssociations struct {
}
func (*validateOpGetCustomerGatewayAssociations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetCustomerGatewayAssociations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetCustomerGatewayAssociationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetCustomerGatewayAssociationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetDevices struct {
}
func (*validateOpGetDevices) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDevicesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDevicesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetLinkAssociations struct {
}
func (*validateOpGetLinkAssociations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetLinkAssociations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetLinkAssociationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetLinkAssociationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetLinks struct {
}
func (*validateOpGetLinks) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetLinks) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetLinksInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetLinksInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetNetworkResourceCounts struct {
}
func (*validateOpGetNetworkResourceCounts) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetNetworkResourceCounts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetNetworkResourceCountsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetNetworkResourceCountsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetNetworkResourceRelationships struct {
}
func (*validateOpGetNetworkResourceRelationships) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetNetworkResourceRelationships) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetNetworkResourceRelationshipsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetNetworkResourceRelationshipsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetNetworkResources struct {
}
func (*validateOpGetNetworkResources) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetNetworkResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetNetworkResourcesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetNetworkResourcesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetNetworkRoutes struct {
}
func (*validateOpGetNetworkRoutes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetNetworkRoutes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetNetworkRoutesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetNetworkRoutesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetNetworkTelemetry struct {
}
func (*validateOpGetNetworkTelemetry) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetNetworkTelemetry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetNetworkTelemetryInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetNetworkTelemetryInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetResourcePolicy struct {
}
func (*validateOpGetResourcePolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetResourcePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetResourcePolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetResourcePolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetRouteAnalysis struct {
}
func (*validateOpGetRouteAnalysis) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetRouteAnalysis) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetRouteAnalysisInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetRouteAnalysisInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSites struct {
}
func (*validateOpGetSites) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSites) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSitesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSitesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSiteToSiteVpnAttachment struct {
}
func (*validateOpGetSiteToSiteVpnAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSiteToSiteVpnAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSiteToSiteVpnAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSiteToSiteVpnAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTransitGatewayConnectPeerAssociations struct {
}
func (*validateOpGetTransitGatewayConnectPeerAssociations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTransitGatewayConnectPeerAssociations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTransitGatewayConnectPeerAssociationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTransitGatewayConnectPeerAssociationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTransitGatewayPeering struct {
}
func (*validateOpGetTransitGatewayPeering) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTransitGatewayPeering) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTransitGatewayPeeringInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTransitGatewayPeeringInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTransitGatewayRegistrations struct {
}
func (*validateOpGetTransitGatewayRegistrations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTransitGatewayRegistrations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTransitGatewayRegistrationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTransitGatewayRegistrationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTransitGatewayRouteTableAttachment struct {
}
func (*validateOpGetTransitGatewayRouteTableAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTransitGatewayRouteTableAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTransitGatewayRouteTableAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTransitGatewayRouteTableAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetVpcAttachment struct {
}
func (*validateOpGetVpcAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetVpcAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetVpcAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetVpcAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListCoreNetworkPolicyVersions struct {
}
func (*validateOpListCoreNetworkPolicyVersions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListCoreNetworkPolicyVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListCoreNetworkPolicyVersionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListCoreNetworkPolicyVersionsInput(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 validateOpPutCoreNetworkPolicy struct {
}
func (*validateOpPutCoreNetworkPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutCoreNetworkPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutCoreNetworkPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutCoreNetworkPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutResourcePolicy struct {
}
func (*validateOpPutResourcePolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutResourcePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutResourcePolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutResourcePolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRegisterTransitGateway struct {
}
func (*validateOpRegisterTransitGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRegisterTransitGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RegisterTransitGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRegisterTransitGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRejectAttachment struct {
}
func (*validateOpRejectAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRejectAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RejectAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRejectAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRestoreCoreNetworkPolicyVersion struct {
}
func (*validateOpRestoreCoreNetworkPolicyVersion) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRestoreCoreNetworkPolicyVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RestoreCoreNetworkPolicyVersionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRestoreCoreNetworkPolicyVersionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartOrganizationServiceAccessUpdate struct {
}
func (*validateOpStartOrganizationServiceAccessUpdate) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartOrganizationServiceAccessUpdate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartOrganizationServiceAccessUpdateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartOrganizationServiceAccessUpdateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartRouteAnalysis struct {
}
func (*validateOpStartRouteAnalysis) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartRouteAnalysis) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartRouteAnalysisInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartRouteAnalysisInput(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 validateOpUpdateConnection struct {
}
func (*validateOpUpdateConnection) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateConnectionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateConnectionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateCoreNetwork struct {
}
func (*validateOpUpdateCoreNetwork) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateCoreNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateCoreNetworkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateCoreNetworkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateDevice struct {
}
func (*validateOpUpdateDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateGlobalNetwork struct {
}
func (*validateOpUpdateGlobalNetwork) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateGlobalNetwork) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateGlobalNetworkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateGlobalNetworkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateLink struct {
}
func (*validateOpUpdateLink) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateLinkInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateLinkInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateNetworkResourceMetadata struct {
}
func (*validateOpUpdateNetworkResourceMetadata) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateNetworkResourceMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateNetworkResourceMetadataInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateNetworkResourceMetadataInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSite struct {
}
func (*validateOpUpdateSite) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSite) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSiteInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSiteInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateVpcAttachment struct {
}
func (*validateOpUpdateVpcAttachment) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateVpcAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateVpcAttachmentInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateVpcAttachmentInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpAcceptAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAcceptAttachment{}, middleware.After)
}
func addOpAssociateConnectPeerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateConnectPeer{}, middleware.After)
}
func addOpAssociateCustomerGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateCustomerGateway{}, middleware.After)
}
func addOpAssociateLinkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateLink{}, middleware.After)
}
func addOpAssociateTransitGatewayConnectPeerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateTransitGatewayConnectPeer{}, middleware.After)
}
func addOpCreateConnectAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateConnectAttachment{}, middleware.After)
}
func addOpCreateConnectionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateConnection{}, middleware.After)
}
func addOpCreateConnectPeerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateConnectPeer{}, middleware.After)
}
func addOpCreateCoreNetworkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateCoreNetwork{}, middleware.After)
}
func addOpCreateDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateDevice{}, middleware.After)
}
func addOpCreateLinkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateLink{}, middleware.After)
}
func addOpCreateSiteValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSite{}, middleware.After)
}
func addOpCreateSiteToSiteVpnAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSiteToSiteVpnAttachment{}, middleware.After)
}
func addOpCreateTransitGatewayPeeringValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateTransitGatewayPeering{}, middleware.After)
}
func addOpCreateTransitGatewayRouteTableAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateTransitGatewayRouteTableAttachment{}, middleware.After)
}
func addOpCreateVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateVpcAttachment{}, middleware.After)
}
func addOpDeleteAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAttachment{}, middleware.After)
}
func addOpDeleteConnectionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteConnection{}, middleware.After)
}
func addOpDeleteConnectPeerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteConnectPeer{}, middleware.After)
}
func addOpDeleteCoreNetworkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteCoreNetwork{}, middleware.After)
}
func addOpDeleteCoreNetworkPolicyVersionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteCoreNetworkPolicyVersion{}, middleware.After)
}
func addOpDeleteDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteDevice{}, middleware.After)
}
func addOpDeleteGlobalNetworkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteGlobalNetwork{}, middleware.After)
}
func addOpDeleteLinkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteLink{}, middleware.After)
}
func addOpDeletePeeringValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeletePeering{}, middleware.After)
}
func addOpDeleteResourcePolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteResourcePolicy{}, middleware.After)
}
func addOpDeleteSiteValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteSite{}, middleware.After)
}
func addOpDeregisterTransitGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeregisterTransitGateway{}, middleware.After)
}
func addOpDisassociateConnectPeerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateConnectPeer{}, middleware.After)
}
func addOpDisassociateCustomerGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateCustomerGateway{}, middleware.After)
}
func addOpDisassociateLinkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateLink{}, middleware.After)
}
func addOpDisassociateTransitGatewayConnectPeerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateTransitGatewayConnectPeer{}, middleware.After)
}
func addOpExecuteCoreNetworkChangeSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpExecuteCoreNetworkChangeSet{}, middleware.After)
}
func addOpGetConnectAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetConnectAttachment{}, middleware.After)
}
func addOpGetConnectionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetConnections{}, middleware.After)
}
func addOpGetConnectPeerAssociationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetConnectPeerAssociations{}, middleware.After)
}
func addOpGetConnectPeerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetConnectPeer{}, middleware.After)
}
func addOpGetCoreNetworkChangeEventsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetCoreNetworkChangeEvents{}, middleware.After)
}
func addOpGetCoreNetworkChangeSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetCoreNetworkChangeSet{}, middleware.After)
}
func addOpGetCoreNetworkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetCoreNetwork{}, middleware.After)
}
func addOpGetCoreNetworkPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetCoreNetworkPolicy{}, middleware.After)
}
func addOpGetCustomerGatewayAssociationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetCustomerGatewayAssociations{}, middleware.After)
}
func addOpGetDevicesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDevices{}, middleware.After)
}
func addOpGetLinkAssociationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetLinkAssociations{}, middleware.After)
}
func addOpGetLinksValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetLinks{}, middleware.After)
}
func addOpGetNetworkResourceCountsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetNetworkResourceCounts{}, middleware.After)
}
func addOpGetNetworkResourceRelationshipsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetNetworkResourceRelationships{}, middleware.After)
}
func addOpGetNetworkResourcesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetNetworkResources{}, middleware.After)
}
func addOpGetNetworkRoutesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetNetworkRoutes{}, middleware.After)
}
func addOpGetNetworkTelemetryValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetNetworkTelemetry{}, middleware.After)
}
func addOpGetResourcePolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetResourcePolicy{}, middleware.After)
}
func addOpGetRouteAnalysisValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetRouteAnalysis{}, middleware.After)
}
func addOpGetSitesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSites{}, middleware.After)
}
func addOpGetSiteToSiteVpnAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSiteToSiteVpnAttachment{}, middleware.After)
}
func addOpGetTransitGatewayConnectPeerAssociationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTransitGatewayConnectPeerAssociations{}, middleware.After)
}
func addOpGetTransitGatewayPeeringValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTransitGatewayPeering{}, middleware.After)
}
func addOpGetTransitGatewayRegistrationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTransitGatewayRegistrations{}, middleware.After)
}
func addOpGetTransitGatewayRouteTableAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTransitGatewayRouteTableAttachment{}, middleware.After)
}
func addOpGetVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetVpcAttachment{}, middleware.After)
}
func addOpListCoreNetworkPolicyVersionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListCoreNetworkPolicyVersions{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpPutCoreNetworkPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutCoreNetworkPolicy{}, middleware.After)
}
func addOpPutResourcePolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutResourcePolicy{}, middleware.After)
}
func addOpRegisterTransitGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRegisterTransitGateway{}, middleware.After)
}
func addOpRejectAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRejectAttachment{}, middleware.After)
}
func addOpRestoreCoreNetworkPolicyVersionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRestoreCoreNetworkPolicyVersion{}, middleware.After)
}
func addOpStartOrganizationServiceAccessUpdateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartOrganizationServiceAccessUpdate{}, middleware.After)
}
func addOpStartRouteAnalysisValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartRouteAnalysis{}, 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 addOpUpdateConnectionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateConnection{}, middleware.After)
}
func addOpUpdateCoreNetworkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateCoreNetwork{}, middleware.After)
}
func addOpUpdateDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateDevice{}, middleware.After)
}
func addOpUpdateGlobalNetworkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateGlobalNetwork{}, middleware.After)
}
func addOpUpdateLinkValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateLink{}, middleware.After)
}
func addOpUpdateNetworkResourceMetadataValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateNetworkResourceMetadata{}, middleware.After)
}
func addOpUpdateSiteValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSite{}, middleware.After)
}
func addOpUpdateVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateVpcAttachment{}, middleware.After)
}
func validateOpAcceptAttachmentInput(v *AcceptAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AcceptAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateConnectPeerInput(v *AssociateConnectPeerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateConnectPeerInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.ConnectPeerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectPeerId"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateCustomerGatewayInput(v *AssociateCustomerGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateCustomerGatewayInput"}
if v.CustomerGatewayArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("CustomerGatewayArn"))
}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateLinkInput(v *AssociateLinkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateLinkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if v.LinkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("LinkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateTransitGatewayConnectPeerInput(v *AssociateTransitGatewayConnectPeerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateTransitGatewayConnectPeerInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.TransitGatewayConnectPeerArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayConnectPeerArn"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateConnectAttachmentInput(v *CreateConnectAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateConnectAttachmentInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.EdgeLocation == nil {
invalidParams.Add(smithy.NewErrParamRequired("EdgeLocation"))
}
if v.TransportAttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransportAttachmentId"))
}
if v.Options == nil {
invalidParams.Add(smithy.NewErrParamRequired("Options"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if v.ConnectedDeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectedDeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateConnectPeerInput(v *CreateConnectPeerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateConnectPeerInput"}
if v.ConnectAttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectAttachmentId"))
}
if v.PeerAddress == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeerAddress"))
}
if v.InsideCidrBlocks == nil {
invalidParams.Add(smithy.NewErrParamRequired("InsideCidrBlocks"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateCoreNetworkInput(v *CreateCoreNetworkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateCoreNetworkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateDeviceInput(v *CreateDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateDeviceInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateLinkInput(v *CreateLinkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateLinkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.Bandwidth == nil {
invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
}
if v.SiteId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SiteId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSiteInput(v *CreateSiteInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSiteInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSiteToSiteVpnAttachmentInput(v *CreateSiteToSiteVpnAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSiteToSiteVpnAttachmentInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.VpnConnectionArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateTransitGatewayPeeringInput(v *CreateTransitGatewayPeeringInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayPeeringInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.TransitGatewayArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateTransitGatewayRouteTableAttachmentInput(v *CreateTransitGatewayRouteTableAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayRouteTableAttachmentInput"}
if v.PeeringId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeeringId"))
}
if v.TransitGatewayRouteTableArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateVpcAttachmentInput(v *CreateVpcAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateVpcAttachmentInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.VpcArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("VpcArn"))
}
if v.SubnetArns == nil {
invalidParams.Add(smithy.NewErrParamRequired("SubnetArns"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAttachmentInput(v *DeleteAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.ConnectionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteConnectPeerInput(v *DeleteConnectPeerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectPeerInput"}
if v.ConnectPeerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectPeerId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteCoreNetworkInput(v *DeleteCoreNetworkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteCoreNetworkInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteCoreNetworkPolicyVersionInput(v *DeleteCoreNetworkPolicyVersionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteCoreNetworkPolicyVersionInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.PolicyVersionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyVersionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteDeviceInput(v *DeleteDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteDeviceInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteGlobalNetworkInput(v *DeleteGlobalNetworkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteGlobalNetworkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteLinkInput(v *DeleteLinkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteLinkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.LinkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("LinkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeletePeeringInput(v *DeletePeeringInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeletePeeringInput"}
if v.PeeringId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeeringId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteResourcePolicyInput(v *DeleteResourcePolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteResourcePolicyInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteSiteInput(v *DeleteSiteInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteSiteInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.SiteId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SiteId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeregisterTransitGatewayInput(v *DeregisterTransitGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeregisterTransitGatewayInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.TransitGatewayArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateConnectPeerInput(v *DisassociateConnectPeerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateConnectPeerInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.ConnectPeerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectPeerId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateCustomerGatewayInput(v *DisassociateCustomerGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateCustomerGatewayInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.CustomerGatewayArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("CustomerGatewayArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateLinkInput(v *DisassociateLinkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateLinkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if v.LinkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("LinkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateTransitGatewayConnectPeerInput(v *DisassociateTransitGatewayConnectPeerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateTransitGatewayConnectPeerInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.TransitGatewayConnectPeerArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayConnectPeerArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpExecuteCoreNetworkChangeSetInput(v *ExecuteCoreNetworkChangeSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExecuteCoreNetworkChangeSetInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.PolicyVersionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyVersionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetConnectAttachmentInput(v *GetConnectAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetConnectAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetConnectionsInput(v *GetConnectionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetConnectionsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetConnectPeerAssociationsInput(v *GetConnectPeerAssociationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetConnectPeerAssociationsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetConnectPeerInput(v *GetConnectPeerInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetConnectPeerInput"}
if v.ConnectPeerId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectPeerId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetCoreNetworkChangeEventsInput(v *GetCoreNetworkChangeEventsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetCoreNetworkChangeEventsInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.PolicyVersionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyVersionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetCoreNetworkChangeSetInput(v *GetCoreNetworkChangeSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetCoreNetworkChangeSetInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.PolicyVersionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyVersionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetCoreNetworkInput(v *GetCoreNetworkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetCoreNetworkInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetCoreNetworkPolicyInput(v *GetCoreNetworkPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetCoreNetworkPolicyInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetCustomerGatewayAssociationsInput(v *GetCustomerGatewayAssociationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetCustomerGatewayAssociationsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetDevicesInput(v *GetDevicesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDevicesInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetLinkAssociationsInput(v *GetLinkAssociationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetLinkAssociationsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetLinksInput(v *GetLinksInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetLinksInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetNetworkResourceCountsInput(v *GetNetworkResourceCountsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetNetworkResourceCountsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetNetworkResourceRelationshipsInput(v *GetNetworkResourceRelationshipsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetNetworkResourceRelationshipsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetNetworkResourcesInput(v *GetNetworkResourcesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetNetworkResourcesInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetNetworkRoutesInput(v *GetNetworkRoutesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetNetworkRoutesInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.RouteTableIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("RouteTableIdentifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetNetworkTelemetryInput(v *GetNetworkTelemetryInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetNetworkTelemetryInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetResourcePolicyInput(v *GetResourcePolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetResourcePolicyInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetRouteAnalysisInput(v *GetRouteAnalysisInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetRouteAnalysisInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.RouteAnalysisId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RouteAnalysisId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSitesInput(v *GetSitesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSitesInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSiteToSiteVpnAttachmentInput(v *GetSiteToSiteVpnAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSiteToSiteVpnAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTransitGatewayConnectPeerAssociationsInput(v *GetTransitGatewayConnectPeerAssociationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayConnectPeerAssociationsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTransitGatewayPeeringInput(v *GetTransitGatewayPeeringInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayPeeringInput"}
if v.PeeringId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PeeringId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTransitGatewayRegistrationsInput(v *GetTransitGatewayRegistrationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayRegistrationsInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTransitGatewayRouteTableAttachmentInput(v *GetTransitGatewayRouteTableAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayRouteTableAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetVpcAttachmentInput(v *GetVpcAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetVpcAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListCoreNetworkPolicyVersionsInput(v *ListCoreNetworkPolicyVersionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListCoreNetworkPolicyVersionsInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
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 validateOpPutCoreNetworkPolicyInput(v *PutCoreNetworkPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutCoreNetworkPolicyInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.PolicyDocument == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyDocument"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutResourcePolicyInput(v *PutResourcePolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutResourcePolicyInput"}
if v.PolicyDocument == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyDocument"))
}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRegisterTransitGatewayInput(v *RegisterTransitGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RegisterTransitGatewayInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.TransitGatewayArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRejectAttachmentInput(v *RejectAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RejectAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRestoreCoreNetworkPolicyVersionInput(v *RestoreCoreNetworkPolicyVersionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RestoreCoreNetworkPolicyVersionInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if v.PolicyVersionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyVersionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartOrganizationServiceAccessUpdateInput(v *StartOrganizationServiceAccessUpdateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartOrganizationServiceAccessUpdateInput"}
if v.Action == nil {
invalidParams.Add(smithy.NewErrParamRequired("Action"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartRouteAnalysisInput(v *StartRouteAnalysisInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartRouteAnalysisInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.Source == nil {
invalidParams.Add(smithy.NewErrParamRequired("Source"))
}
if v.Destination == nil {
invalidParams.Add(smithy.NewErrParamRequired("Destination"))
}
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"))
}
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 validateOpUpdateConnectionInput(v *UpdateConnectionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.ConnectionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateCoreNetworkInput(v *UpdateCoreNetworkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateCoreNetworkInput"}
if v.CoreNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("CoreNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateDeviceInput(v *UpdateDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateDeviceInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.DeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateGlobalNetworkInput(v *UpdateGlobalNetworkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateGlobalNetworkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateLinkInput(v *UpdateLinkInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateLinkInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.LinkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("LinkId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateNetworkResourceMetadataInput(v *UpdateNetworkResourceMetadataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateNetworkResourceMetadataInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.Metadata == nil {
invalidParams.Add(smithy.NewErrParamRequired("Metadata"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSiteInput(v *UpdateSiteInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSiteInput"}
if v.GlobalNetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GlobalNetworkId"))
}
if v.SiteId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SiteId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateVpcAttachmentInput(v *UpdateVpcAttachmentInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateVpcAttachmentInput"}
if v.AttachmentId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 3,209 |
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 NetworkManager 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: "networkmanager.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "networkmanager-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "networkmanager-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "networkmanager.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: false,
PartitionEndpoint: "aws-global",
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "aws-global",
}: endpoints.Endpoint{
Hostname: "networkmanager.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "networkmanager.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "networkmanager-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "networkmanager-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "networkmanager.{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: "networkmanager-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "networkmanager.{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: "networkmanager-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "networkmanager.{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: "networkmanager-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "networkmanager.{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: "networkmanager-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "networkmanager.{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: "networkmanager.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "networkmanager-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "networkmanager-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "networkmanager.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: false,
PartitionEndpoint: "aws-us-gov-global",
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "aws-us-gov-global",
}: endpoints.Endpoint{
Hostname: "networkmanager.us-gov-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-gov-west-1",
},
},
},
},
}
| 319 |
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 AttachmentState string
// Enum values for AttachmentState
const (
AttachmentStateRejected AttachmentState = "REJECTED"
AttachmentStatePendingAttachmentAcceptance AttachmentState = "PENDING_ATTACHMENT_ACCEPTANCE"
AttachmentStateCreating AttachmentState = "CREATING"
AttachmentStateFailed AttachmentState = "FAILED"
AttachmentStateAvailable AttachmentState = "AVAILABLE"
AttachmentStateUpdating AttachmentState = "UPDATING"
AttachmentStatePendingNetworkUpdate AttachmentState = "PENDING_NETWORK_UPDATE"
AttachmentStatePendingTagAcceptance AttachmentState = "PENDING_TAG_ACCEPTANCE"
AttachmentStateDeleting AttachmentState = "DELETING"
)
// Values returns all known values for AttachmentState. 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 (AttachmentState) Values() []AttachmentState {
return []AttachmentState{
"REJECTED",
"PENDING_ATTACHMENT_ACCEPTANCE",
"CREATING",
"FAILED",
"AVAILABLE",
"UPDATING",
"PENDING_NETWORK_UPDATE",
"PENDING_TAG_ACCEPTANCE",
"DELETING",
}
}
type AttachmentType string
// Enum values for AttachmentType
const (
AttachmentTypeConnect AttachmentType = "CONNECT"
AttachmentTypeSiteToSiteVpn AttachmentType = "SITE_TO_SITE_VPN"
AttachmentTypeVpc AttachmentType = "VPC"
AttachmentTypeTransitGatewayRouteTable AttachmentType = "TRANSIT_GATEWAY_ROUTE_TABLE"
)
// Values returns all known values for AttachmentType. 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 (AttachmentType) Values() []AttachmentType {
return []AttachmentType{
"CONNECT",
"SITE_TO_SITE_VPN",
"VPC",
"TRANSIT_GATEWAY_ROUTE_TABLE",
}
}
type ChangeAction string
// Enum values for ChangeAction
const (
ChangeActionAdd ChangeAction = "ADD"
ChangeActionModify ChangeAction = "MODIFY"
ChangeActionRemove ChangeAction = "REMOVE"
)
// Values returns all known values for ChangeAction. 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 (ChangeAction) Values() []ChangeAction {
return []ChangeAction{
"ADD",
"MODIFY",
"REMOVE",
}
}
type ChangeSetState string
// Enum values for ChangeSetState
const (
ChangeSetStatePendingGeneration ChangeSetState = "PENDING_GENERATION"
ChangeSetStateFailedGeneration ChangeSetState = "FAILED_GENERATION"
ChangeSetStateReadyToExecute ChangeSetState = "READY_TO_EXECUTE"
ChangeSetStateExecuting ChangeSetState = "EXECUTING"
ChangeSetStateExecutionSucceeded ChangeSetState = "EXECUTION_SUCCEEDED"
ChangeSetStateOutOfDate ChangeSetState = "OUT_OF_DATE"
)
// Values returns all known values for ChangeSetState. 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 (ChangeSetState) Values() []ChangeSetState {
return []ChangeSetState{
"PENDING_GENERATION",
"FAILED_GENERATION",
"READY_TO_EXECUTE",
"EXECUTING",
"EXECUTION_SUCCEEDED",
"OUT_OF_DATE",
}
}
type ChangeStatus string
// Enum values for ChangeStatus
const (
ChangeStatusNotStarted ChangeStatus = "NOT_STARTED"
ChangeStatusInProgress ChangeStatus = "IN_PROGRESS"
ChangeStatusComplete ChangeStatus = "COMPLETE"
ChangeStatusFailed ChangeStatus = "FAILED"
)
// Values returns all known values for ChangeStatus. 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 (ChangeStatus) Values() []ChangeStatus {
return []ChangeStatus{
"NOT_STARTED",
"IN_PROGRESS",
"COMPLETE",
"FAILED",
}
}
type ChangeType string
// Enum values for ChangeType
const (
ChangeTypeCoreNetworkSegment ChangeType = "CORE_NETWORK_SEGMENT"
ChangeTypeCoreNetworkEdge ChangeType = "CORE_NETWORK_EDGE"
ChangeTypeAttachmentMapping ChangeType = "ATTACHMENT_MAPPING"
ChangeTypeAttachmentRoutePropagation ChangeType = "ATTACHMENT_ROUTE_PROPAGATION"
ChangeTypeAttachmentRouteStatic ChangeType = "ATTACHMENT_ROUTE_STATIC"
ChangeTypeCoreNetworkConfiguration ChangeType = "CORE_NETWORK_CONFIGURATION"
ChangeTypeSegmentsConfiguration ChangeType = "SEGMENTS_CONFIGURATION"
ChangeTypeSegmentActionsConfiguration ChangeType = "SEGMENT_ACTIONS_CONFIGURATION"
ChangeTypeAttachmentPoliciesConfiguration ChangeType = "ATTACHMENT_POLICIES_CONFIGURATION"
)
// Values returns all known values for ChangeType. 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 (ChangeType) Values() []ChangeType {
return []ChangeType{
"CORE_NETWORK_SEGMENT",
"CORE_NETWORK_EDGE",
"ATTACHMENT_MAPPING",
"ATTACHMENT_ROUTE_PROPAGATION",
"ATTACHMENT_ROUTE_STATIC",
"CORE_NETWORK_CONFIGURATION",
"SEGMENTS_CONFIGURATION",
"SEGMENT_ACTIONS_CONFIGURATION",
"ATTACHMENT_POLICIES_CONFIGURATION",
}
}
type ConnectionState string
// Enum values for ConnectionState
const (
ConnectionStatePending ConnectionState = "PENDING"
ConnectionStateAvailable ConnectionState = "AVAILABLE"
ConnectionStateDeleting ConnectionState = "DELETING"
ConnectionStateUpdating ConnectionState = "UPDATING"
)
// Values returns all known values for ConnectionState. 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 (ConnectionState) Values() []ConnectionState {
return []ConnectionState{
"PENDING",
"AVAILABLE",
"DELETING",
"UPDATING",
}
}
type ConnectionStatus string
// Enum values for ConnectionStatus
const (
ConnectionStatusUp ConnectionStatus = "UP"
ConnectionStatusDown ConnectionStatus = "DOWN"
)
// Values returns all known values for ConnectionStatus. 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 (ConnectionStatus) Values() []ConnectionStatus {
return []ConnectionStatus{
"UP",
"DOWN",
}
}
type ConnectionType string
// Enum values for ConnectionType
const (
ConnectionTypeBgp ConnectionType = "BGP"
ConnectionTypeIpsec ConnectionType = "IPSEC"
)
// Values returns all known values for ConnectionType. 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 (ConnectionType) Values() []ConnectionType {
return []ConnectionType{
"BGP",
"IPSEC",
}
}
type ConnectPeerAssociationState string
// Enum values for ConnectPeerAssociationState
const (
ConnectPeerAssociationStatePending ConnectPeerAssociationState = "PENDING"
ConnectPeerAssociationStateAvailable ConnectPeerAssociationState = "AVAILABLE"
ConnectPeerAssociationStateDeleting ConnectPeerAssociationState = "DELETING"
ConnectPeerAssociationStateDeleted ConnectPeerAssociationState = "DELETED"
)
// Values returns all known values for ConnectPeerAssociationState. 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 (ConnectPeerAssociationState) Values() []ConnectPeerAssociationState {
return []ConnectPeerAssociationState{
"PENDING",
"AVAILABLE",
"DELETING",
"DELETED",
}
}
type ConnectPeerState string
// Enum values for ConnectPeerState
const (
ConnectPeerStateCreating ConnectPeerState = "CREATING"
ConnectPeerStateFailed ConnectPeerState = "FAILED"
ConnectPeerStateAvailable ConnectPeerState = "AVAILABLE"
ConnectPeerStateDeleting ConnectPeerState = "DELETING"
)
// Values returns all known values for ConnectPeerState. 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 (ConnectPeerState) Values() []ConnectPeerState {
return []ConnectPeerState{
"CREATING",
"FAILED",
"AVAILABLE",
"DELETING",
}
}
type CoreNetworkPolicyAlias string
// Enum values for CoreNetworkPolicyAlias
const (
CoreNetworkPolicyAliasLive CoreNetworkPolicyAlias = "LIVE"
CoreNetworkPolicyAliasLatest CoreNetworkPolicyAlias = "LATEST"
)
// Values returns all known values for CoreNetworkPolicyAlias. 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 (CoreNetworkPolicyAlias) Values() []CoreNetworkPolicyAlias {
return []CoreNetworkPolicyAlias{
"LIVE",
"LATEST",
}
}
type CoreNetworkState string
// Enum values for CoreNetworkState
const (
CoreNetworkStateCreating CoreNetworkState = "CREATING"
CoreNetworkStateUpdating CoreNetworkState = "UPDATING"
CoreNetworkStateAvailable CoreNetworkState = "AVAILABLE"
CoreNetworkStateDeleting CoreNetworkState = "DELETING"
)
// Values returns all known values for CoreNetworkState. 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 (CoreNetworkState) Values() []CoreNetworkState {
return []CoreNetworkState{
"CREATING",
"UPDATING",
"AVAILABLE",
"DELETING",
}
}
type CustomerGatewayAssociationState string
// Enum values for CustomerGatewayAssociationState
const (
CustomerGatewayAssociationStatePending CustomerGatewayAssociationState = "PENDING"
CustomerGatewayAssociationStateAvailable CustomerGatewayAssociationState = "AVAILABLE"
CustomerGatewayAssociationStateDeleting CustomerGatewayAssociationState = "DELETING"
CustomerGatewayAssociationStateDeleted CustomerGatewayAssociationState = "DELETED"
)
// Values returns all known values for CustomerGatewayAssociationState. 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 (CustomerGatewayAssociationState) Values() []CustomerGatewayAssociationState {
return []CustomerGatewayAssociationState{
"PENDING",
"AVAILABLE",
"DELETING",
"DELETED",
}
}
type DeviceState string
// Enum values for DeviceState
const (
DeviceStatePending DeviceState = "PENDING"
DeviceStateAvailable DeviceState = "AVAILABLE"
DeviceStateDeleting DeviceState = "DELETING"
DeviceStateUpdating DeviceState = "UPDATING"
)
// Values returns all known values for DeviceState. 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 (DeviceState) Values() []DeviceState {
return []DeviceState{
"PENDING",
"AVAILABLE",
"DELETING",
"UPDATING",
}
}
type GlobalNetworkState string
// Enum values for GlobalNetworkState
const (
GlobalNetworkStatePending GlobalNetworkState = "PENDING"
GlobalNetworkStateAvailable GlobalNetworkState = "AVAILABLE"
GlobalNetworkStateDeleting GlobalNetworkState = "DELETING"
GlobalNetworkStateUpdating GlobalNetworkState = "UPDATING"
)
// Values returns all known values for GlobalNetworkState. 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 (GlobalNetworkState) Values() []GlobalNetworkState {
return []GlobalNetworkState{
"PENDING",
"AVAILABLE",
"DELETING",
"UPDATING",
}
}
type LinkAssociationState string
// Enum values for LinkAssociationState
const (
LinkAssociationStatePending LinkAssociationState = "PENDING"
LinkAssociationStateAvailable LinkAssociationState = "AVAILABLE"
LinkAssociationStateDeleting LinkAssociationState = "DELETING"
LinkAssociationStateDeleted LinkAssociationState = "DELETED"
)
// Values returns all known values for LinkAssociationState. 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 (LinkAssociationState) Values() []LinkAssociationState {
return []LinkAssociationState{
"PENDING",
"AVAILABLE",
"DELETING",
"DELETED",
}
}
type LinkState string
// Enum values for LinkState
const (
LinkStatePending LinkState = "PENDING"
LinkStateAvailable LinkState = "AVAILABLE"
LinkStateDeleting LinkState = "DELETING"
LinkStateUpdating LinkState = "UPDATING"
)
// Values returns all known values for LinkState. 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 (LinkState) Values() []LinkState {
return []LinkState{
"PENDING",
"AVAILABLE",
"DELETING",
"UPDATING",
}
}
type PeeringState string
// Enum values for PeeringState
const (
PeeringStateCreating PeeringState = "CREATING"
PeeringStateFailed PeeringState = "FAILED"
PeeringStateAvailable PeeringState = "AVAILABLE"
PeeringStateDeleting PeeringState = "DELETING"
)
// Values returns all known values for PeeringState. 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 (PeeringState) Values() []PeeringState {
return []PeeringState{
"CREATING",
"FAILED",
"AVAILABLE",
"DELETING",
}
}
type PeeringType string
// Enum values for PeeringType
const (
PeeringTypeTransitGateway PeeringType = "TRANSIT_GATEWAY"
)
// Values returns all known values for PeeringType. 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 (PeeringType) Values() []PeeringType {
return []PeeringType{
"TRANSIT_GATEWAY",
}
}
type RouteAnalysisCompletionReasonCode string
// Enum values for RouteAnalysisCompletionReasonCode
const (
RouteAnalysisCompletionReasonCodeTransitGatewayAttachmentNotFound RouteAnalysisCompletionReasonCode = "TRANSIT_GATEWAY_ATTACHMENT_NOT_FOUND"
RouteAnalysisCompletionReasonCodeTransitGatewayAttachmentNotInTransitGateway RouteAnalysisCompletionReasonCode = "TRANSIT_GATEWAY_ATTACHMENT_NOT_IN_TRANSIT_GATEWAY"
RouteAnalysisCompletionReasonCodeCyclicPathDetected RouteAnalysisCompletionReasonCode = "CYCLIC_PATH_DETECTED"
RouteAnalysisCompletionReasonCodeTransitGatewayAttachmentStableRouteTableNotFound RouteAnalysisCompletionReasonCode = "TRANSIT_GATEWAY_ATTACHMENT_STABLE_ROUTE_TABLE_NOT_FOUND"
RouteAnalysisCompletionReasonCodeRouteNotFound RouteAnalysisCompletionReasonCode = "ROUTE_NOT_FOUND"
RouteAnalysisCompletionReasonCodeBlackholeRouteForDestinationFound RouteAnalysisCompletionReasonCode = "BLACKHOLE_ROUTE_FOR_DESTINATION_FOUND"
RouteAnalysisCompletionReasonCodeInactiveRouteForDestinationFound RouteAnalysisCompletionReasonCode = "INACTIVE_ROUTE_FOR_DESTINATION_FOUND"
RouteAnalysisCompletionReasonCodeTransitGatewayAttachment RouteAnalysisCompletionReasonCode = "TRANSIT_GATEWAY_ATTACHMENT_ATTACH_ARN_NO_MATCH"
RouteAnalysisCompletionReasonCodeMaxHopsExceeded RouteAnalysisCompletionReasonCode = "MAX_HOPS_EXCEEDED"
RouteAnalysisCompletionReasonCodePossibleMiddlebox RouteAnalysisCompletionReasonCode = "POSSIBLE_MIDDLEBOX"
RouteAnalysisCompletionReasonCodeNoDestinationArnProvided RouteAnalysisCompletionReasonCode = "NO_DESTINATION_ARN_PROVIDED"
)
// Values returns all known values for RouteAnalysisCompletionReasonCode. 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 (RouteAnalysisCompletionReasonCode) Values() []RouteAnalysisCompletionReasonCode {
return []RouteAnalysisCompletionReasonCode{
"TRANSIT_GATEWAY_ATTACHMENT_NOT_FOUND",
"TRANSIT_GATEWAY_ATTACHMENT_NOT_IN_TRANSIT_GATEWAY",
"CYCLIC_PATH_DETECTED",
"TRANSIT_GATEWAY_ATTACHMENT_STABLE_ROUTE_TABLE_NOT_FOUND",
"ROUTE_NOT_FOUND",
"BLACKHOLE_ROUTE_FOR_DESTINATION_FOUND",
"INACTIVE_ROUTE_FOR_DESTINATION_FOUND",
"TRANSIT_GATEWAY_ATTACHMENT_ATTACH_ARN_NO_MATCH",
"MAX_HOPS_EXCEEDED",
"POSSIBLE_MIDDLEBOX",
"NO_DESTINATION_ARN_PROVIDED",
}
}
type RouteAnalysisCompletionResultCode string
// Enum values for RouteAnalysisCompletionResultCode
const (
RouteAnalysisCompletionResultCodeConnected RouteAnalysisCompletionResultCode = "CONNECTED"
RouteAnalysisCompletionResultCodeNotConnected RouteAnalysisCompletionResultCode = "NOT_CONNECTED"
)
// Values returns all known values for RouteAnalysisCompletionResultCode. 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 (RouteAnalysisCompletionResultCode) Values() []RouteAnalysisCompletionResultCode {
return []RouteAnalysisCompletionResultCode{
"CONNECTED",
"NOT_CONNECTED",
}
}
type RouteAnalysisStatus string
// Enum values for RouteAnalysisStatus
const (
RouteAnalysisStatusRunning RouteAnalysisStatus = "RUNNING"
RouteAnalysisStatusCompleted RouteAnalysisStatus = "COMPLETED"
RouteAnalysisStatusFailed RouteAnalysisStatus = "FAILED"
)
// Values returns all known values for RouteAnalysisStatus. 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 (RouteAnalysisStatus) Values() []RouteAnalysisStatus {
return []RouteAnalysisStatus{
"RUNNING",
"COMPLETED",
"FAILED",
}
}
type RouteState string
// Enum values for RouteState
const (
RouteStateActive RouteState = "ACTIVE"
RouteStateBlackhole RouteState = "BLACKHOLE"
)
// Values returns all known values for RouteState. 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 (RouteState) Values() []RouteState {
return []RouteState{
"ACTIVE",
"BLACKHOLE",
}
}
type RouteTableType string
// Enum values for RouteTableType
const (
RouteTableTypeTransitGatewayRouteTable RouteTableType = "TRANSIT_GATEWAY_ROUTE_TABLE"
RouteTableTypeCoreNetworkSegment RouteTableType = "CORE_NETWORK_SEGMENT"
)
// Values returns all known values for RouteTableType. 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 (RouteTableType) Values() []RouteTableType {
return []RouteTableType{
"TRANSIT_GATEWAY_ROUTE_TABLE",
"CORE_NETWORK_SEGMENT",
}
}
type RouteType string
// Enum values for RouteType
const (
RouteTypePropagated RouteType = "PROPAGATED"
RouteTypeStatic RouteType = "STATIC"
)
// Values returns all known values for RouteType. 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 (RouteType) Values() []RouteType {
return []RouteType{
"PROPAGATED",
"STATIC",
}
}
type SiteState string
// Enum values for SiteState
const (
SiteStatePending SiteState = "PENDING"
SiteStateAvailable SiteState = "AVAILABLE"
SiteStateDeleting SiteState = "DELETING"
SiteStateUpdating SiteState = "UPDATING"
)
// Values returns all known values for SiteState. 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 (SiteState) Values() []SiteState {
return []SiteState{
"PENDING",
"AVAILABLE",
"DELETING",
"UPDATING",
}
}
type TransitGatewayConnectPeerAssociationState string
// Enum values for TransitGatewayConnectPeerAssociationState
const (
TransitGatewayConnectPeerAssociationStatePending TransitGatewayConnectPeerAssociationState = "PENDING"
TransitGatewayConnectPeerAssociationStateAvailable TransitGatewayConnectPeerAssociationState = "AVAILABLE"
TransitGatewayConnectPeerAssociationStateDeleting TransitGatewayConnectPeerAssociationState = "DELETING"
TransitGatewayConnectPeerAssociationStateDeleted TransitGatewayConnectPeerAssociationState = "DELETED"
)
// Values returns all known values for TransitGatewayConnectPeerAssociationState.
// 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 (TransitGatewayConnectPeerAssociationState) Values() []TransitGatewayConnectPeerAssociationState {
return []TransitGatewayConnectPeerAssociationState{
"PENDING",
"AVAILABLE",
"DELETING",
"DELETED",
}
}
type TransitGatewayRegistrationState string
// Enum values for TransitGatewayRegistrationState
const (
TransitGatewayRegistrationStatePending TransitGatewayRegistrationState = "PENDING"
TransitGatewayRegistrationStateAvailable TransitGatewayRegistrationState = "AVAILABLE"
TransitGatewayRegistrationStateDeleting TransitGatewayRegistrationState = "DELETING"
TransitGatewayRegistrationStateDeleted TransitGatewayRegistrationState = "DELETED"
TransitGatewayRegistrationStateFailed TransitGatewayRegistrationState = "FAILED"
)
// Values returns all known values for TransitGatewayRegistrationState. 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 (TransitGatewayRegistrationState) Values() []TransitGatewayRegistrationState {
return []TransitGatewayRegistrationState{
"PENDING",
"AVAILABLE",
"DELETING",
"DELETED",
"FAILED",
}
}
type TunnelProtocol string
// Enum values for TunnelProtocol
const (
TunnelProtocolGre TunnelProtocol = "GRE"
)
// Values returns all known values for TunnelProtocol. 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 (TunnelProtocol) Values() []TunnelProtocol {
return []TunnelProtocol{
"GRE",
}
}
type ValidationExceptionReason string
// Enum values for ValidationExceptionReason
const (
ValidationExceptionReasonUnknownOperation ValidationExceptionReason = "UnknownOperation"
ValidationExceptionReasonCannotParse ValidationExceptionReason = "CannotParse"
ValidationExceptionReasonFieldValidationFailed ValidationExceptionReason = "FieldValidationFailed"
ValidationExceptionReasonOther ValidationExceptionReason = "Other"
)
// Values returns all known values for ValidationExceptionReason. 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 (ValidationExceptionReason) Values() []ValidationExceptionReason {
return []ValidationExceptionReason{
"UnknownOperation",
"CannotParse",
"FieldValidationFailed",
"Other",
}
}
| 687 |
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 }
// There was a conflict processing the request. Updating or deleting the resource
// can cause an inconsistent state.
type ConflictException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
ResourceType *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 }
// Describes a core network policy exception.
type CoreNetworkPolicyException struct {
Message *string
ErrorCodeOverride *string
Errors []CoreNetworkPolicyError
noSmithyDocumentSerde
}
func (e *CoreNetworkPolicyException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *CoreNetworkPolicyException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *CoreNetworkPolicyException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "CoreNetworkPolicyException"
}
return *e.ErrorCodeOverride
}
func (e *CoreNetworkPolicyException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request has failed due to an internal error.
type InternalServerException struct {
Message *string
ErrorCodeOverride *string
RetryAfterSeconds *int32
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 specified resource could not be found.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
ResourceType *string
Context map[string]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 }
// A service limit was exceeded.
type ServiceQuotaExceededException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
ResourceType *string
LimitCode *string
ServiceCode *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 request was denied due to request throttling.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *string
RetryAfterSeconds *int32
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 input fails to satisfy the constraints.
type ValidationException struct {
Message *string
ErrorCodeOverride *string
Reason ValidationExceptionReason
Fields []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 }
| 239 |
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"
"time"
)
// Describes the current status of an account within an Amazon Web Services
// Organization, including service-linked roles (SLRs).
type AccountStatus struct {
// The ID of an account within the Amazon Web Services Organization.
AccountId *string
// The status of SLR deployment for the account.
SLRDeploymentStatus *string
noSmithyDocumentSerde
}
// Describes a core network attachment.
type Attachment struct {
// The ID of the attachment.
AttachmentId *string
// The policy rule number associated with the attachment.
AttachmentPolicyRuleNumber *int32
// The type of attachment.
AttachmentType AttachmentType
// The ARN of a core network.
CoreNetworkArn *string
// The ID of a core network.
CoreNetworkId *string
// The timestamp when the attachment was created.
CreatedAt *time.Time
// The Region where the edge is located.
EdgeLocation *string
// The ID of the attachment account owner.
OwnerAccountId *string
// The attachment to move from one segment to another.
ProposedSegmentChange *ProposedSegmentChange
// The attachment resource ARN.
ResourceArn *string
// The name of the segment attachment.
SegmentName *string
// The state of the attachment.
State AttachmentState
// The tags associated with the attachment.
Tags []Tag
// The timestamp when the attachment was last updated.
UpdatedAt *time.Time
noSmithyDocumentSerde
}
// Specifies a location in Amazon Web Services.
type AWSLocation struct {
// The Amazon Resource Name (ARN) of the subnet that the device is located in.
SubnetArn *string
// The Zone that the device is located in. Specify the ID of an Availability Zone,
// Local Zone, Wavelength Zone, or an Outpost.
Zone *string
noSmithyDocumentSerde
}
// Describes bandwidth information.
type Bandwidth struct {
// Download speed in Mbps.
DownloadSpeed *int32
// Upload speed in Mbps.
UploadSpeed *int32
noSmithyDocumentSerde
}
// Describes the BGP options.
type BgpOptions struct {
// The Peer ASN of the BGP.
PeerAsn *int64
noSmithyDocumentSerde
}
// Describes a core network Connect attachment.
type ConnectAttachment struct {
// The attachment details.
Attachment *Attachment
// Options for connecting an attachment.
Options *ConnectAttachmentOptions
// The ID of the transport attachment.
TransportAttachmentId *string
noSmithyDocumentSerde
}
// Describes a core network Connect attachment options.
type ConnectAttachmentOptions struct {
// The protocol used for the attachment connection.
Protocol TunnelProtocol
noSmithyDocumentSerde
}
// Describes a connection.
type Connection struct {
// The ID of the second device in the connection.
ConnectedDeviceId *string
// The ID of the link for the second device in the connection.
ConnectedLinkId *string
// The Amazon Resource Name (ARN) of the connection.
ConnectionArn *string
// The ID of the connection.
ConnectionId *string
// The date and time that the connection was created.
CreatedAt *time.Time
// The description of the connection.
Description *string
// The ID of the first device in the connection.
DeviceId *string
// The ID of the global network.
GlobalNetworkId *string
// The ID of the link for the first device in the connection.
LinkId *string
// The state of the connection.
State ConnectionState
// The tags for the connection.
Tags []Tag
noSmithyDocumentSerde
}
// Describes connection health.
type ConnectionHealth struct {
// The connection status.
Status ConnectionStatus
// The time the status was last updated.
Timestamp *time.Time
// The connection type.
Type ConnectionType
noSmithyDocumentSerde
}
// Describes a core network Connect peer.
type ConnectPeer struct {
// The configuration of the Connect peer.
Configuration *ConnectPeerConfiguration
// The ID of the attachment to connect.
ConnectAttachmentId *string
// The ID of the Connect peer.
ConnectPeerId *string
// The ID of a core network.
CoreNetworkId *string
// The timestamp when the Connect peer was created.
CreatedAt *time.Time
// The Connect peer Regions where edges are located.
EdgeLocation *string
// The state of the Connect peer.
State ConnectPeerState
// The list of key-value tags associated with the Connect peer.
Tags []Tag
noSmithyDocumentSerde
}
// Describes a core network Connect peer association.
type ConnectPeerAssociation struct {
// The ID of the Connect peer.
ConnectPeerId *string
// The ID of the device to connect to.
DeviceId *string
// The ID of the global network.
GlobalNetworkId *string
// The ID of the link.
LinkId *string
// The state of the Connect peer association.
State ConnectPeerAssociationState
noSmithyDocumentSerde
}
// Describes a core network BGP configuration.
type ConnectPeerBgpConfiguration struct {
// The address of a core network.
CoreNetworkAddress *string
// The ASN of the Coret Network.
CoreNetworkAsn *int64
// The address of a core network Connect peer.
PeerAddress *string
// The ASN of the Connect peer.
PeerAsn *int64
noSmithyDocumentSerde
}
// Describes a core network Connect peer configuration.
type ConnectPeerConfiguration struct {
// The Connect peer BGP configurations.
BgpConfigurations []ConnectPeerBgpConfiguration
// The IP address of a core network.
CoreNetworkAddress *string
// The inside IP addresses used for a Connect peer configuration.
InsideCidrBlocks []string
// The IP address of the Connect peer.
PeerAddress *string
// The protocol used for a Connect peer configuration.
Protocol TunnelProtocol
noSmithyDocumentSerde
}
// Summary description of a Connect peer.
type ConnectPeerSummary struct {
// The ID of a Connect peer attachment.
ConnectAttachmentId *string
// The ID of a Connect peer.
ConnectPeerId *string
// The state of a Connect peer.
ConnectPeerState ConnectPeerState
// The ID of a core network.
CoreNetworkId *string
// The timestamp when a Connect peer was created.
CreatedAt *time.Time
// The Region where the edge is located.
EdgeLocation *string
// The list of key-value tags associated with the Connect peer summary.
Tags []Tag
noSmithyDocumentSerde
}
// Describes a core network.
type CoreNetwork struct {
// The ARN of a core network.
CoreNetworkArn *string
// The ID of a core network.
CoreNetworkId *string
// The timestamp when a core network was created.
CreatedAt *time.Time
// The description of a core network.
Description *string
// The edges within a core network.
Edges []CoreNetworkEdge
// The ID of the global network that your core network is a part of.
GlobalNetworkId *string
// The segments within a core network.
Segments []CoreNetworkSegment
// The current state of a core network.
State CoreNetworkState
// The list of key-value tags associated with a core network.
Tags []Tag
noSmithyDocumentSerde
}
// Details describing a core network change.
type CoreNetworkChange struct {
// The action to take for a core network.
Action ChangeAction
// The resource identifier.
Identifier *string
// Uniquely identifies the path for a change within the changeset. For example,
// the IdentifierPath for a core network segment change might be
// "CORE_NETWORK_SEGMENT/us-east-1/devsegment" .
IdentifierPath *string
// The new value for a core network
NewValues *CoreNetworkChangeValues
// The previous values for a core network.
PreviousValues *CoreNetworkChangeValues
// The type of change.
Type ChangeType
noSmithyDocumentSerde
}
// Describes a core network change event. This can be a change to a segment,
// attachment, route, etc.
type CoreNetworkChangeEvent struct {
// The action taken for the change event.
Action ChangeAction
// The timestamp for an event change in status.
EventTime *time.Time
// Uniquely identifies the path for a change within the changeset. For example,
// the IdentifierPath for a core network segment change might be
// "CORE_NETWORK_SEGMENT/us-east-1/devsegment" .
IdentifierPath *string
// The status of the core network change event.
Status ChangeStatus
// Describes the type of change event.
Type ChangeType
// Details of the change event.
Values *CoreNetworkChangeEventValues
noSmithyDocumentSerde
}
// Describes a core network change event.
type CoreNetworkChangeEventValues struct {
// The ID of the attachment if the change event is associated with an attachment.
AttachmentId *string
// For a STATIC_ROUTE event, this is the IP address.
Cidr *string
// The edge location for the core network change event.
EdgeLocation *string
// The segment name if the change event is associated with a segment.
SegmentName *string
noSmithyDocumentSerde
}
// Describes a core network change.
type CoreNetworkChangeValues struct {
// The ASN of a core network.
Asn *int64
// The IP addresses used for a core network.
Cidr *string
// The ID of the destination.
DestinationIdentifier *string
// The Regions where edges are located in a core network.
EdgeLocations []string
// The inside IP addresses used for core network change values.
InsideCidrBlocks []string
// The names of the segments in a core network.
SegmentName *string
// The shared segments for a core network change value.
SharedSegments []string
noSmithyDocumentSerde
}
// Describes a core network edge.
type CoreNetworkEdge struct {
// The ASN of a core network edge.
Asn *int64
// The Region where a core network edge is located.
EdgeLocation *string
// The inside IP addresses used for core network edges.
InsideCidrBlocks []string
noSmithyDocumentSerde
}
// Describes a core network policy. You can have only one LIVE Core Policy.
type CoreNetworkPolicy struct {
// Whether a core network policy is the current LIVE policy or the most recently
// submitted policy.
Alias CoreNetworkPolicyAlias
// The state of a core network policy.
ChangeSetState ChangeSetState
// The ID of a core network.
CoreNetworkId *string
// The timestamp when a core network policy was created.
CreatedAt *time.Time
// The description of a core network policy.
Description *string
// Describes a core network policy.
//
// This value conforms to the media type: application/json
PolicyDocument *string
// Describes any errors in a core network policy.
PolicyErrors []CoreNetworkPolicyError
// The ID of the policy version.
PolicyVersionId *int32
noSmithyDocumentSerde
}
// Provides details about an error in a core network policy.
type CoreNetworkPolicyError struct {
// The error code associated with a core network policy error.
//
// This member is required.
ErrorCode *string
// The message associated with a core network policy error code.
//
// This member is required.
Message *string
// The JSON path where the error was discovered in the policy document.
Path *string
noSmithyDocumentSerde
}
// Describes a core network policy version.
type CoreNetworkPolicyVersion struct {
// Whether a core network policy is the current policy or the most recently
// submitted policy.
Alias CoreNetworkPolicyAlias
// The status of the policy version change set.
ChangeSetState ChangeSetState
// The ID of a core network.
CoreNetworkId *string
// The timestamp when a core network policy version was created.
CreatedAt *time.Time
// The description of a core network policy version.
Description *string
// The ID of the policy version.
PolicyVersionId *int32
noSmithyDocumentSerde
}
// Describes a core network segment, which are dedicated routes. Only attachments
// within this segment can communicate with each other.
type CoreNetworkSegment struct {
// The Regions where the edges are located.
EdgeLocations []string
// The name of a core network segment.
Name *string
// The shared segments of a core network.
SharedSegments []string
noSmithyDocumentSerde
}
// Returns details about a core network edge.
type CoreNetworkSegmentEdgeIdentifier struct {
// The ID of a core network.
CoreNetworkId *string
// The Region where the segment edge is located.
EdgeLocation *string
// The name of the segment edge.
SegmentName *string
noSmithyDocumentSerde
}
// Returns summary information about a core network.
type CoreNetworkSummary struct {
// a core network ARN.
CoreNetworkArn *string
// The ID of a core network.
CoreNetworkId *string
// The description of a core network.
Description *string
// The global network ID.
GlobalNetworkId *string
// The ID of the account owner.
OwnerAccountId *string
// The state of a core network.
State CoreNetworkState
// The key-value tags associated with a core network summary.
Tags []Tag
noSmithyDocumentSerde
}
// Describes the association between a customer gateway, a device, and a link.
type CustomerGatewayAssociation struct {
// The Amazon Resource Name (ARN) of the customer gateway.
CustomerGatewayArn *string
// The ID of the device.
DeviceId *string
// The ID of the global network.
GlobalNetworkId *string
// The ID of the link.
LinkId *string
// The association state.
State CustomerGatewayAssociationState
noSmithyDocumentSerde
}
// Describes a device.
type Device struct {
// The Amazon Web Services location of the device.
AWSLocation *AWSLocation
// The date and time that the site was created.
CreatedAt *time.Time
// The description of the device.
Description *string
// The Amazon Resource Name (ARN) of the device.
DeviceArn *string
// The ID of the device.
DeviceId *string
// The ID of the global network.
GlobalNetworkId *string
// The site location.
Location *Location
// The device model.
Model *string
// The device serial number.
SerialNumber *string
// The site ID.
SiteId *string
// The device state.
State DeviceState
// The tags for the device.
Tags []Tag
// The device type.
Type *string
// The device vendor.
Vendor *string
noSmithyDocumentSerde
}
// Describes a global network. This is a single private network acting as a
// high-level container for your network objects, including an Amazon Web
// Services-managed Core Network.
type GlobalNetwork struct {
// The date and time that the global network was created.
CreatedAt *time.Time
// The description of the global network.
Description *string
// The Amazon Resource Name (ARN) of the global network.
GlobalNetworkArn *string
// The ID of the global network.
GlobalNetworkId *string
// The state of the global network.
State GlobalNetworkState
// The tags for the global network.
Tags []Tag
noSmithyDocumentSerde
}
// Describes a link.
type Link struct {
// The bandwidth for the link.
Bandwidth *Bandwidth
// The date and time that the link was created.
CreatedAt *time.Time
// The description of the link.
Description *string
// The ID of the global network.
GlobalNetworkId *string
// The Amazon Resource Name (ARN) of the link.
LinkArn *string
// The ID of the link.
LinkId *string
// The provider of the link.
Provider *string
// The ID of the site.
SiteId *string
// The state of the link.
State LinkState
// The tags for the link.
Tags []Tag
// The type of the link.
Type *string
noSmithyDocumentSerde
}
// Describes the association between a device and a link.
type LinkAssociation struct {
// The device ID for the link association.
DeviceId *string
// The ID of the global network.
GlobalNetworkId *string
// The state of the association.
LinkAssociationState LinkAssociationState
// The ID of the link.
LinkId *string
noSmithyDocumentSerde
}
// Describes a location.
type Location struct {
// The physical address.
Address *string
// The latitude.
Latitude *string
// The longitude.
Longitude *string
noSmithyDocumentSerde
}
// Describes a network resource.
type NetworkResource struct {
// The Amazon Web Services account ID.
AccountId *string
// The Amazon Web Services Region.
AwsRegion *string
// The ID of a core network.
CoreNetworkId *string
// Information about the resource, in JSON format. Network Manager gets this
// information by describing the resource using its Describe API call.
Definition *string
// The time that the resource definition was retrieved.
DefinitionTimestamp *time.Time
// The resource metadata.
Metadata map[string]string
// The ARN of the gateway.
RegisteredGatewayArn *string
// The ARN of the resource.
ResourceArn *string
// The ID of the resource.
ResourceId *string
// The resource type. The following are the supported resource types for Direct
// Connect:
// - dxcon
// - dx-gateway
// - dx-vif
// The following are the supported resource types for Network Manager:
// - connection
// - device
// - link
// - site
// The following are the supported resource types for Amazon VPC:
// - customer-gateway
// - transit-gateway
// - transit-gateway-attachment
// - transit-gateway-connect-peer
// - transit-gateway-route-table
// - vpn-connection
ResourceType *string
// The tags.
Tags []Tag
noSmithyDocumentSerde
}
// Describes a resource count.
type NetworkResourceCount struct {
// The resource count.
Count *int32
// The resource type.
ResourceType *string
noSmithyDocumentSerde
}
// Describes a network resource.
type NetworkResourceSummary struct {
// Information about the resource, in JSON format. Network Manager gets this
// information by describing the resource using its Describe API call.
Definition *string
// Indicates whether this is a middlebox appliance.
IsMiddlebox bool
// The value for the Name tag.
NameTag *string
// The ARN of the gateway.
RegisteredGatewayArn *string
// The ARN of the resource.
ResourceArn *string
// The resource type.
ResourceType *string
noSmithyDocumentSerde
}
// Describes a network route.
type NetworkRoute struct {
// A unique identifier for the route, such as a CIDR block.
DestinationCidrBlock *string
// The destinations.
Destinations []NetworkRouteDestination
// The ID of the prefix list.
PrefixListId *string
// The route state. The possible values are active and blackhole .
State RouteState
// The route type. The possible values are propagated and static .
Type RouteType
noSmithyDocumentSerde
}
// Describes the destination of a network route.
type NetworkRouteDestination struct {
// The ID of a core network attachment.
CoreNetworkAttachmentId *string
// The edge location for the network destination.
EdgeLocation *string
// The ID of the resource.
ResourceId *string
// The resource type.
ResourceType *string
// The name of the segment.
SegmentName *string
// The ID of the transit gateway attachment.
TransitGatewayAttachmentId *string
noSmithyDocumentSerde
}
// Describes the telemetry information for a resource.
type NetworkTelemetry struct {
// The Amazon Web Services account ID.
AccountId *string
// The address.
Address *string
// The Amazon Web Services Region.
AwsRegion *string
// The ID of a core network.
CoreNetworkId *string
// The connection health.
Health *ConnectionHealth
// The ARN of the gateway.
RegisteredGatewayArn *string
// The ARN of the resource.
ResourceArn *string
// The ID of the resource.
ResourceId *string
// The resource type.
ResourceType *string
noSmithyDocumentSerde
}
// The status of an Amazon Web Services Organization and the accounts within that
// organization.
type OrganizationStatus struct {
// The current service-linked role (SLR) deployment status for an Amazon Web
// Services Organization's accounts. This will be either SUCCEEDED or IN_PROGRESS .
AccountStatusList []AccountStatus
// The status of the organization's AWS service access. This will be ENABLED or
// DISABLED .
OrganizationAwsServiceAccessStatus *string
// The ID of an Amazon Web Services Organization.
OrganizationId *string
// The status of the SLR deployment for the account. This will be either SUCCEEDED
// or IN_PROGRESS .
SLRDeploymentStatus *string
noSmithyDocumentSerde
}
// Describes a path component.
type PathComponent struct {
// The destination CIDR block in the route table.
DestinationCidrBlock *string
// The resource.
Resource *NetworkResourceSummary
// The sequence number in the path. The destination is 0.
Sequence *int32
noSmithyDocumentSerde
}
// Describes a peering connection.
type Peering struct {
// The ARN of a core network.
CoreNetworkArn *string
// The ID of the core network for the peering request.
CoreNetworkId *string
// The timestamp when the attachment peer was created.
CreatedAt *time.Time
// The edge location for the peer.
EdgeLocation *string
// The ID of the account owner.
OwnerAccountId *string
// The ID of the peering attachment.
PeeringId *string
// The type of peering. This will be TRANSIT_GATEWAY .
PeeringType PeeringType
// The resource ARN of the peer.
ResourceArn *string
// The current state of the peering connection.
State PeeringState
// The list of key-value tags associated with the peering.
Tags []Tag
noSmithyDocumentSerde
}
// Describes a proposed segment change. In some cases, the segment change must
// first be evaluated and accepted.
type ProposedSegmentChange struct {
// The rule number in the policy document that applies to this change.
AttachmentPolicyRuleNumber *int32
// The name of the segment to change.
SegmentName *string
// The list of key-value tags that changed for the segment.
Tags []Tag
noSmithyDocumentSerde
}
// Describes a resource relationship.
type Relationship struct {
// The ARN of the resource.
From *string
// The ARN of the resource.
To *string
noSmithyDocumentSerde
}
// Describes a route analysis.
type RouteAnalysis struct {
// The destination.
Destination *RouteAnalysisEndpointOptions
// The forward path.
ForwardPath *RouteAnalysisPath
// The ID of the global network.
GlobalNetworkId *string
// Indicates whether to analyze the return path. The return path is not analyzed
// if the forward path analysis does not succeed.
IncludeReturnPath bool
// The ID of the AWS account that created the route analysis.
OwnerAccountId *string
// The return path.
ReturnPath *RouteAnalysisPath
// The ID of the route analysis.
RouteAnalysisId *string
// The source.
Source *RouteAnalysisEndpointOptions
// The time that the analysis started.
StartTimestamp *time.Time
// The status of the route analysis.
Status RouteAnalysisStatus
// Indicates whether to include the location of middlebox appliances in the route
// analysis.
UseMiddleboxes bool
noSmithyDocumentSerde
}
// Describes the status of an analysis at completion.
type RouteAnalysisCompletion struct {
// The reason code. Available only if a connection is not found.
// - BLACKHOLE_ROUTE_FOR_DESTINATION_FOUND - Found a black hole route with the
// destination CIDR block.
// - CYCLIC_PATH_DETECTED - Found the same resource multiple times while
// traversing the path.
// - INACTIVE_ROUTE_FOR_DESTINATION_FOUND - Found an inactive route with the
// destination CIDR block.
// - MAX_HOPS_EXCEEDED - Analysis exceeded 64 hops without finding the
// destination.
// - ROUTE_NOT_FOUND - Cannot find a route table with the destination CIDR block.
// - TGW_ATTACH_ARN_NO_MATCH - Found an attachment, but not with the correct
// destination ARN.
// - TGW_ATTACH_NOT_FOUND - Cannot find an attachment.
// - TGW_ATTACH_NOT_IN_TGW - Found an attachment, but not to the correct transit
// gateway.
// - TGW_ATTACH_STABLE_ROUTE_TABLE_NOT_FOUND - The state of the route table
// association is not associated.
ReasonCode RouteAnalysisCompletionReasonCode
// Additional information about the path. Available only if a connection is not
// found.
ReasonContext map[string]string
// The result of the analysis. If the status is NOT_CONNECTED , check the reason
// code.
ResultCode RouteAnalysisCompletionResultCode
noSmithyDocumentSerde
}
// Describes a source or a destination.
type RouteAnalysisEndpointOptions struct {
// The IP address.
IpAddress *string
// The ARN of the transit gateway.
TransitGatewayArn *string
// The ARN of the transit gateway attachment.
TransitGatewayAttachmentArn *string
noSmithyDocumentSerde
}
// Describes a source or a destination.
type RouteAnalysisEndpointOptionsSpecification struct {
// The IP address.
IpAddress *string
// The ARN of the transit gateway attachment.
TransitGatewayAttachmentArn *string
noSmithyDocumentSerde
}
// Describes a route analysis path.
type RouteAnalysisPath struct {
// The status of the analysis at completion.
CompletionStatus *RouteAnalysisCompletion
// The route analysis path.
Path []PathComponent
noSmithyDocumentSerde
}
// Describes a route table.
type RouteTableIdentifier struct {
// The segment edge in a core network.
CoreNetworkSegmentEdge *CoreNetworkSegmentEdgeIdentifier
// The ARN of the transit gateway route table.
TransitGatewayRouteTableArn *string
noSmithyDocumentSerde
}
// Describes a site.
type Site struct {
// The date and time that the site was created.
CreatedAt *time.Time
// The description of the site.
Description *string
// The ID of the global network.
GlobalNetworkId *string
// The location of the site.
Location *Location
// The Amazon Resource Name (ARN) of the site.
SiteArn *string
// The ID of the site.
SiteId *string
// The state of the site.
State SiteState
// The tags for the site.
Tags []Tag
noSmithyDocumentSerde
}
// Creates a site-to-site VPN attachment.
type SiteToSiteVpnAttachment struct {
// Provides details about a site-to-site VPN attachment.
Attachment *Attachment
// The ARN of the site-to-site VPN attachment.
VpnConnectionArn *string
noSmithyDocumentSerde
}
// Describes a tag.
type Tag struct {
// The tag key. Constraints: Maximum length of 128 characters.
Key *string
// The tag value. Constraints: Maximum length of 256 characters.
Value *string
noSmithyDocumentSerde
}
// Describes a transit gateway Connect peer association.
type TransitGatewayConnectPeerAssociation struct {
// The ID of the device.
DeviceId *string
// The ID of the global network.
GlobalNetworkId *string
// The ID of the link.
LinkId *string
// The state of the association.
State TransitGatewayConnectPeerAssociationState
// The Amazon Resource Name (ARN) of the transit gateway Connect peer.
TransitGatewayConnectPeerArn *string
noSmithyDocumentSerde
}
// Describes a transit gateway peering attachment.
type TransitGatewayPeering struct {
// Describes a transit gateway peer connection.
Peering *Peering
// The ARN of the transit gateway.
TransitGatewayArn *string
// The ID of the transit gateway peering attachment.
TransitGatewayPeeringAttachmentId *string
noSmithyDocumentSerde
}
// Describes the registration of a transit gateway to a global network.
type TransitGatewayRegistration struct {
// The ID of the global network.
GlobalNetworkId *string
// The state of the transit gateway registration.
State *TransitGatewayRegistrationStateReason
// The Amazon Resource Name (ARN) of the transit gateway.
TransitGatewayArn *string
noSmithyDocumentSerde
}
// Describes the status of a transit gateway registration.
type TransitGatewayRegistrationStateReason struct {
// The code for the state reason.
Code TransitGatewayRegistrationState
// The message for the state reason.
Message *string
noSmithyDocumentSerde
}
// Describes a transit gateway route table attachment.
type TransitGatewayRouteTableAttachment struct {
// Describes a core network attachment.
Attachment *Attachment
// The ID of the peering attachment.
PeeringId *string
// The ARN of the transit gateway attachment route table. For example,
// "TransitGatewayRouteTableArn":
// "arn:aws:ec2:us-west-2:123456789012:transit-gateway-route-table/tgw-rtb-9876543210123456"
// .
TransitGatewayRouteTableArn *string
noSmithyDocumentSerde
}
// Describes a validation exception for a field.
type ValidationExceptionField struct {
// The message for the field.
//
// This member is required.
Message *string
// The name of the field.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
// Describes a VPC attachment.
type VpcAttachment struct {
// Provides details about the VPC attachment.
Attachment *Attachment
// Provides details about the VPC attachment.
Options *VpcOptions
// The subnet ARNs.
SubnetArns []string
noSmithyDocumentSerde
}
// Describes the VPC options.
type VpcOptions struct {
// Indicates whether appliance mode is supported. If enabled, traffic flow between
// a source and destination use the same Availability Zone for the VPC attachment
// for the lifetime of that flow. The default value is false .
ApplianceModeSupport bool
// Indicates whether IPv6 is supported.
Ipv6Support bool
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 1,326 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
import (
"context"
cryptorand "crypto/rand"
"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"
smithyrand "github.com/aws/smithy-go/rand"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "nimble"
const ServiceAPIVersion = "2020-08-01"
// Client provides the API client to make operations call for AmazonNimbleStudio.
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)
resolveIdempotencyTokenProvider(&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
// Provides idempotency tokens values that will be automatically populated into
// idempotent API operations.
IdempotencyTokenProvider IdempotencyTokenProvider
// 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, "nimble", 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 resolveIdempotencyTokenProvider(o *Options) {
if o.IdempotencyTokenProvider != nil {
return
}
o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader)
}
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
}
// IdempotencyTokenProvider interface for providing idempotency token
type IdempotencyTokenProvider interface {
GetIdempotencyToken() (string, error)
}
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)
}
| 454 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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 nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Accept EULAs.
func (c *Client) AcceptEulas(ctx context.Context, params *AcceptEulasInput, optFns ...func(*Options)) (*AcceptEulasOutput, error) {
if params == nil {
params = &AcceptEulasInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AcceptEulas", params, optFns, c.addOperationAcceptEulasMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AcceptEulasOutput)
out.ResultMetadata = metadata
return out, nil
}
type AcceptEulasInput struct {
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
// The EULA ID.
EulaIds []string
noSmithyDocumentSerde
}
type AcceptEulasOutput struct {
// A collection of EULA acceptances.
EulaAcceptances []types.EulaAcceptance
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAcceptEulasMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAcceptEulas{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAcceptEulas{}, 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 = addIdempotencyToken_opAcceptEulasMiddleware(stack, options); err != nil {
return err
}
if err = addOpAcceptEulasValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAcceptEulas(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
}
type idempotencyToken_initializeOpAcceptEulas struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpAcceptEulas) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpAcceptEulas) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*AcceptEulasInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *AcceptEulasInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opAcceptEulasMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpAcceptEulas{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opAcceptEulas(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "AcceptEulas",
}
}
| 171 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Create a launch profile.
func (c *Client) CreateLaunchProfile(ctx context.Context, params *CreateLaunchProfileInput, optFns ...func(*Options)) (*CreateLaunchProfileOutput, error) {
if params == nil {
params = &CreateLaunchProfileInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateLaunchProfile", params, optFns, c.addOperationCreateLaunchProfileMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateLaunchProfileOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateLaunchProfileInput struct {
// Specifies the IDs of the EC2 subnets where streaming sessions will be
// accessible from. These subnets must support the specified instance types.
//
// This member is required.
Ec2SubnetIds []string
// The version number of the protocol that is used by the launch profile. The only
// valid version is "2021-03-31".
//
// This member is required.
LaunchProfileProtocolVersions []string
// The name for the launch profile.
//
// This member is required.
Name *string
// A configuration for a streaming session.
//
// This member is required.
StreamConfiguration *types.StreamConfigurationCreate
// Unique identifiers for a collection of studio components that can be used with
// this launch profile.
//
// This member is required.
StudioComponentIds []string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
// The description.
Description *string
// A collection of labels, in the form of key-value pairs, that apply to this
// resource.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateLaunchProfileOutput struct {
// The launch profile.
LaunchProfile *types.LaunchProfile
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateLaunchProfileMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateLaunchProfile{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateLaunchProfile{}, 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 = addIdempotencyToken_opCreateLaunchProfileMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateLaunchProfileValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateLaunchProfile(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
}
type idempotencyToken_initializeOpCreateLaunchProfile struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateLaunchProfile) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateLaunchProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateLaunchProfileInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateLaunchProfileInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateLaunchProfileMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateLaunchProfile{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateLaunchProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "CreateLaunchProfile",
}
}
| 203 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a streaming image resource in a studio.
func (c *Client) CreateStreamingImage(ctx context.Context, params *CreateStreamingImageInput, optFns ...func(*Options)) (*CreateStreamingImageOutput, error) {
if params == nil {
params = &CreateStreamingImageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStreamingImage", params, optFns, c.addOperationCreateStreamingImageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStreamingImageOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStreamingImageInput struct {
// The ID of an EC2 machine image with which to create this streaming image.
//
// This member is required.
Ec2ImageId *string
// A friendly name for a streaming image resource.
//
// This member is required.
Name *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
// A human-readable description of the streaming image.
Description *string
// A collection of labels, in the form of key-value pairs, that apply to this
// resource.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateStreamingImageOutput struct {
// The streaming image.
StreamingImage *types.StreamingImage
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStreamingImageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateStreamingImage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateStreamingImage{}, 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 = addIdempotencyToken_opCreateStreamingImageMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateStreamingImageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStreamingImage(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
}
type idempotencyToken_initializeOpCreateStreamingImage struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateStreamingImage) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateStreamingImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateStreamingImageInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStreamingImageInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateStreamingImageMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStreamingImage{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateStreamingImage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "CreateStreamingImage",
}
}
| 185 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a streaming session in a studio. After invoking this operation, you
// must poll GetStreamingSession until the streaming session is in the READY state.
func (c *Client) CreateStreamingSession(ctx context.Context, params *CreateStreamingSessionInput, optFns ...func(*Options)) (*CreateStreamingSessionOutput, error) {
if params == nil {
params = &CreateStreamingSessionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStreamingSession", params, optFns, c.addOperationCreateStreamingSessionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStreamingSessionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStreamingSessionInput struct {
// The ID of the launch profile used to control access from the streaming session.
//
// This member is required.
LaunchProfileId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
// The EC2 Instance type used for the streaming session.
Ec2InstanceType types.StreamingInstanceType
// The user ID of the user that owns the streaming session. The user that owns the
// session will be logging into the session and interacting with the virtual
// workstation.
OwnedBy *string
// The ID of the streaming image.
StreamingImageId *string
// A collection of labels, in the form of key-value pairs, that apply to this
// resource.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateStreamingSessionOutput struct {
// The session.
Session *types.StreamingSession
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStreamingSessionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateStreamingSession{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateStreamingSession{}, 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 = addIdempotencyToken_opCreateStreamingSessionMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateStreamingSessionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStreamingSession(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
}
type idempotencyToken_initializeOpCreateStreamingSession struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateStreamingSession) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateStreamingSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateStreamingSessionInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStreamingSessionInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateStreamingSessionMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStreamingSession{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateStreamingSession(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "CreateStreamingSession",
}
}
| 189 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a streaming session stream for a streaming session. After invoking this
// API, invoke GetStreamingSessionStream with the returned streamId to poll the
// resource until it is in the READY state.
func (c *Client) CreateStreamingSessionStream(ctx context.Context, params *CreateStreamingSessionStreamInput, optFns ...func(*Options)) (*CreateStreamingSessionStreamOutput, error) {
if params == nil {
params = &CreateStreamingSessionStreamInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStreamingSessionStream", params, optFns, c.addOperationCreateStreamingSessionStreamMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStreamingSessionStreamOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStreamingSessionStreamInput struct {
// The streaming session ID.
//
// This member is required.
SessionId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
// The expiration time in seconds.
ExpirationInSeconds *int32
noSmithyDocumentSerde
}
type CreateStreamingSessionStreamOutput struct {
// The stream.
Stream *types.StreamingSessionStream
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStreamingSessionStreamMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateStreamingSessionStream{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateStreamingSessionStream{}, 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 = addIdempotencyToken_opCreateStreamingSessionStreamMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateStreamingSessionStreamValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStreamingSessionStream(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
}
type idempotencyToken_initializeOpCreateStreamingSessionStream struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateStreamingSessionStream) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateStreamingSessionStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateStreamingSessionStreamInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStreamingSessionStreamInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateStreamingSessionStreamMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStreamingSessionStream{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateStreamingSessionStream(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "CreateStreamingSessionStream",
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Create a new studio. When creating a studio, two IAM roles must be provided:
// the admin role and the user role. These roles are assumed by your users when
// they log in to the Nimble Studio portal. The user role must have the
// AmazonNimbleStudio-StudioUser managed policy attached for the portal to function
// properly. The admin role must have the AmazonNimbleStudio-StudioAdmin managed
// policy attached for the portal to function properly. You may optionally specify
// a KMS key in the StudioEncryptionConfiguration . In Nimble Studio, resource
// names, descriptions, initialization scripts, and other data you provide are
// always encrypted at rest using an KMS key. By default, this key is owned by
// Amazon Web Services and managed on your behalf. You may provide your own KMS key
// when calling CreateStudio to encrypt this data using a key you own and manage.
// When providing an KMS key during studio creation, Nimble Studio creates KMS
// grants in your account to provide your studio user and admin roles access to
// these KMS keys. If you delete this grant, the studio will no longer be
// accessible to your portal users. If you delete the studio KMS key, your studio
// will no longer be accessible.
func (c *Client) CreateStudio(ctx context.Context, params *CreateStudioInput, optFns ...func(*Options)) (*CreateStudioOutput, error) {
if params == nil {
params = &CreateStudioInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStudio", params, optFns, c.addOperationCreateStudioMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStudioOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStudioInput struct {
// The IAM role that studio admins will assume when logging in to the Nimble
// Studio portal.
//
// This member is required.
AdminRoleArn *string
// A friendly name for the studio.
//
// This member is required.
DisplayName *string
// The studio name that is used in the URL of the Nimble Studio portal when
// accessed by Nimble Studio users.
//
// This member is required.
StudioName *string
// The IAM role that studio users will assume when logging in to the Nimble Studio
// portal.
//
// This member is required.
UserRoleArn *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
// The studio encryption configuration.
StudioEncryptionConfiguration *types.StudioEncryptionConfiguration
// A collection of labels, in the form of key-value pairs, that apply to this
// resource.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateStudioOutput struct {
// Information about a studio.
Studio *types.Studio
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStudioMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateStudio{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateStudio{}, 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 = addIdempotencyToken_opCreateStudioMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateStudioValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStudio(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
}
type idempotencyToken_initializeOpCreateStudio struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateStudio) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateStudio) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateStudioInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStudioInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateStudioMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStudio{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateStudio(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "CreateStudio",
}
}
| 208 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a studio component resource.
func (c *Client) CreateStudioComponent(ctx context.Context, params *CreateStudioComponentInput, optFns ...func(*Options)) (*CreateStudioComponentOutput, error) {
if params == nil {
params = &CreateStudioComponentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStudioComponent", params, optFns, c.addOperationCreateStudioComponentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStudioComponentOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStudioComponentInput struct {
// The name for the studio component.
//
// This member is required.
Name *string
// The studio ID.
//
// This member is required.
StudioId *string
// The type of the studio component.
//
// This member is required.
Type types.StudioComponentType
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
// The configuration of the studio component, based on component type.
Configuration *types.StudioComponentConfiguration
// The description.
Description *string
// The EC2 security groups that control access to the studio component.
Ec2SecurityGroupIds []string
// Initialization scripts for studio components.
InitializationScripts []types.StudioComponentInitializationScript
// An IAM role attached to a Studio Component that gives the studio component
// access to Amazon Web Services resources at anytime while the instance is
// running.
RuntimeRoleArn *string
// Parameters for the studio component scripts.
ScriptParameters []types.ScriptParameterKeyValue
// An IAM role attached to Studio Component when the system initialization script
// runs which give the studio component access to Amazon Web Services resources
// when the system initialization script runs.
SecureInitializationRoleArn *string
// The specific subtype of a studio component.
Subtype types.StudioComponentSubtype
// A collection of labels, in the form of key-value pairs, that apply to this
// resource.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateStudioComponentOutput struct {
// Information about the studio component.
StudioComponent *types.StudioComponent
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStudioComponentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateStudioComponent{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateStudioComponent{}, 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 = addIdempotencyToken_opCreateStudioComponentMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateStudioComponentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStudioComponent(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
}
type idempotencyToken_initializeOpCreateStudioComponent struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateStudioComponent) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateStudioComponent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateStudioComponentInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStudioComponentInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateStudioComponentMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStudioComponent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateStudioComponent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "CreateStudioComponent",
}
}
| 210 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Permanently delete a launch profile.
func (c *Client) DeleteLaunchProfile(ctx context.Context, params *DeleteLaunchProfileInput, optFns ...func(*Options)) (*DeleteLaunchProfileOutput, error) {
if params == nil {
params = &DeleteLaunchProfileInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteLaunchProfile", params, optFns, c.addOperationDeleteLaunchProfileMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteLaunchProfileOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteLaunchProfileInput struct {
// The ID of the launch profile used to control access from the streaming session.
//
// This member is required.
LaunchProfileId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
noSmithyDocumentSerde
}
type DeleteLaunchProfileOutput struct {
// The launch profile.
LaunchProfile *types.LaunchProfile
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteLaunchProfileMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteLaunchProfile{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteLaunchProfile{}, 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 = addIdempotencyToken_opDeleteLaunchProfileMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeleteLaunchProfileValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteLaunchProfile(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
}
type idempotencyToken_initializeOpDeleteLaunchProfile struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeleteLaunchProfile) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeleteLaunchProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*DeleteLaunchProfileInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteLaunchProfileInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeleteLaunchProfileMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteLaunchProfile{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeleteLaunchProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "DeleteLaunchProfile",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Delete a user from launch profile membership.
func (c *Client) DeleteLaunchProfileMember(ctx context.Context, params *DeleteLaunchProfileMemberInput, optFns ...func(*Options)) (*DeleteLaunchProfileMemberOutput, error) {
if params == nil {
params = &DeleteLaunchProfileMemberInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteLaunchProfileMember", params, optFns, c.addOperationDeleteLaunchProfileMemberMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteLaunchProfileMemberOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteLaunchProfileMemberInput struct {
// The ID of the launch profile used to control access from the streaming session.
//
// This member is required.
LaunchProfileId *string
// The principal ID. This currently supports a IAM Identity Center UserId.
//
// This member is required.
PrincipalId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
noSmithyDocumentSerde
}
type DeleteLaunchProfileMemberOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteLaunchProfileMemberMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteLaunchProfileMember{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteLaunchProfileMember{}, 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 = addIdempotencyToken_opDeleteLaunchProfileMemberMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeleteLaunchProfileMemberValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteLaunchProfileMember(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
}
type idempotencyToken_initializeOpDeleteLaunchProfileMember struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeleteLaunchProfileMember) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeleteLaunchProfileMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*DeleteLaunchProfileMemberInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteLaunchProfileMemberInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeleteLaunchProfileMemberMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteLaunchProfileMember{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeleteLaunchProfileMember(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "DeleteLaunchProfileMember",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Delete streaming image.
func (c *Client) DeleteStreamingImage(ctx context.Context, params *DeleteStreamingImageInput, optFns ...func(*Options)) (*DeleteStreamingImageOutput, error) {
if params == nil {
params = &DeleteStreamingImageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStreamingImage", params, optFns, c.addOperationDeleteStreamingImageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStreamingImageOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStreamingImageInput struct {
// The streaming image ID.
//
// This member is required.
StreamingImageId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
noSmithyDocumentSerde
}
type DeleteStreamingImageOutput struct {
// The streaming image.
StreamingImage *types.StreamingImage
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStreamingImageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteStreamingImage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteStreamingImage{}, 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 = addIdempotencyToken_opDeleteStreamingImageMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeleteStreamingImageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStreamingImage(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
}
type idempotencyToken_initializeOpDeleteStreamingImage struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeleteStreamingImage) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeleteStreamingImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*DeleteStreamingImageInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStreamingImageInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeleteStreamingImageMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStreamingImage{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeleteStreamingImage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "DeleteStreamingImage",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes streaming session resource. After invoking this operation, use
// GetStreamingSession to poll the resource until it transitions to a DELETED
// state. A streaming session will count against your streaming session quota until
// it is marked DELETED .
func (c *Client) DeleteStreamingSession(ctx context.Context, params *DeleteStreamingSessionInput, optFns ...func(*Options)) (*DeleteStreamingSessionOutput, error) {
if params == nil {
params = &DeleteStreamingSessionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStreamingSession", params, optFns, c.addOperationDeleteStreamingSessionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStreamingSessionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStreamingSessionInput struct {
// The streaming session ID.
//
// This member is required.
SessionId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
noSmithyDocumentSerde
}
type DeleteStreamingSessionOutput struct {
// The session.
Session *types.StreamingSession
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStreamingSessionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteStreamingSession{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteStreamingSession{}, 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 = addIdempotencyToken_opDeleteStreamingSessionMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeleteStreamingSessionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStreamingSession(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
}
type idempotencyToken_initializeOpDeleteStreamingSession struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeleteStreamingSession) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeleteStreamingSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*DeleteStreamingSessionInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStreamingSessionInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeleteStreamingSessionMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStreamingSession{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeleteStreamingSession(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "DeleteStreamingSession",
}
}
| 176 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Delete a studio resource.
func (c *Client) DeleteStudio(ctx context.Context, params *DeleteStudioInput, optFns ...func(*Options)) (*DeleteStudioOutput, error) {
if params == nil {
params = &DeleteStudioInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStudio", params, optFns, c.addOperationDeleteStudioMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStudioOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStudioInput struct {
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
noSmithyDocumentSerde
}
type DeleteStudioOutput struct {
// Information about a studio.
//
// This member is required.
Studio *types.Studio
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStudioMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteStudio{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteStudio{}, 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 = addIdempotencyToken_opDeleteStudioMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeleteStudioValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStudio(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
}
type idempotencyToken_initializeOpDeleteStudio struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeleteStudio) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeleteStudio) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*DeleteStudioInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStudioInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeleteStudioMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStudio{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeleteStudio(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "DeleteStudio",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a studio component resource.
func (c *Client) DeleteStudioComponent(ctx context.Context, params *DeleteStudioComponentInput, optFns ...func(*Options)) (*DeleteStudioComponentOutput, error) {
if params == nil {
params = &DeleteStudioComponentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStudioComponent", params, optFns, c.addOperationDeleteStudioComponentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStudioComponentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStudioComponentInput struct {
// The studio component ID.
//
// This member is required.
StudioComponentId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
noSmithyDocumentSerde
}
type DeleteStudioComponentOutput struct {
// Information about the studio component.
StudioComponent *types.StudioComponent
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStudioComponentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteStudioComponent{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteStudioComponent{}, 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 = addIdempotencyToken_opDeleteStudioComponentMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeleteStudioComponentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStudioComponent(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
}
type idempotencyToken_initializeOpDeleteStudioComponent struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeleteStudioComponent) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeleteStudioComponent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*DeleteStudioComponentInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStudioComponentInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeleteStudioComponentMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStudioComponent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeleteStudioComponent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "DeleteStudioComponent",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Delete a user from studio membership.
func (c *Client) DeleteStudioMember(ctx context.Context, params *DeleteStudioMemberInput, optFns ...func(*Options)) (*DeleteStudioMemberOutput, error) {
if params == nil {
params = &DeleteStudioMemberInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStudioMember", params, optFns, c.addOperationDeleteStudioMemberMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStudioMemberOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStudioMemberInput struct {
// The principal ID. This currently supports a IAM Identity Center UserId.
//
// This member is required.
PrincipalId *string
// The studio ID.
//
// This member is required.
StudioId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request. If you don’t specify a client token, the Amazon Web Services SDK
// automatically generates a client token and uses it for the request to ensure
// idempotency.
ClientToken *string
noSmithyDocumentSerde
}
type DeleteStudioMemberOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStudioMemberMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteStudioMember{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteStudioMember{}, 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 = addIdempotencyToken_opDeleteStudioMemberMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeleteStudioMemberValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStudioMember(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
}
type idempotencyToken_initializeOpDeleteStudioMember struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeleteStudioMember) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeleteStudioMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*DeleteStudioMemberInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStudioMemberInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeleteStudioMemberMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStudioMember{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeleteStudioMember(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "DeleteStudioMember",
}
}
| 168 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get EULA.
func (c *Client) GetEula(ctx context.Context, params *GetEulaInput, optFns ...func(*Options)) (*GetEulaOutput, error) {
if params == nil {
params = &GetEulaInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetEula", params, optFns, c.addOperationGetEulaMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetEulaOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetEulaInput struct {
// The EULA ID.
//
// This member is required.
EulaId *string
noSmithyDocumentSerde
}
type GetEulaOutput struct {
// The EULA.
Eula *types.Eula
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetEulaMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetEula{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetEula{}, 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 = addOpGetEulaValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetEula(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_opGetEula(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "GetEula",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Get a launch profile.
func (c *Client) GetLaunchProfile(ctx context.Context, params *GetLaunchProfileInput, optFns ...func(*Options)) (*GetLaunchProfileOutput, error) {
if params == nil {
params = &GetLaunchProfileInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLaunchProfile", params, optFns, c.addOperationGetLaunchProfileMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLaunchProfileOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLaunchProfileInput struct {
// The ID of the launch profile used to control access from the streaming session.
//
// This member is required.
LaunchProfileId *string
// The studio ID.
//
// This member is required.
StudioId *string
noSmithyDocumentSerde
}
type GetLaunchProfileOutput struct {
// The launch profile.
LaunchProfile *types.LaunchProfile
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLaunchProfileMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLaunchProfile{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLaunchProfile{}, 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 = addOpGetLaunchProfileValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLaunchProfile(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
}
// GetLaunchProfileAPIClient is a client that implements the GetLaunchProfile
// operation.
type GetLaunchProfileAPIClient interface {
GetLaunchProfile(context.Context, *GetLaunchProfileInput, ...func(*Options)) (*GetLaunchProfileOutput, error)
}
var _ GetLaunchProfileAPIClient = (*Client)(nil)
// LaunchProfileReadyWaiterOptions are waiter options for LaunchProfileReadyWaiter
type LaunchProfileReadyWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// LaunchProfileReadyWaiter will use default minimum delay of 5 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, LaunchProfileReadyWaiter will use default max delay of 750 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetLaunchProfileInput, *GetLaunchProfileOutput, error) (bool, error)
}
// LaunchProfileReadyWaiter defines the waiters for LaunchProfileReady
type LaunchProfileReadyWaiter struct {
client GetLaunchProfileAPIClient
options LaunchProfileReadyWaiterOptions
}
// NewLaunchProfileReadyWaiter constructs a LaunchProfileReadyWaiter.
func NewLaunchProfileReadyWaiter(client GetLaunchProfileAPIClient, optFns ...func(*LaunchProfileReadyWaiterOptions)) *LaunchProfileReadyWaiter {
options := LaunchProfileReadyWaiterOptions{}
options.MinDelay = 5 * time.Second
options.MaxDelay = 750 * time.Second
options.Retryable = launchProfileReadyStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &LaunchProfileReadyWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for LaunchProfileReady waiter. The maxWaitDur is
// the maximum wait duration the waiter will wait. The maxWaitDur is required and
// must be greater than zero.
func (w *LaunchProfileReadyWaiter) Wait(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileReadyWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for LaunchProfileReady waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *LaunchProfileReadyWaiter) WaitForOutput(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileReadyWaiterOptions)) (*GetLaunchProfileOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 750 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetLaunchProfile(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for LaunchProfileReady waiter")
}
func launchProfileReadyStateRetryable(ctx context.Context, input *GetLaunchProfileInput, output *GetLaunchProfileOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("launchProfile.state", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "READY"
value, ok := pathValue.(types.LaunchProfileState)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("launchProfile.state", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATE_FAILED"
value, ok := pathValue.(types.LaunchProfileState)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err == nil {
pathValue, err := jmespath.Search("launchProfile.state", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "UPDATE_FAILED"
value, ok := pathValue.(types.LaunchProfileState)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// LaunchProfileDeletedWaiterOptions are waiter options for
// LaunchProfileDeletedWaiter
type LaunchProfileDeletedWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// LaunchProfileDeletedWaiter will use default minimum delay of 5 seconds. Note
// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, LaunchProfileDeletedWaiter will use default max delay of 750
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *GetLaunchProfileInput, *GetLaunchProfileOutput, error) (bool, error)
}
// LaunchProfileDeletedWaiter defines the waiters for LaunchProfileDeleted
type LaunchProfileDeletedWaiter struct {
client GetLaunchProfileAPIClient
options LaunchProfileDeletedWaiterOptions
}
// NewLaunchProfileDeletedWaiter constructs a LaunchProfileDeletedWaiter.
func NewLaunchProfileDeletedWaiter(client GetLaunchProfileAPIClient, optFns ...func(*LaunchProfileDeletedWaiterOptions)) *LaunchProfileDeletedWaiter {
options := LaunchProfileDeletedWaiterOptions{}
options.MinDelay = 5 * time.Second
options.MaxDelay = 750 * time.Second
options.Retryable = launchProfileDeletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &LaunchProfileDeletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for LaunchProfileDeleted waiter. The maxWaitDur
// is the maximum wait duration the waiter will wait. The maxWaitDur is required
// and must be greater than zero.
func (w *LaunchProfileDeletedWaiter) Wait(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileDeletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for LaunchProfileDeleted waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *LaunchProfileDeletedWaiter) WaitForOutput(ctx context.Context, params *GetLaunchProfileInput, maxWaitDur time.Duration, optFns ...func(*LaunchProfileDeletedWaiterOptions)) (*GetLaunchProfileOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 750 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.GetLaunchProfile(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for LaunchProfileDeleted waiter")
}
func launchProfileDeletedStateRetryable(ctx context.Context, input *GetLaunchProfileInput, output *GetLaunchProfileOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("launchProfile.state", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "DELETED"
value, ok := pathValue.(types.LaunchProfileState)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("launchProfile.state", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "DELETE_FAILED"
value, ok := pathValue.(types.LaunchProfileState)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.LaunchProfileState value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opGetLaunchProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "GetLaunchProfile",
}
}
| 516 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Launch profile details include the launch profile resource and summary
// information of resources that are used by, or available to, the launch profile.
// This includes the name and description of all studio components used by the
// launch profiles, and the name and description of streaming images that can be
// used with this launch profile.
func (c *Client) GetLaunchProfileDetails(ctx context.Context, params *GetLaunchProfileDetailsInput, optFns ...func(*Options)) (*GetLaunchProfileDetailsOutput, error) {
if params == nil {
params = &GetLaunchProfileDetailsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLaunchProfileDetails", params, optFns, c.addOperationGetLaunchProfileDetailsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLaunchProfileDetailsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLaunchProfileDetailsInput struct {
// The ID of the launch profile used to control access from the streaming session.
//
// This member is required.
LaunchProfileId *string
// The studio ID.
//
// This member is required.
StudioId *string
noSmithyDocumentSerde
}
type GetLaunchProfileDetailsOutput struct {
// The launch profile.
LaunchProfile *types.LaunchProfile
// A collection of streaming images.
StreamingImages []types.StreamingImage
// A collection of studio component summaries.
StudioComponentSummaries []types.StudioComponentSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLaunchProfileDetailsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLaunchProfileDetails{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLaunchProfileDetails{}, 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 = addOpGetLaunchProfileDetailsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLaunchProfileDetails(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_opGetLaunchProfileDetails(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "GetLaunchProfileDetails",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get a launch profile initialization.
func (c *Client) GetLaunchProfileInitialization(ctx context.Context, params *GetLaunchProfileInitializationInput, optFns ...func(*Options)) (*GetLaunchProfileInitializationOutput, error) {
if params == nil {
params = &GetLaunchProfileInitializationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLaunchProfileInitialization", params, optFns, c.addOperationGetLaunchProfileInitializationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLaunchProfileInitializationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLaunchProfileInitializationInput struct {
// The ID of the launch profile used to control access from the streaming session.
//
// This member is required.
LaunchProfileId *string
// The launch profile protocol versions supported by the client.
//
// This member is required.
LaunchProfileProtocolVersions []string
// The launch purpose.
//
// This member is required.
LaunchPurpose *string
// The platform where this Launch Profile will be used, either Windows or Linux.
//
// This member is required.
Platform *string
// The studio ID.
//
// This member is required.
StudioId *string
noSmithyDocumentSerde
}
type GetLaunchProfileInitializationOutput struct {
// The launch profile initialization.
LaunchProfileInitialization *types.LaunchProfileInitialization
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLaunchProfileInitializationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLaunchProfileInitialization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLaunchProfileInitialization{}, 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 = addOpGetLaunchProfileInitializationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLaunchProfileInitialization(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_opGetLaunchProfileInitialization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "GetLaunchProfileInitialization",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package nimble
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/nimble/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get a user persona in launch profile membership.
func (c *Client) GetLaunchProfileMember(ctx context.Context, params *GetLaunchProfileMemberInput, optFns ...func(*Options)) (*GetLaunchProfileMemberOutput, error) {
if params == nil {
params = &GetLaunchProfileMemberInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLaunchProfileMember", params, optFns, c.addOperationGetLaunchProfileMemberMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLaunchProfileMemberOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLaunchProfileMemberInput struct {
// The ID of the launch profile used to control access from the streaming session.
//
// This member is required.
LaunchProfileId *string
// The principal ID. This currently supports a IAM Identity Center UserId.
//
// This member is required.
PrincipalId *string
// The studio ID.
//
// This member is required.
StudioId *string
noSmithyDocumentSerde
}
type GetLaunchProfileMemberOutput struct {
// The member.
Member *types.LaunchProfileMembership
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLaunchProfileMemberMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLaunchProfileMember{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLaunchProfileMember{}, 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 = addOpGetLaunchProfileMemberValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLaunchProfileMember(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_opGetLaunchProfileMember(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "nimble",
OperationName: "GetLaunchProfileMember",
}
}
| 135 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.