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 iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets information about a multicast group.
func (c *Client) GetMulticastGroup(ctx context.Context, params *GetMulticastGroupInput, optFns ...func(*Options)) (*GetMulticastGroupOutput, error) {
if params == nil {
params = &GetMulticastGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetMulticastGroup", params, optFns, c.addOperationGetMulticastGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetMulticastGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetMulticastGroupInput struct {
// The ID of the multicast group.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetMulticastGroupOutput struct {
// The arn of the multicast group.
Arn *string
// Created at timestamp for the resource.
CreatedAt *time.Time
// The description of the new resource.
Description *string
// The ID of the multicast group.
Id *string
// The LoRaWAN information that is to be returned from getting multicast group
// information.
LoRaWAN *types.LoRaWANMulticastGet
// The name of the multicast group.
Name *string
// The status of the multicast group.
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetMulticastGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetMulticastGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetMulticastGroup{}, 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 = addOpGetMulticastGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetMulticastGroup(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_opGetMulticastGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetMulticastGroup",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a multicast group session.
func (c *Client) GetMulticastGroupSession(ctx context.Context, params *GetMulticastGroupSessionInput, optFns ...func(*Options)) (*GetMulticastGroupSessionOutput, error) {
if params == nil {
params = &GetMulticastGroupSessionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetMulticastGroupSession", params, optFns, c.addOperationGetMulticastGroupSessionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetMulticastGroupSessionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetMulticastGroupSessionInput struct {
// The ID of the multicast group.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetMulticastGroupSessionOutput struct {
// The LoRaWAN information used with the multicast session.
LoRaWAN *types.LoRaWANMulticastSession
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetMulticastGroupSessionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetMulticastGroupSession{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetMulticastGroupSession{}, 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 = addOpGetMulticastGroupSessionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetMulticastGroupSession(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_opGetMulticastGroupSession(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetMulticastGroupSession",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get network analyzer configuration.
func (c *Client) GetNetworkAnalyzerConfiguration(ctx context.Context, params *GetNetworkAnalyzerConfigurationInput, optFns ...func(*Options)) (*GetNetworkAnalyzerConfigurationOutput, error) {
if params == nil {
params = &GetNetworkAnalyzerConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetNetworkAnalyzerConfiguration", params, optFns, c.addOperationGetNetworkAnalyzerConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetNetworkAnalyzerConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetNetworkAnalyzerConfigurationInput struct {
// Name of the network analyzer configuration.
//
// This member is required.
ConfigurationName *string
noSmithyDocumentSerde
}
type GetNetworkAnalyzerConfigurationOutput struct {
// The Amazon Resource Name of the new resource.
Arn *string
// The description of the new resource.
Description *string
// List of multicast group resources that have been added to the network analyzer
// configuration.
MulticastGroups []string
// Name of the network analyzer configuration.
Name *string
// Trace content for your wireless gateway and wireless device resources.
TraceContent *types.TraceContent
// List of wireless gateway resources that have been added to the network analyzer
// configuration.
WirelessDevices []string
// List of wireless gateway resources that have been added to the network analyzer
// configuration.
WirelessGateways []string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetNetworkAnalyzerConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetNetworkAnalyzerConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetNetworkAnalyzerConfiguration{}, 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 = addOpGetNetworkAnalyzerConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetNetworkAnalyzerConfiguration(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_opGetNetworkAnalyzerConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetNetworkAnalyzerConfiguration",
}
}
| 146 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a partner account. If PartnerAccountId and PartnerType
// are null , returns all partner accounts.
func (c *Client) GetPartnerAccount(ctx context.Context, params *GetPartnerAccountInput, optFns ...func(*Options)) (*GetPartnerAccountOutput, error) {
if params == nil {
params = &GetPartnerAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPartnerAccount", params, optFns, c.addOperationGetPartnerAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPartnerAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetPartnerAccountInput struct {
// The partner account ID to disassociate from the AWS account.
//
// This member is required.
PartnerAccountId *string
// The partner type.
//
// This member is required.
PartnerType types.PartnerType
noSmithyDocumentSerde
}
type GetPartnerAccountOutput struct {
// Whether the partner account is linked to the AWS account.
AccountLinked bool
// The Sidewalk account credentials.
Sidewalk *types.SidewalkAccountInfoWithFingerprint
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPartnerAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetPartnerAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetPartnerAccount{}, 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 = addOpGetPartnerAccountValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPartnerAccount(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_opGetPartnerAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetPartnerAccount",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get the position information for a given resource. This action is no longer
// supported. Calls to retrieve the position information should use the
// GetResourcePosition (https://docs.aws.amazon.com/iot-wireless/2020-11-22/apireference/API_GetResourcePosition.html)
// API operation instead.
//
// Deprecated: This operation is no longer supported.
func (c *Client) GetPosition(ctx context.Context, params *GetPositionInput, optFns ...func(*Options)) (*GetPositionOutput, error) {
if params == nil {
params = &GetPositionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPosition", params, optFns, c.addOperationGetPositionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPositionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetPositionInput struct {
// Resource identifier used to retrieve the position information.
//
// This member is required.
ResourceIdentifier *string
// Resource type of the resource for which position information is retrieved.
//
// This member is required.
ResourceType types.PositionResourceType
noSmithyDocumentSerde
}
type GetPositionOutput struct {
// The accuracy of the estimated position in meters. An empty value indicates that
// no position data is available. A value of ‘0.0’ value indicates that position
// data is available. This data corresponds to the position information that you
// specified instead of the position computed by solver.
Accuracy *types.Accuracy
// The position information of the resource.
Position []float32
// The vendor of the positioning solver.
SolverProvider types.PositionSolverProvider
// The type of solver used to identify the position of the resource.
SolverType types.PositionSolverType
// The version of the positioning solver.
SolverVersion *string
// The timestamp at which the device's position was determined.
Timestamp *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPositionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetPosition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetPosition{}, 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 = addOpGetPositionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPosition(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_opGetPosition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetPosition",
}
}
| 153 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get position configuration for a given resource. This action is no longer
// supported. Calls to retrieve the position configuration should use the
// GetResourcePosition (https://docs.aws.amazon.com/iot-wireless/2020-11-22/apireference/API_GetResourcePosition.html)
// API operation instead.
//
// Deprecated: This operation is no longer supported.
func (c *Client) GetPositionConfiguration(ctx context.Context, params *GetPositionConfigurationInput, optFns ...func(*Options)) (*GetPositionConfigurationOutput, error) {
if params == nil {
params = &GetPositionConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPositionConfiguration", params, optFns, c.addOperationGetPositionConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPositionConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetPositionConfigurationInput struct {
// Resource identifier used in a position configuration.
//
// This member is required.
ResourceIdentifier *string
// Resource type of the resource for which position configuration is retrieved.
//
// This member is required.
ResourceType types.PositionResourceType
noSmithyDocumentSerde
}
type GetPositionConfigurationOutput struct {
// The position data destination that describes the AWS IoT rule that processes
// the device's position data for use by AWS IoT Core for LoRaWAN.
Destination *string
// The wrapper for the solver configuration details object.
Solvers *types.PositionSolverDetails
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPositionConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetPositionConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetPositionConfiguration{}, 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 = addOpGetPositionConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPositionConfiguration(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_opGetPositionConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetPositionConfiguration",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Get estimated position information as a payload in GeoJSON format. The payload
// measurement data is resolved using solvers that are provided by third-party
// vendors.
func (c *Client) GetPositionEstimate(ctx context.Context, params *GetPositionEstimateInput, optFns ...func(*Options)) (*GetPositionEstimateOutput, error) {
if params == nil {
params = &GetPositionEstimateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPositionEstimate", params, optFns, c.addOperationGetPositionEstimateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPositionEstimateOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetPositionEstimateInput struct {
// Retrieves an estimated device position by resolving measurement data from
// cellular radio towers. The position is resolved using HERE's cellular-based
// solver.
CellTowers *types.CellTowers
// Retrieves an estimated device position by resolving the global navigation
// satellite system (GNSS) scan data. The position is resolved using the GNSS
// solver powered by LoRa Cloud.
Gnss *types.Gnss
// Retrieves an estimated device position by resolving the IP address information
// from the device. The position is resolved using MaxMind's IP-based solver.
Ip *types.Ip
// Optional information that specifies the time when the position information will
// be resolved. It uses the Unix timestamp format. If not specified, the time at
// which the request was received will be used.
Timestamp *time.Time
// Retrieves an estimated device position by resolving WLAN measurement data. The
// position is resolved using HERE's Wi-Fi based solver.
WiFiAccessPoints []types.WiFiAccessPoint
noSmithyDocumentSerde
}
type GetPositionEstimateOutput struct {
// The position information of the resource, displayed as a JSON payload. The
// payload uses the GeoJSON format, which a format that's used to encode geographic
// data structures. For more information, see GeoJSON (https://geojson.org/) .
GeoJsonPayload []byte
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPositionEstimateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetPositionEstimate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetPositionEstimate{}, 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 = addOpGetPositionEstimateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPositionEstimate(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_opGetPositionEstimate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetPositionEstimate",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get the event configuration for a particular resource identifier.
func (c *Client) GetResourceEventConfiguration(ctx context.Context, params *GetResourceEventConfigurationInput, optFns ...func(*Options)) (*GetResourceEventConfigurationOutput, error) {
if params == nil {
params = &GetResourceEventConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetResourceEventConfiguration", params, optFns, c.addOperationGetResourceEventConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetResourceEventConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetResourceEventConfigurationInput struct {
// Resource identifier to opt in for event messaging.
//
// This member is required.
Identifier *string
// Identifier type of the particular resource identifier for event configuration.
//
// This member is required.
IdentifierType types.IdentifierType
// Partner type of the resource if the identifier type is PartnerAccountId .
PartnerType types.EventNotificationPartnerType
noSmithyDocumentSerde
}
type GetResourceEventConfigurationOutput struct {
// Event configuration for the connection status event.
ConnectionStatus *types.ConnectionStatusEventConfiguration
// Event configuration for the device registration state event.
DeviceRegistrationState *types.DeviceRegistrationStateEventConfiguration
// Event configuration for the join event.
Join *types.JoinEventConfiguration
// Event configuration for the message delivery status event.
MessageDeliveryStatus *types.MessageDeliveryStatusEventConfiguration
// Event configuration for the proximity event.
Proximity *types.ProximityEventConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetResourceEventConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetResourceEventConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetResourceEventConfiguration{}, 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 = addOpGetResourceEventConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetResourceEventConfiguration(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_opGetResourceEventConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetResourceEventConfiguration",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Fetches the log-level override, if any, for a given resource-ID and
// resource-type. It can be used for a wireless device or a wireless gateway.
func (c *Client) GetResourceLogLevel(ctx context.Context, params *GetResourceLogLevelInput, optFns ...func(*Options)) (*GetResourceLogLevelOutput, error) {
if params == nil {
params = &GetResourceLogLevelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetResourceLogLevel", params, optFns, c.addOperationGetResourceLogLevelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetResourceLogLevelOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetResourceLogLevelInput struct {
// The identifier of the resource. For a Wireless Device, it is the wireless
// device ID. For a wireless gateway, it is the wireless gateway ID.
//
// This member is required.
ResourceIdentifier *string
// The type of the resource, which can be WirelessDevice or WirelessGateway .
//
// This member is required.
ResourceType *string
noSmithyDocumentSerde
}
type GetResourceLogLevelOutput struct {
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
LogLevel types.LogLevel
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetResourceLogLevelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetResourceLogLevel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetResourceLogLevel{}, 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 = addOpGetResourceLogLevelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetResourceLogLevel(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_opGetResourceLogLevel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetResourceLogLevel",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Get the position information for a given wireless device or a wireless gateway
// resource. The position information uses the World Geodetic System (WGS84) (https://gisgeography.com/wgs84-world-geodetic-system/)
// .
func (c *Client) GetResourcePosition(ctx context.Context, params *GetResourcePositionInput, optFns ...func(*Options)) (*GetResourcePositionOutput, error) {
if params == nil {
params = &GetResourcePositionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetResourcePosition", params, optFns, c.addOperationGetResourcePositionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetResourcePositionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetResourcePositionInput struct {
// The identifier of the resource for which position information is retrieved. It
// can be the wireless device ID or the wireless gateway ID, depending on the
// resource type.
//
// This member is required.
ResourceIdentifier *string
// The type of resource for which position information is retrieved, which can be
// a wireless device or a wireless gateway.
//
// This member is required.
ResourceType types.PositionResourceType
noSmithyDocumentSerde
}
type GetResourcePositionOutput struct {
// The position information of the resource, displayed as a JSON payload. The
// payload uses the GeoJSON format, which a format that's used to encode geographic
// data structures. For more information, see GeoJSON (https://geojson.org/) .
GeoJsonPayload []byte
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetResourcePositionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetResourcePosition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetResourcePosition{}, 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 = addOpGetResourcePositionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetResourcePosition(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_opGetResourcePosition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetResourcePosition",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the account-specific endpoint for Configuration and Update Server (CUPS)
// protocol or LoRaWAN Network Server (LNS) connections.
func (c *Client) GetServiceEndpoint(ctx context.Context, params *GetServiceEndpointInput, optFns ...func(*Options)) (*GetServiceEndpointOutput, error) {
if params == nil {
params = &GetServiceEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetServiceEndpoint", params, optFns, c.addOperationGetServiceEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetServiceEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetServiceEndpointInput struct {
// The service type for which to get endpoint information about. Can be CUPS for
// the Configuration and Update Server endpoint, or LNS for the LoRaWAN Network
// Server endpoint or CLAIM for the global endpoint.
ServiceType types.WirelessGatewayServiceType
noSmithyDocumentSerde
}
type GetServiceEndpointOutput struct {
// The Root CA of the server trust certificate.
ServerTrust *string
// The service endpoint value.
ServiceEndpoint *string
// The endpoint's service type.
ServiceType types.WirelessGatewayServiceType
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetServiceEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetServiceEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetServiceEndpoint{}, 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_opGetServiceEndpoint(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_opGetServiceEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetServiceEndpoint",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a service profile.
func (c *Client) GetServiceProfile(ctx context.Context, params *GetServiceProfileInput, optFns ...func(*Options)) (*GetServiceProfileOutput, error) {
if params == nil {
params = &GetServiceProfileInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetServiceProfile", params, optFns, c.addOperationGetServiceProfileMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetServiceProfileOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetServiceProfileInput struct {
// The ID of the resource to get.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetServiceProfileOutput struct {
// The Amazon Resource Name of the resource.
Arn *string
// The ID of the service profile.
Id *string
// Information about the service profile.
LoRaWAN *types.LoRaWANGetServiceProfileInfo
// The name of the resource.
Name *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetServiceProfileMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetServiceProfile{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetServiceProfile{}, 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 = addOpGetServiceProfileValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetServiceProfile(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_opGetServiceProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetServiceProfile",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a wireless device.
func (c *Client) GetWirelessDevice(ctx context.Context, params *GetWirelessDeviceInput, optFns ...func(*Options)) (*GetWirelessDeviceOutput, error) {
if params == nil {
params = &GetWirelessDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessDevice", params, optFns, c.addOperationGetWirelessDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessDeviceInput struct {
// The identifier of the wireless device to get.
//
// This member is required.
Identifier *string
// The type of identifier used in identifier .
//
// This member is required.
IdentifierType types.WirelessDeviceIdType
noSmithyDocumentSerde
}
type GetWirelessDeviceOutput struct {
// The Amazon Resource Name of the resource.
Arn *string
// The description of the resource.
Description *string
// The name of the destination to which the device is assigned.
DestinationName *string
// The ID of the wireless device.
Id *string
// Information about the wireless device.
LoRaWAN *types.LoRaWANDevice
// The name of the resource.
Name *string
// FPort values for the GNSS, stream, and ClockSync functions of the positioning
// information.
Positioning types.PositioningConfigStatus
// Sidewalk device object.
Sidewalk *types.SidewalkDevice
// The ARN of the thing associated with the wireless device.
ThingArn *string
// The name of the thing associated with the wireless device. The value is empty
// if a thing isn't associated with the device.
ThingName *string
// The wireless device type.
Type types.WirelessDeviceType
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessDevice{}, 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 = addOpGetWirelessDeviceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessDevice(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_opGetWirelessDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessDevice",
}
}
| 162 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Get information about an import task and count of device onboarding summary
// information for the import task.
func (c *Client) GetWirelessDeviceImportTask(ctx context.Context, params *GetWirelessDeviceImportTaskInput, optFns ...func(*Options)) (*GetWirelessDeviceImportTaskOutput, error) {
if params == nil {
params = &GetWirelessDeviceImportTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessDeviceImportTask", params, optFns, c.addOperationGetWirelessDeviceImportTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessDeviceImportTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessDeviceImportTaskInput struct {
// The identifier of the import task for which information is requested.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetWirelessDeviceImportTaskOutput struct {
// The ARN (Amazon Resource Name) of the import task.
Arn *string
// The time at which the import task was created.
CreationTime *time.Time
// The name of the destination that's assigned to the wireless devices in the
// import task.
DestinationName *string
// The number of devices in the import task that failed to onboard to the import
// task.
FailedImportedDeviceCount *int64
// The identifier of the import task for which information is retrieved.
Id *string
// The number of devices in the import task that are waiting for the control log
// to start processing.
InitializedImportedDeviceCount *int64
// The number of devices in the import task that have been onboarded to the import
// task.
OnboardedImportedDeviceCount *int64
// The number of devices in the import task that are waiting in the import task
// queue to be onboarded.
PendingImportedDeviceCount *int64
// The Sidewalk-related information about an import task.
Sidewalk *types.SidewalkGetStartImportInfo
// The import task status.
Status types.ImportTaskStatus
// The reason for the provided status information, such as a validation error that
// causes the import task to fail.
StatusReason *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessDeviceImportTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessDeviceImportTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessDeviceImportTask{}, 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 = addOpGetWirelessDeviceImportTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessDeviceImportTask(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_opGetWirelessDeviceImportTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessDeviceImportTask",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets operating information about a wireless device.
func (c *Client) GetWirelessDeviceStatistics(ctx context.Context, params *GetWirelessDeviceStatisticsInput, optFns ...func(*Options)) (*GetWirelessDeviceStatisticsOutput, error) {
if params == nil {
params = &GetWirelessDeviceStatisticsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessDeviceStatistics", params, optFns, c.addOperationGetWirelessDeviceStatisticsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessDeviceStatisticsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessDeviceStatisticsInput struct {
// The ID of the wireless device for which to get the data.
//
// This member is required.
WirelessDeviceId *string
noSmithyDocumentSerde
}
type GetWirelessDeviceStatisticsOutput struct {
// The date and time when the most recent uplink was received. This value is only
// valid for 3 months.
LastUplinkReceivedAt *string
// Information about the wireless device's operations.
LoRaWAN *types.LoRaWANDeviceMetadata
// MetaData for Sidewalk device.
Sidewalk *types.SidewalkDeviceMetadata
// The ID of the wireless device.
WirelessDeviceId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessDeviceStatisticsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessDeviceStatistics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessDeviceStatistics{}, 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 = addOpGetWirelessDeviceStatisticsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessDeviceStatistics(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_opGetWirelessDeviceStatistics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessDeviceStatistics",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a wireless gateway.
func (c *Client) GetWirelessGateway(ctx context.Context, params *GetWirelessGatewayInput, optFns ...func(*Options)) (*GetWirelessGatewayOutput, error) {
if params == nil {
params = &GetWirelessGatewayInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessGateway", params, optFns, c.addOperationGetWirelessGatewayMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessGatewayOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessGatewayInput struct {
// The identifier of the wireless gateway to get.
//
// This member is required.
Identifier *string
// The type of identifier used in identifier .
//
// This member is required.
IdentifierType types.WirelessGatewayIdType
noSmithyDocumentSerde
}
type GetWirelessGatewayOutput struct {
// The Amazon Resource Name of the resource.
Arn *string
// The description of the resource.
Description *string
// The ID of the wireless gateway.
Id *string
// Information about the wireless gateway.
LoRaWAN *types.LoRaWANGateway
// The name of the resource.
Name *string
// The ARN of the thing associated with the wireless gateway.
ThingArn *string
// The name of the thing associated with the wireless gateway. The value is empty
// if a thing isn't associated with the gateway.
ThingName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessGatewayMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessGateway{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessGateway{}, 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 = addOpGetWirelessGatewayValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessGateway(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_opGetWirelessGateway(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessGateway",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the ID of the certificate that is currently associated with a wireless
// gateway.
func (c *Client) GetWirelessGatewayCertificate(ctx context.Context, params *GetWirelessGatewayCertificateInput, optFns ...func(*Options)) (*GetWirelessGatewayCertificateOutput, error) {
if params == nil {
params = &GetWirelessGatewayCertificateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessGatewayCertificate", params, optFns, c.addOperationGetWirelessGatewayCertificateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessGatewayCertificateOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessGatewayCertificateInput struct {
// The ID of the resource to get.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetWirelessGatewayCertificateOutput struct {
// The ID of the certificate associated with the wireless gateway.
IotCertificateId *string
// The ID of the certificate that is associated with the wireless gateway and used
// for the LoRaWANNetworkServer endpoint.
LoRaWANNetworkServerCertificateId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessGatewayCertificateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessGatewayCertificate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessGatewayCertificate{}, 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 = addOpGetWirelessGatewayCertificateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessGatewayCertificate(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_opGetWirelessGatewayCertificate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessGatewayCertificate",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the firmware version and other information about a wireless gateway.
func (c *Client) GetWirelessGatewayFirmwareInformation(ctx context.Context, params *GetWirelessGatewayFirmwareInformationInput, optFns ...func(*Options)) (*GetWirelessGatewayFirmwareInformationOutput, error) {
if params == nil {
params = &GetWirelessGatewayFirmwareInformationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessGatewayFirmwareInformation", params, optFns, c.addOperationGetWirelessGatewayFirmwareInformationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessGatewayFirmwareInformationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessGatewayFirmwareInformationInput struct {
// The ID of the resource to get.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetWirelessGatewayFirmwareInformationOutput struct {
// Information about the wireless gateway's firmware.
LoRaWAN *types.LoRaWANGatewayCurrentVersion
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessGatewayFirmwareInformationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessGatewayFirmwareInformation{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessGatewayFirmwareInformation{}, 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 = addOpGetWirelessGatewayFirmwareInformationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessGatewayFirmwareInformation(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_opGetWirelessGatewayFirmwareInformation(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessGatewayFirmwareInformation",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets operating information about a wireless gateway.
func (c *Client) GetWirelessGatewayStatistics(ctx context.Context, params *GetWirelessGatewayStatisticsInput, optFns ...func(*Options)) (*GetWirelessGatewayStatisticsOutput, error) {
if params == nil {
params = &GetWirelessGatewayStatisticsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessGatewayStatistics", params, optFns, c.addOperationGetWirelessGatewayStatisticsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessGatewayStatisticsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessGatewayStatisticsInput struct {
// The ID of the wireless gateway for which to get the data.
//
// This member is required.
WirelessGatewayId *string
noSmithyDocumentSerde
}
type GetWirelessGatewayStatisticsOutput struct {
// The connection status of the wireless gateway.
ConnectionStatus types.ConnectionStatus
// The date and time when the most recent uplink was received. This value is only
// valid for 3 months.
LastUplinkReceivedAt *string
// The ID of the wireless gateway.
WirelessGatewayId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessGatewayStatisticsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessGatewayStatistics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessGatewayStatistics{}, 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 = addOpGetWirelessGatewayStatisticsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessGatewayStatistics(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_opGetWirelessGatewayStatistics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessGatewayStatistics",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a wireless gateway task.
func (c *Client) GetWirelessGatewayTask(ctx context.Context, params *GetWirelessGatewayTaskInput, optFns ...func(*Options)) (*GetWirelessGatewayTaskOutput, error) {
if params == nil {
params = &GetWirelessGatewayTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessGatewayTask", params, optFns, c.addOperationGetWirelessGatewayTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessGatewayTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessGatewayTaskInput struct {
// The ID of the resource to get.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetWirelessGatewayTaskOutput struct {
// The date and time when the most recent uplink was received. This value is only
// valid for 3 months.
LastUplinkReceivedAt *string
// The status of the request.
Status types.WirelessGatewayTaskStatus
// The date and time when the task was created.
TaskCreatedAt *string
// The ID of the wireless gateway.
WirelessGatewayId *string
// The ID of the WirelessGatewayTask.
WirelessGatewayTaskDefinitionId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessGatewayTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessGatewayTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessGatewayTask{}, 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 = addOpGetWirelessGatewayTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessGatewayTask(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_opGetWirelessGatewayTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessGatewayTask",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a wireless gateway task definition.
func (c *Client) GetWirelessGatewayTaskDefinition(ctx context.Context, params *GetWirelessGatewayTaskDefinitionInput, optFns ...func(*Options)) (*GetWirelessGatewayTaskDefinitionOutput, error) {
if params == nil {
params = &GetWirelessGatewayTaskDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetWirelessGatewayTaskDefinition", params, optFns, c.addOperationGetWirelessGatewayTaskDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetWirelessGatewayTaskDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetWirelessGatewayTaskDefinitionInput struct {
// The ID of the resource to get.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type GetWirelessGatewayTaskDefinitionOutput struct {
// The Amazon Resource Name of the resource.
Arn *string
// Whether to automatically create tasks using this task definition for all
// gateways with the specified current version. If false , the task must me created
// by calling CreateWirelessGatewayTask .
AutoCreateTasks bool
// The name of the resource.
Name *string
// Information about the gateways to update.
Update *types.UpdateWirelessGatewayTaskCreate
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetWirelessGatewayTaskDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetWirelessGatewayTaskDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetWirelessGatewayTaskDefinition{}, 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 = addOpGetWirelessGatewayTaskDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetWirelessGatewayTaskDefinition(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_opGetWirelessGatewayTaskDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "GetWirelessGatewayTaskDefinition",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the destinations registered to your AWS account.
func (c *Client) ListDestinations(ctx context.Context, params *ListDestinationsInput, optFns ...func(*Options)) (*ListDestinationsOutput, error) {
if params == nil {
params = &ListDestinationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDestinations", params, optFns, c.addOperationListDestinationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDestinationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDestinationsInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListDestinationsOutput struct {
// The list of destinations.
DestinationList []types.Destinations
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDestinationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDestinations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDestinations{}, 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_opListDestinations(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
}
// ListDestinationsAPIClient is a client that implements the ListDestinations
// operation.
type ListDestinationsAPIClient interface {
ListDestinations(context.Context, *ListDestinationsInput, ...func(*Options)) (*ListDestinationsOutput, error)
}
var _ ListDestinationsAPIClient = (*Client)(nil)
// ListDestinationsPaginatorOptions is the paginator options for ListDestinations
type ListDestinationsPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListDestinationsPaginator is a paginator for ListDestinations
type ListDestinationsPaginator struct {
options ListDestinationsPaginatorOptions
client ListDestinationsAPIClient
params *ListDestinationsInput
nextToken *string
firstPage bool
}
// NewListDestinationsPaginator returns a new ListDestinationsPaginator
func NewListDestinationsPaginator(client ListDestinationsAPIClient, params *ListDestinationsInput, optFns ...func(*ListDestinationsPaginatorOptions)) *ListDestinationsPaginator {
if params == nil {
params = &ListDestinationsInput{}
}
options := ListDestinationsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDestinationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDestinationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDestinations page.
func (p *ListDestinationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDestinationsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListDestinations(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_opListDestinations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListDestinations",
}
}
| 215 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the device profiles registered to your AWS account.
func (c *Client) ListDeviceProfiles(ctx context.Context, params *ListDeviceProfilesInput, optFns ...func(*Options)) (*ListDeviceProfilesOutput, error) {
if params == nil {
params = &ListDeviceProfilesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDeviceProfiles", params, optFns, c.addOperationListDeviceProfilesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDeviceProfilesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDeviceProfilesInput struct {
// A filter to list only device profiles that use this type, which can be LoRaWAN
// or Sidewalk .
DeviceProfileType types.DeviceProfileType
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListDeviceProfilesOutput struct {
// The list of device profiles.
DeviceProfileList []types.DeviceProfile
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDeviceProfilesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDeviceProfiles{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDeviceProfiles{}, 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_opListDeviceProfiles(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
}
// ListDeviceProfilesAPIClient is a client that implements the ListDeviceProfiles
// operation.
type ListDeviceProfilesAPIClient interface {
ListDeviceProfiles(context.Context, *ListDeviceProfilesInput, ...func(*Options)) (*ListDeviceProfilesOutput, error)
}
var _ ListDeviceProfilesAPIClient = (*Client)(nil)
// ListDeviceProfilesPaginatorOptions is the paginator options for
// ListDeviceProfiles
type ListDeviceProfilesPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListDeviceProfilesPaginator is a paginator for ListDeviceProfiles
type ListDeviceProfilesPaginator struct {
options ListDeviceProfilesPaginatorOptions
client ListDeviceProfilesAPIClient
params *ListDeviceProfilesInput
nextToken *string
firstPage bool
}
// NewListDeviceProfilesPaginator returns a new ListDeviceProfilesPaginator
func NewListDeviceProfilesPaginator(client ListDeviceProfilesAPIClient, params *ListDeviceProfilesInput, optFns ...func(*ListDeviceProfilesPaginatorOptions)) *ListDeviceProfilesPaginator {
if params == nil {
params = &ListDeviceProfilesInput{}
}
options := ListDeviceProfilesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDeviceProfilesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDeviceProfilesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDeviceProfiles page.
func (p *ListDeviceProfilesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDeviceProfilesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListDeviceProfiles(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_opListDeviceProfiles(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListDeviceProfiles",
}
}
| 220 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List the Sidewalk devices in an import task and their onboarding status.
func (c *Client) ListDevicesForWirelessDeviceImportTask(ctx context.Context, params *ListDevicesForWirelessDeviceImportTaskInput, optFns ...func(*Options)) (*ListDevicesForWirelessDeviceImportTaskOutput, error) {
if params == nil {
params = &ListDevicesForWirelessDeviceImportTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDevicesForWirelessDeviceImportTask", params, optFns, c.addOperationListDevicesForWirelessDeviceImportTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDevicesForWirelessDeviceImportTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDevicesForWirelessDeviceImportTaskInput struct {
// The identifier of the import task for which wireless devices are listed.
//
// This member is required.
Id *string
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// The status of the devices in the import task.
Status types.OnboardStatus
noSmithyDocumentSerde
}
type ListDevicesForWirelessDeviceImportTaskOutput struct {
// The name of the Sidewalk destination that describes the IoT rule to route
// messages received from devices in an import task that are onboarded to AWS IoT
// Wireless.
DestinationName *string
// List of wireless devices in an import task and their onboarding status.
ImportedWirelessDeviceList []types.ImportedWirelessDevice
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDevicesForWirelessDeviceImportTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDevicesForWirelessDeviceImportTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDevicesForWirelessDeviceImportTask{}, 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 = addOpListDevicesForWirelessDeviceImportTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDevicesForWirelessDeviceImportTask(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_opListDevicesForWirelessDeviceImportTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListDevicesForWirelessDeviceImportTask",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List event configurations where at least one event topic has been enabled.
func (c *Client) ListEventConfigurations(ctx context.Context, params *ListEventConfigurationsInput, optFns ...func(*Options)) (*ListEventConfigurationsOutput, error) {
if params == nil {
params = &ListEventConfigurationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListEventConfigurations", params, optFns, c.addOperationListEventConfigurationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListEventConfigurationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListEventConfigurationsInput struct {
// Resource type to filter event configurations.
//
// This member is required.
ResourceType types.EventNotificationResourceType
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListEventConfigurationsOutput struct {
// Event configurations of all events for a single resource.
EventConfigurationsList []types.EventConfigurationItem
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListEventConfigurationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListEventConfigurations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListEventConfigurations{}, 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 = addOpListEventConfigurationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListEventConfigurations(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_opListEventConfigurations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListEventConfigurations",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the FUOTA tasks registered to your AWS account.
func (c *Client) ListFuotaTasks(ctx context.Context, params *ListFuotaTasksInput, optFns ...func(*Options)) (*ListFuotaTasksOutput, error) {
if params == nil {
params = &ListFuotaTasksInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFuotaTasks", params, optFns, c.addOperationListFuotaTasksMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFuotaTasksOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFuotaTasksInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListFuotaTasksOutput struct {
// Lists the FUOTA tasks registered to your AWS account.
FuotaTaskList []types.FuotaTask
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFuotaTasksMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListFuotaTasks{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListFuotaTasks{}, 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_opListFuotaTasks(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
}
// ListFuotaTasksAPIClient is a client that implements the ListFuotaTasks
// operation.
type ListFuotaTasksAPIClient interface {
ListFuotaTasks(context.Context, *ListFuotaTasksInput, ...func(*Options)) (*ListFuotaTasksOutput, error)
}
var _ ListFuotaTasksAPIClient = (*Client)(nil)
// ListFuotaTasksPaginatorOptions is the paginator options for ListFuotaTasks
type ListFuotaTasksPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListFuotaTasksPaginator is a paginator for ListFuotaTasks
type ListFuotaTasksPaginator struct {
options ListFuotaTasksPaginatorOptions
client ListFuotaTasksAPIClient
params *ListFuotaTasksInput
nextToken *string
firstPage bool
}
// NewListFuotaTasksPaginator returns a new ListFuotaTasksPaginator
func NewListFuotaTasksPaginator(client ListFuotaTasksAPIClient, params *ListFuotaTasksInput, optFns ...func(*ListFuotaTasksPaginatorOptions)) *ListFuotaTasksPaginator {
if params == nil {
params = &ListFuotaTasksInput{}
}
options := ListFuotaTasksPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListFuotaTasksPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListFuotaTasksPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListFuotaTasks page.
func (p *ListFuotaTasksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFuotaTasksOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListFuotaTasks(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_opListFuotaTasks(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListFuotaTasks",
}
}
| 215 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the multicast groups registered to your AWS account.
func (c *Client) ListMulticastGroups(ctx context.Context, params *ListMulticastGroupsInput, optFns ...func(*Options)) (*ListMulticastGroupsOutput, error) {
if params == nil {
params = &ListMulticastGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMulticastGroups", params, optFns, c.addOperationListMulticastGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMulticastGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMulticastGroupsInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListMulticastGroupsOutput struct {
// List of multicast groups.
MulticastGroupList []types.MulticastGroup
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMulticastGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListMulticastGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListMulticastGroups{}, 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_opListMulticastGroups(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
}
// ListMulticastGroupsAPIClient is a client that implements the
// ListMulticastGroups operation.
type ListMulticastGroupsAPIClient interface {
ListMulticastGroups(context.Context, *ListMulticastGroupsInput, ...func(*Options)) (*ListMulticastGroupsOutput, error)
}
var _ ListMulticastGroupsAPIClient = (*Client)(nil)
// ListMulticastGroupsPaginatorOptions is the paginator options for
// ListMulticastGroups
type ListMulticastGroupsPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListMulticastGroupsPaginator is a paginator for ListMulticastGroups
type ListMulticastGroupsPaginator struct {
options ListMulticastGroupsPaginatorOptions
client ListMulticastGroupsAPIClient
params *ListMulticastGroupsInput
nextToken *string
firstPage bool
}
// NewListMulticastGroupsPaginator returns a new ListMulticastGroupsPaginator
func NewListMulticastGroupsPaginator(client ListMulticastGroupsAPIClient, params *ListMulticastGroupsInput, optFns ...func(*ListMulticastGroupsPaginatorOptions)) *ListMulticastGroupsPaginator {
if params == nil {
params = &ListMulticastGroupsInput{}
}
options := ListMulticastGroupsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMulticastGroupsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMulticastGroupsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMulticastGroups page.
func (p *ListMulticastGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMulticastGroupsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListMulticastGroups(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_opListMulticastGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListMulticastGroups",
}
}
| 216 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List all multicast groups associated with a fuota task.
func (c *Client) ListMulticastGroupsByFuotaTask(ctx context.Context, params *ListMulticastGroupsByFuotaTaskInput, optFns ...func(*Options)) (*ListMulticastGroupsByFuotaTaskOutput, error) {
if params == nil {
params = &ListMulticastGroupsByFuotaTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMulticastGroupsByFuotaTask", params, optFns, c.addOperationListMulticastGroupsByFuotaTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMulticastGroupsByFuotaTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMulticastGroupsByFuotaTaskInput struct {
// The ID of a FUOTA task.
//
// This member is required.
Id *string
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListMulticastGroupsByFuotaTaskOutput struct {
// List of multicast groups associated with a FUOTA task.
MulticastGroupList []types.MulticastGroupByFuotaTask
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMulticastGroupsByFuotaTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListMulticastGroupsByFuotaTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListMulticastGroupsByFuotaTask{}, 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 = addOpListMulticastGroupsByFuotaTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListMulticastGroupsByFuotaTask(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
}
// ListMulticastGroupsByFuotaTaskAPIClient is a client that implements the
// ListMulticastGroupsByFuotaTask operation.
type ListMulticastGroupsByFuotaTaskAPIClient interface {
ListMulticastGroupsByFuotaTask(context.Context, *ListMulticastGroupsByFuotaTaskInput, ...func(*Options)) (*ListMulticastGroupsByFuotaTaskOutput, error)
}
var _ ListMulticastGroupsByFuotaTaskAPIClient = (*Client)(nil)
// ListMulticastGroupsByFuotaTaskPaginatorOptions is the paginator options for
// ListMulticastGroupsByFuotaTask
type ListMulticastGroupsByFuotaTaskPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListMulticastGroupsByFuotaTaskPaginator is a paginator for
// ListMulticastGroupsByFuotaTask
type ListMulticastGroupsByFuotaTaskPaginator struct {
options ListMulticastGroupsByFuotaTaskPaginatorOptions
client ListMulticastGroupsByFuotaTaskAPIClient
params *ListMulticastGroupsByFuotaTaskInput
nextToken *string
firstPage bool
}
// NewListMulticastGroupsByFuotaTaskPaginator returns a new
// ListMulticastGroupsByFuotaTaskPaginator
func NewListMulticastGroupsByFuotaTaskPaginator(client ListMulticastGroupsByFuotaTaskAPIClient, params *ListMulticastGroupsByFuotaTaskInput, optFns ...func(*ListMulticastGroupsByFuotaTaskPaginatorOptions)) *ListMulticastGroupsByFuotaTaskPaginator {
if params == nil {
params = &ListMulticastGroupsByFuotaTaskInput{}
}
options := ListMulticastGroupsByFuotaTaskPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMulticastGroupsByFuotaTaskPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMulticastGroupsByFuotaTaskPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMulticastGroupsByFuotaTask page.
func (p *ListMulticastGroupsByFuotaTaskPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMulticastGroupsByFuotaTaskOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListMulticastGroupsByFuotaTask(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_opListMulticastGroupsByFuotaTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListMulticastGroupsByFuotaTask",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the network analyzer configurations.
func (c *Client) ListNetworkAnalyzerConfigurations(ctx context.Context, params *ListNetworkAnalyzerConfigurationsInput, optFns ...func(*Options)) (*ListNetworkAnalyzerConfigurationsOutput, error) {
if params == nil {
params = &ListNetworkAnalyzerConfigurationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListNetworkAnalyzerConfigurations", params, optFns, c.addOperationListNetworkAnalyzerConfigurationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListNetworkAnalyzerConfigurationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListNetworkAnalyzerConfigurationsInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListNetworkAnalyzerConfigurationsOutput struct {
// The list of network analyzer configurations.
NetworkAnalyzerConfigurationList []types.NetworkAnalyzerConfigurations
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListNetworkAnalyzerConfigurationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListNetworkAnalyzerConfigurations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListNetworkAnalyzerConfigurations{}, 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_opListNetworkAnalyzerConfigurations(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
}
// ListNetworkAnalyzerConfigurationsAPIClient is a client that implements the
// ListNetworkAnalyzerConfigurations operation.
type ListNetworkAnalyzerConfigurationsAPIClient interface {
ListNetworkAnalyzerConfigurations(context.Context, *ListNetworkAnalyzerConfigurationsInput, ...func(*Options)) (*ListNetworkAnalyzerConfigurationsOutput, error)
}
var _ ListNetworkAnalyzerConfigurationsAPIClient = (*Client)(nil)
// ListNetworkAnalyzerConfigurationsPaginatorOptions is the paginator options for
// ListNetworkAnalyzerConfigurations
type ListNetworkAnalyzerConfigurationsPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListNetworkAnalyzerConfigurationsPaginator is a paginator for
// ListNetworkAnalyzerConfigurations
type ListNetworkAnalyzerConfigurationsPaginator struct {
options ListNetworkAnalyzerConfigurationsPaginatorOptions
client ListNetworkAnalyzerConfigurationsAPIClient
params *ListNetworkAnalyzerConfigurationsInput
nextToken *string
firstPage bool
}
// NewListNetworkAnalyzerConfigurationsPaginator returns a new
// ListNetworkAnalyzerConfigurationsPaginator
func NewListNetworkAnalyzerConfigurationsPaginator(client ListNetworkAnalyzerConfigurationsAPIClient, params *ListNetworkAnalyzerConfigurationsInput, optFns ...func(*ListNetworkAnalyzerConfigurationsPaginatorOptions)) *ListNetworkAnalyzerConfigurationsPaginator {
if params == nil {
params = &ListNetworkAnalyzerConfigurationsInput{}
}
options := ListNetworkAnalyzerConfigurationsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListNetworkAnalyzerConfigurationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListNetworkAnalyzerConfigurationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListNetworkAnalyzerConfigurations page.
func (p *ListNetworkAnalyzerConfigurationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListNetworkAnalyzerConfigurationsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListNetworkAnalyzerConfigurations(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_opListNetworkAnalyzerConfigurations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListNetworkAnalyzerConfigurations",
}
}
| 218 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the partner accounts associated with your AWS account.
func (c *Client) ListPartnerAccounts(ctx context.Context, params *ListPartnerAccountsInput, optFns ...func(*Options)) (*ListPartnerAccountsOutput, error) {
if params == nil {
params = &ListPartnerAccountsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListPartnerAccounts", params, optFns, c.addOperationListPartnerAccountsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListPartnerAccountsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListPartnerAccountsInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListPartnerAccountsOutput struct {
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// The Sidewalk account credentials.
Sidewalk []types.SidewalkAccountInfoWithFingerprint
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListPartnerAccountsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListPartnerAccounts{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListPartnerAccounts{}, 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_opListPartnerAccounts(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_opListPartnerAccounts(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListPartnerAccounts",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List position configurations for a given resource, such as positioning solvers.
// This action is no longer supported. Calls to retrieve position information
// should use the GetResourcePosition (https://docs.aws.amazon.com/iot-wireless/2020-11-22/apireference/API_GetResourcePosition.html)
// API operation instead.
//
// Deprecated: This operation is no longer supported.
func (c *Client) ListPositionConfigurations(ctx context.Context, params *ListPositionConfigurationsInput, optFns ...func(*Options)) (*ListPositionConfigurationsOutput, error) {
if params == nil {
params = &ListPositionConfigurationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListPositionConfigurations", params, optFns, c.addOperationListPositionConfigurationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListPositionConfigurationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListPositionConfigurationsInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// Resource type for which position configurations are listed.
ResourceType types.PositionResourceType
noSmithyDocumentSerde
}
type ListPositionConfigurationsOutput struct {
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// A list of position configurations.
PositionConfigurationList []types.PositionConfigurationItem
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListPositionConfigurationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListPositionConfigurations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListPositionConfigurations{}, 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_opListPositionConfigurations(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
}
// ListPositionConfigurationsAPIClient is a client that implements the
// ListPositionConfigurations operation.
type ListPositionConfigurationsAPIClient interface {
ListPositionConfigurations(context.Context, *ListPositionConfigurationsInput, ...func(*Options)) (*ListPositionConfigurationsOutput, error)
}
var _ ListPositionConfigurationsAPIClient = (*Client)(nil)
// ListPositionConfigurationsPaginatorOptions is the paginator options for
// ListPositionConfigurations
type ListPositionConfigurationsPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListPositionConfigurationsPaginator is a paginator for
// ListPositionConfigurations
type ListPositionConfigurationsPaginator struct {
options ListPositionConfigurationsPaginatorOptions
client ListPositionConfigurationsAPIClient
params *ListPositionConfigurationsInput
nextToken *string
firstPage bool
}
// NewListPositionConfigurationsPaginator returns a new
// ListPositionConfigurationsPaginator
func NewListPositionConfigurationsPaginator(client ListPositionConfigurationsAPIClient, params *ListPositionConfigurationsInput, optFns ...func(*ListPositionConfigurationsPaginatorOptions)) *ListPositionConfigurationsPaginator {
if params == nil {
params = &ListPositionConfigurationsInput{}
}
options := ListPositionConfigurationsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListPositionConfigurationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListPositionConfigurationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListPositionConfigurations page.
func (p *ListPositionConfigurationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPositionConfigurationsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListPositionConfigurations(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_opListPositionConfigurations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListPositionConfigurations",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List queued messages in the downlink queue.
func (c *Client) ListQueuedMessages(ctx context.Context, params *ListQueuedMessagesInput, optFns ...func(*Options)) (*ListQueuedMessagesOutput, error) {
if params == nil {
params = &ListQueuedMessagesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListQueuedMessages", params, optFns, c.addOperationListQueuedMessagesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListQueuedMessagesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListQueuedMessagesInput struct {
// The ID of a given wireless device which the downlink message packets are being
// sent.
//
// This member is required.
Id *string
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// The wireless device type, whic can be either Sidewalk or LoRaWAN.
WirelessDeviceType types.WirelessDeviceType
noSmithyDocumentSerde
}
type ListQueuedMessagesOutput struct {
// The messages in the downlink queue.
DownlinkQueueMessagesList []types.DownlinkQueueMessage
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListQueuedMessagesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListQueuedMessages{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListQueuedMessages{}, 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 = addOpListQueuedMessagesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListQueuedMessages(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
}
// ListQueuedMessagesAPIClient is a client that implements the ListQueuedMessages
// operation.
type ListQueuedMessagesAPIClient interface {
ListQueuedMessages(context.Context, *ListQueuedMessagesInput, ...func(*Options)) (*ListQueuedMessagesOutput, error)
}
var _ ListQueuedMessagesAPIClient = (*Client)(nil)
// ListQueuedMessagesPaginatorOptions is the paginator options for
// ListQueuedMessages
type ListQueuedMessagesPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListQueuedMessagesPaginator is a paginator for ListQueuedMessages
type ListQueuedMessagesPaginator struct {
options ListQueuedMessagesPaginatorOptions
client ListQueuedMessagesAPIClient
params *ListQueuedMessagesInput
nextToken *string
firstPage bool
}
// NewListQueuedMessagesPaginator returns a new ListQueuedMessagesPaginator
func NewListQueuedMessagesPaginator(client ListQueuedMessagesAPIClient, params *ListQueuedMessagesInput, optFns ...func(*ListQueuedMessagesPaginatorOptions)) *ListQueuedMessagesPaginator {
if params == nil {
params = &ListQueuedMessagesInput{}
}
options := ListQueuedMessagesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListQueuedMessagesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListQueuedMessagesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListQueuedMessages page.
func (p *ListQueuedMessagesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListQueuedMessagesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListQueuedMessages(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_opListQueuedMessages(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListQueuedMessages",
}
}
| 228 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the service profiles registered to your AWS account.
func (c *Client) ListServiceProfiles(ctx context.Context, params *ListServiceProfilesInput, optFns ...func(*Options)) (*ListServiceProfilesOutput, error) {
if params == nil {
params = &ListServiceProfilesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListServiceProfiles", params, optFns, c.addOperationListServiceProfilesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListServiceProfilesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListServiceProfilesInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListServiceProfilesOutput struct {
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// The list of service profiles.
ServiceProfileList []types.ServiceProfile
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListServiceProfilesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListServiceProfiles{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListServiceProfiles{}, 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_opListServiceProfiles(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
}
// ListServiceProfilesAPIClient is a client that implements the
// ListServiceProfiles operation.
type ListServiceProfilesAPIClient interface {
ListServiceProfiles(context.Context, *ListServiceProfilesInput, ...func(*Options)) (*ListServiceProfilesOutput, error)
}
var _ ListServiceProfilesAPIClient = (*Client)(nil)
// ListServiceProfilesPaginatorOptions is the paginator options for
// ListServiceProfiles
type ListServiceProfilesPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListServiceProfilesPaginator is a paginator for ListServiceProfiles
type ListServiceProfilesPaginator struct {
options ListServiceProfilesPaginatorOptions
client ListServiceProfilesAPIClient
params *ListServiceProfilesInput
nextToken *string
firstPage bool
}
// NewListServiceProfilesPaginator returns a new ListServiceProfilesPaginator
func NewListServiceProfilesPaginator(client ListServiceProfilesAPIClient, params *ListServiceProfilesInput, optFns ...func(*ListServiceProfilesPaginatorOptions)) *ListServiceProfilesPaginator {
if params == nil {
params = &ListServiceProfilesInput{}
}
options := ListServiceProfilesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListServiceProfilesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListServiceProfilesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListServiceProfiles page.
func (p *ListServiceProfilesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListServiceProfilesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListServiceProfiles(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_opListServiceProfiles(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListServiceProfiles",
}
}
| 216 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the tags (metadata) you have assigned to the 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 ARN of the resource for which you want to list tags.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The tags to attach to the specified resource. Tags are metadata that you can
// use to manage a resource.
Tags []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: "iotwireless",
OperationName: "ListTagsForResource",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List wireless devices that have been added to an import task.
func (c *Client) ListWirelessDeviceImportTasks(ctx context.Context, params *ListWirelessDeviceImportTasksInput, optFns ...func(*Options)) (*ListWirelessDeviceImportTasksOutput, error) {
if params == nil {
params = &ListWirelessDeviceImportTasksInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListWirelessDeviceImportTasks", params, optFns, c.addOperationListWirelessDeviceImportTasksMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListWirelessDeviceImportTasksOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListWirelessDeviceImportTasksInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListWirelessDeviceImportTasksOutput struct {
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// List of import tasks and summary information of onboarding status of devices in
// each import task.
WirelessDeviceImportTaskList []types.WirelessDeviceImportTask
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListWirelessDeviceImportTasksMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListWirelessDeviceImportTasks{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListWirelessDeviceImportTasks{}, 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_opListWirelessDeviceImportTasks(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_opListWirelessDeviceImportTasks(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListWirelessDeviceImportTasks",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the wireless devices registered to your AWS account.
func (c *Client) ListWirelessDevices(ctx context.Context, params *ListWirelessDevicesInput, optFns ...func(*Options)) (*ListWirelessDevicesOutput, error) {
if params == nil {
params = &ListWirelessDevicesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListWirelessDevices", params, optFns, c.addOperationListWirelessDevicesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListWirelessDevicesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListWirelessDevicesInput struct {
// A filter to list only the wireless devices that use this destination.
DestinationName *string
// A filter to list only the wireless devices that use this device profile.
DeviceProfileId *string
// The ID of a FUOTA task.
FuotaTaskId *string
// The maximum number of results to return in this operation.
MaxResults int32
// The ID of the multicast group.
MulticastGroupId *string
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// A filter to list only the wireless devices that use this service profile.
ServiceProfileId *string
// A filter to list only the wireless devices that use this wireless device type.
WirelessDeviceType types.WirelessDeviceType
noSmithyDocumentSerde
}
type ListWirelessDevicesOutput struct {
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// The ID of the wireless device.
WirelessDeviceList []types.WirelessDeviceStatistics
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListWirelessDevicesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListWirelessDevices{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListWirelessDevices{}, 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_opListWirelessDevices(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
}
// ListWirelessDevicesAPIClient is a client that implements the
// ListWirelessDevices operation.
type ListWirelessDevicesAPIClient interface {
ListWirelessDevices(context.Context, *ListWirelessDevicesInput, ...func(*Options)) (*ListWirelessDevicesOutput, error)
}
var _ ListWirelessDevicesAPIClient = (*Client)(nil)
// ListWirelessDevicesPaginatorOptions is the paginator options for
// ListWirelessDevices
type ListWirelessDevicesPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListWirelessDevicesPaginator is a paginator for ListWirelessDevices
type ListWirelessDevicesPaginator struct {
options ListWirelessDevicesPaginatorOptions
client ListWirelessDevicesAPIClient
params *ListWirelessDevicesInput
nextToken *string
firstPage bool
}
// NewListWirelessDevicesPaginator returns a new ListWirelessDevicesPaginator
func NewListWirelessDevicesPaginator(client ListWirelessDevicesAPIClient, params *ListWirelessDevicesInput, optFns ...func(*ListWirelessDevicesPaginatorOptions)) *ListWirelessDevicesPaginator {
if params == nil {
params = &ListWirelessDevicesInput{}
}
options := ListWirelessDevicesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListWirelessDevicesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListWirelessDevicesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListWirelessDevices page.
func (p *ListWirelessDevicesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListWirelessDevicesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListWirelessDevices(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_opListWirelessDevices(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListWirelessDevices",
}
}
| 234 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the wireless gateways registered to your AWS account.
func (c *Client) ListWirelessGateways(ctx context.Context, params *ListWirelessGatewaysInput, optFns ...func(*Options)) (*ListWirelessGatewaysOutput, error) {
if params == nil {
params = &ListWirelessGatewaysInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListWirelessGateways", params, optFns, c.addOperationListWirelessGatewaysMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListWirelessGatewaysOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListWirelessGatewaysInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListWirelessGatewaysOutput struct {
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// The ID of the wireless gateway.
WirelessGatewayList []types.WirelessGatewayStatistics
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListWirelessGatewaysMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListWirelessGateways{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListWirelessGateways{}, 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_opListWirelessGateways(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
}
// ListWirelessGatewaysAPIClient is a client that implements the
// ListWirelessGateways operation.
type ListWirelessGatewaysAPIClient interface {
ListWirelessGateways(context.Context, *ListWirelessGatewaysInput, ...func(*Options)) (*ListWirelessGatewaysOutput, error)
}
var _ ListWirelessGatewaysAPIClient = (*Client)(nil)
// ListWirelessGatewaysPaginatorOptions is the paginator options for
// ListWirelessGateways
type ListWirelessGatewaysPaginatorOptions struct {
// The maximum number of results to return in this operation.
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
}
// ListWirelessGatewaysPaginator is a paginator for ListWirelessGateways
type ListWirelessGatewaysPaginator struct {
options ListWirelessGatewaysPaginatorOptions
client ListWirelessGatewaysAPIClient
params *ListWirelessGatewaysInput
nextToken *string
firstPage bool
}
// NewListWirelessGatewaysPaginator returns a new ListWirelessGatewaysPaginator
func NewListWirelessGatewaysPaginator(client ListWirelessGatewaysAPIClient, params *ListWirelessGatewaysInput, optFns ...func(*ListWirelessGatewaysPaginatorOptions)) *ListWirelessGatewaysPaginator {
if params == nil {
params = &ListWirelessGatewaysInput{}
}
options := ListWirelessGatewaysPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListWirelessGatewaysPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListWirelessGatewaysPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListWirelessGateways page.
func (p *ListWirelessGatewaysPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListWirelessGatewaysOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListWirelessGateways(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_opListWirelessGateways(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListWirelessGateways",
}
}
| 216 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List the wireless gateway tasks definitions registered to your AWS account.
func (c *Client) ListWirelessGatewayTaskDefinitions(ctx context.Context, params *ListWirelessGatewayTaskDefinitionsInput, optFns ...func(*Options)) (*ListWirelessGatewayTaskDefinitionsOutput, error) {
if params == nil {
params = &ListWirelessGatewayTaskDefinitionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListWirelessGatewayTaskDefinitions", params, optFns, c.addOperationListWirelessGatewayTaskDefinitionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListWirelessGatewayTaskDefinitionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListWirelessGatewayTaskDefinitionsInput struct {
// The maximum number of results to return in this operation.
MaxResults int32
// To retrieve the next set of results, the nextToken value from a previous
// response; otherwise null to receive the first set of results.
NextToken *string
// A filter to list only the wireless gateway task definitions that use this task
// definition type.
TaskDefinitionType types.WirelessGatewayTaskDefinitionType
noSmithyDocumentSerde
}
type ListWirelessGatewayTaskDefinitionsOutput struct {
// The token to use to get the next set of results, or null if there are no
// additional results.
NextToken *string
// The list of task definitions.
TaskDefinitions []types.UpdateWirelessGatewayTaskEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListWirelessGatewayTaskDefinitionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListWirelessGatewayTaskDefinitions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListWirelessGatewayTaskDefinitions{}, 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_opListWirelessGatewayTaskDefinitions(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_opListWirelessGatewayTaskDefinitions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ListWirelessGatewayTaskDefinitions",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Put position configuration for a given resource. This action is no longer
// supported. Calls to update the position configuration should use the
// UpdateResourcePosition (https://docs.aws.amazon.com/iot-wireless/2020-11-22/apireference/API_UpdateResourcePosition.html)
// API operation instead.
//
// Deprecated: This operation is no longer supported.
func (c *Client) PutPositionConfiguration(ctx context.Context, params *PutPositionConfigurationInput, optFns ...func(*Options)) (*PutPositionConfigurationOutput, error) {
if params == nil {
params = &PutPositionConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutPositionConfiguration", params, optFns, c.addOperationPutPositionConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutPositionConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutPositionConfigurationInput struct {
// Resource identifier used to update the position configuration.
//
// This member is required.
ResourceIdentifier *string
// Resource type of the resource for which you want to update the position
// configuration.
//
// This member is required.
ResourceType types.PositionResourceType
// The position data destination that describes the AWS IoT rule that processes
// the device's position data for use by AWS IoT Core for LoRaWAN.
Destination *string
// The positioning solvers used to update the position configuration of the
// resource.
Solvers *types.PositionSolverConfigurations
noSmithyDocumentSerde
}
type PutPositionConfigurationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutPositionConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutPositionConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutPositionConfiguration{}, 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 = addOpPutPositionConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutPositionConfiguration(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_opPutPositionConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "PutPositionConfiguration",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Sets the log-level override for a resource-ID and resource-type. This option
// can be specified for a wireless gateway or a wireless device. A limit of 200 log
// level override can be set per account.
func (c *Client) PutResourceLogLevel(ctx context.Context, params *PutResourceLogLevelInput, optFns ...func(*Options)) (*PutResourceLogLevelOutput, error) {
if params == nil {
params = &PutResourceLogLevelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutResourceLogLevel", params, optFns, c.addOperationPutResourceLogLevelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutResourceLogLevelOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutResourceLogLevelInput struct {
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
//
// This member is required.
LogLevel types.LogLevel
// The identifier of the resource. For a Wireless Device, it is the wireless
// device ID. For a wireless gateway, it is the wireless gateway ID.
//
// This member is required.
ResourceIdentifier *string
// The type of the resource, which can be WirelessDevice or WirelessGateway .
//
// This member is required.
ResourceType *string
noSmithyDocumentSerde
}
type PutResourceLogLevelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutResourceLogLevelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutResourceLogLevel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutResourceLogLevel{}, 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 = addOpPutResourceLogLevelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutResourceLogLevel(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_opPutResourceLogLevel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "PutResourceLogLevel",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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 the log-level overrides for all resources; both wireless devices and
// wireless gateways.
func (c *Client) ResetAllResourceLogLevels(ctx context.Context, params *ResetAllResourceLogLevelsInput, optFns ...func(*Options)) (*ResetAllResourceLogLevelsOutput, error) {
if params == nil {
params = &ResetAllResourceLogLevelsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ResetAllResourceLogLevels", params, optFns, c.addOperationResetAllResourceLogLevelsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ResetAllResourceLogLevelsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ResetAllResourceLogLevelsInput struct {
noSmithyDocumentSerde
}
type ResetAllResourceLogLevelsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationResetAllResourceLogLevelsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpResetAllResourceLogLevels{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpResetAllResourceLogLevels{}, 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_opResetAllResourceLogLevels(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_opResetAllResourceLogLevels(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ResetAllResourceLogLevels",
}
}
| 112 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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 the log-level override, if any, for a specific resource-ID and
// resource-type. It can be used for a wireless device or a wireless gateway.
func (c *Client) ResetResourceLogLevel(ctx context.Context, params *ResetResourceLogLevelInput, optFns ...func(*Options)) (*ResetResourceLogLevelOutput, error) {
if params == nil {
params = &ResetResourceLogLevelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ResetResourceLogLevel", params, optFns, c.addOperationResetResourceLogLevelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ResetResourceLogLevelOutput)
out.ResultMetadata = metadata
return out, nil
}
type ResetResourceLogLevelInput struct {
// The identifier of the resource. For a Wireless Device, it is the wireless
// device ID. For a wireless gateway, it is the wireless gateway ID.
//
// This member is required.
ResourceIdentifier *string
// The type of the resource, which can be WirelessDevice or WirelessGateway .
//
// This member is required.
ResourceType *string
noSmithyDocumentSerde
}
type ResetResourceLogLevelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationResetResourceLogLevelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpResetResourceLogLevel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpResetResourceLogLevel{}, 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 = addOpResetResourceLogLevelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opResetResourceLogLevel(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_opResetResourceLogLevel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "ResetResourceLogLevel",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Sends the specified data to a multicast group.
func (c *Client) SendDataToMulticastGroup(ctx context.Context, params *SendDataToMulticastGroupInput, optFns ...func(*Options)) (*SendDataToMulticastGroupOutput, error) {
if params == nil {
params = &SendDataToMulticastGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SendDataToMulticastGroup", params, optFns, c.addOperationSendDataToMulticastGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SendDataToMulticastGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type SendDataToMulticastGroupInput struct {
// The ID of the multicast group.
//
// This member is required.
Id *string
// The binary to be sent to the end device, encoded in base64.
//
// This member is required.
PayloadData *string
// Wireless metadata that is to be sent to multicast group.
//
// This member is required.
WirelessMetadata *types.MulticastWirelessMetadata
noSmithyDocumentSerde
}
type SendDataToMulticastGroupOutput struct {
// ID of a multicast group message.
MessageId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSendDataToMulticastGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpSendDataToMulticastGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSendDataToMulticastGroup{}, 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 = addOpSendDataToMulticastGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSendDataToMulticastGroup(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_opSendDataToMulticastGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "SendDataToMulticastGroup",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Sends a decrypted application data frame to a device.
func (c *Client) SendDataToWirelessDevice(ctx context.Context, params *SendDataToWirelessDeviceInput, optFns ...func(*Options)) (*SendDataToWirelessDeviceOutput, error) {
if params == nil {
params = &SendDataToWirelessDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SendDataToWirelessDevice", params, optFns, c.addOperationSendDataToWirelessDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SendDataToWirelessDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type SendDataToWirelessDeviceInput struct {
// The ID of the wireless device to receive the data.
//
// This member is required.
Id *string
// The binary to be sent to the end device, encoded in base64.
//
// This member is required.
PayloadData *string
// The transmit mode to use to send data to the wireless device. Can be: 0 for UM
// (unacknowledge mode) or 1 for AM (acknowledge mode).
//
// This member is required.
TransmitMode *int32
// Metadata about the message request.
WirelessMetadata *types.WirelessMetadata
noSmithyDocumentSerde
}
type SendDataToWirelessDeviceOutput struct {
// The ID of the message sent to the wireless device.
MessageId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSendDataToWirelessDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpSendDataToWirelessDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSendDataToWirelessDevice{}, 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 = addOpSendDataToWirelessDeviceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSendDataToWirelessDevice(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_opSendDataToWirelessDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "SendDataToWirelessDevice",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a bulk association of all qualifying wireless devices with a multicast
// group.
func (c *Client) StartBulkAssociateWirelessDeviceWithMulticastGroup(ctx context.Context, params *StartBulkAssociateWirelessDeviceWithMulticastGroupInput, optFns ...func(*Options)) (*StartBulkAssociateWirelessDeviceWithMulticastGroupOutput, error) {
if params == nil {
params = &StartBulkAssociateWirelessDeviceWithMulticastGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartBulkAssociateWirelessDeviceWithMulticastGroup", params, optFns, c.addOperationStartBulkAssociateWirelessDeviceWithMulticastGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartBulkAssociateWirelessDeviceWithMulticastGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartBulkAssociateWirelessDeviceWithMulticastGroupInput struct {
// The ID of the multicast group.
//
// This member is required.
Id *string
// Query string used to search for wireless devices as part of the bulk associate
// and disassociate process.
QueryString *string
// The tag to attach to the specified resource. Tags are metadata that you can use
// to manage a resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type StartBulkAssociateWirelessDeviceWithMulticastGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartBulkAssociateWirelessDeviceWithMulticastGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartBulkAssociateWirelessDeviceWithMulticastGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartBulkAssociateWirelessDeviceWithMulticastGroup{}, 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 = addOpStartBulkAssociateWirelessDeviceWithMulticastGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartBulkAssociateWirelessDeviceWithMulticastGroup(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_opStartBulkAssociateWirelessDeviceWithMulticastGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "StartBulkAssociateWirelessDeviceWithMulticastGroup",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a bulk disassociatin of all qualifying wireless devices from a multicast
// group.
func (c *Client) StartBulkDisassociateWirelessDeviceFromMulticastGroup(ctx context.Context, params *StartBulkDisassociateWirelessDeviceFromMulticastGroupInput, optFns ...func(*Options)) (*StartBulkDisassociateWirelessDeviceFromMulticastGroupOutput, error) {
if params == nil {
params = &StartBulkDisassociateWirelessDeviceFromMulticastGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartBulkDisassociateWirelessDeviceFromMulticastGroup", params, optFns, c.addOperationStartBulkDisassociateWirelessDeviceFromMulticastGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartBulkDisassociateWirelessDeviceFromMulticastGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartBulkDisassociateWirelessDeviceFromMulticastGroupInput struct {
// The ID of the multicast group.
//
// This member is required.
Id *string
// Query string used to search for wireless devices as part of the bulk associate
// and disassociate process.
QueryString *string
// The tag to attach to the specified resource. Tags are metadata that you can use
// to manage a resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type StartBulkDisassociateWirelessDeviceFromMulticastGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartBulkDisassociateWirelessDeviceFromMulticastGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartBulkDisassociateWirelessDeviceFromMulticastGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartBulkDisassociateWirelessDeviceFromMulticastGroup{}, 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 = addOpStartBulkDisassociateWirelessDeviceFromMulticastGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartBulkDisassociateWirelessDeviceFromMulticastGroup(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_opStartBulkDisassociateWirelessDeviceFromMulticastGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "StartBulkDisassociateWirelessDeviceFromMulticastGroup",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a FUOTA task.
func (c *Client) StartFuotaTask(ctx context.Context, params *StartFuotaTaskInput, optFns ...func(*Options)) (*StartFuotaTaskOutput, error) {
if params == nil {
params = &StartFuotaTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartFuotaTask", params, optFns, c.addOperationStartFuotaTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartFuotaTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartFuotaTaskInput struct {
// The ID of a FUOTA task.
//
// This member is required.
Id *string
// The LoRaWAN information used to start a FUOTA task.
LoRaWAN *types.LoRaWANStartFuotaTask
noSmithyDocumentSerde
}
type StartFuotaTaskOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartFuotaTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartFuotaTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartFuotaTask{}, 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 = addOpStartFuotaTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartFuotaTask(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_opStartFuotaTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "StartFuotaTask",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a multicast group session.
func (c *Client) StartMulticastGroupSession(ctx context.Context, params *StartMulticastGroupSessionInput, optFns ...func(*Options)) (*StartMulticastGroupSessionOutput, error) {
if params == nil {
params = &StartMulticastGroupSessionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartMulticastGroupSession", params, optFns, c.addOperationStartMulticastGroupSessionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartMulticastGroupSessionOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartMulticastGroupSessionInput struct {
// The ID of the multicast group.
//
// This member is required.
Id *string
// The LoRaWAN information used with the multicast session.
//
// This member is required.
LoRaWAN *types.LoRaWANMulticastSession
noSmithyDocumentSerde
}
type StartMulticastGroupSessionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartMulticastGroupSessionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartMulticastGroupSession{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartMulticastGroupSession{}, 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 = addOpStartMulticastGroupSessionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartMulticastGroupSession(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_opStartMulticastGroupSession(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "StartMulticastGroupSession",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Start import task for a single wireless device.
func (c *Client) StartSingleWirelessDeviceImportTask(ctx context.Context, params *StartSingleWirelessDeviceImportTaskInput, optFns ...func(*Options)) (*StartSingleWirelessDeviceImportTaskOutput, error) {
if params == nil {
params = &StartSingleWirelessDeviceImportTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartSingleWirelessDeviceImportTask", params, optFns, c.addOperationStartSingleWirelessDeviceImportTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartSingleWirelessDeviceImportTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartSingleWirelessDeviceImportTaskInput struct {
// The name of the Sidewalk destination that describes the IoT rule to route
// messages from the device in the import task that will be onboarded to AWS IoT
// Wireless.
//
// This member is required.
DestinationName *string
// The Sidewalk-related parameters for importing a single wireless device.
//
// This member is required.
Sidewalk *types.SidewalkSingleStartImportInfo
// Each resource must have a unique client request token. If you try to create a
// new resource with the same token as a resource that already exists, an exception
// occurs. If you omit this value, AWS SDKs will automatically generate a unique
// client request.
ClientRequestToken *string
// The name of the wireless device for which an import task is being started.
DeviceName *string
// The tag to attach to the specified resource. Tags are metadata that you can use
// to manage a resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type StartSingleWirelessDeviceImportTaskOutput struct {
// The ARN (Amazon Resource Name) of the import task.
Arn *string
// The import task ID.
Id *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartSingleWirelessDeviceImportTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartSingleWirelessDeviceImportTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartSingleWirelessDeviceImportTask{}, 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_opStartSingleWirelessDeviceImportTaskMiddleware(stack, options); err != nil {
return err
}
if err = addOpStartSingleWirelessDeviceImportTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartSingleWirelessDeviceImportTask(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_initializeOpStartSingleWirelessDeviceImportTask struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpStartSingleWirelessDeviceImportTask) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpStartSingleWirelessDeviceImportTask) 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.(*StartSingleWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *StartSingleWirelessDeviceImportTaskInput ")
}
if input.ClientRequestToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientRequestToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opStartSingleWirelessDeviceImportTaskMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpStartSingleWirelessDeviceImportTask{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opStartSingleWirelessDeviceImportTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "StartSingleWirelessDeviceImportTask",
}
}
| 185 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Start import task for provisioning Sidewalk devices in bulk using an S3 CSV
// file.
func (c *Client) StartWirelessDeviceImportTask(ctx context.Context, params *StartWirelessDeviceImportTaskInput, optFns ...func(*Options)) (*StartWirelessDeviceImportTaskOutput, error) {
if params == nil {
params = &StartWirelessDeviceImportTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartWirelessDeviceImportTask", params, optFns, c.addOperationStartWirelessDeviceImportTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartWirelessDeviceImportTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartWirelessDeviceImportTaskInput struct {
// The name of the Sidewalk destination that describes the IoT rule to route
// messages from the devices in the import task that are onboarded to AWS IoT
// Wireless.
//
// This member is required.
DestinationName *string
// The Sidewalk-related parameters for importing wireless devices that need to be
// provisioned in bulk.
//
// This member is required.
Sidewalk *types.SidewalkStartImportInfo
// Each resource must have a unique client request token. If you try to create a
// new resource with the same token as a resource that already exists, an exception
// occurs. If you omit this value, AWS SDKs will automatically generate a unique
// client request.
ClientRequestToken *string
// The tag to attach to the specified resource. Tags are metadata that you can use
// to manage a resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type StartWirelessDeviceImportTaskOutput struct {
// The ARN (Amazon Resource Name) of the import task.
Arn *string
// The import task ID.
Id *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartWirelessDeviceImportTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartWirelessDeviceImportTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartWirelessDeviceImportTask{}, 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_opStartWirelessDeviceImportTaskMiddleware(stack, options); err != nil {
return err
}
if err = addOpStartWirelessDeviceImportTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartWirelessDeviceImportTask(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_initializeOpStartWirelessDeviceImportTask struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpStartWirelessDeviceImportTask) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpStartWirelessDeviceImportTask) 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.(*StartWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *StartWirelessDeviceImportTaskInput ")
}
if input.ClientRequestToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientRequestToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opStartWirelessDeviceImportTaskMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpStartWirelessDeviceImportTask{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opStartWirelessDeviceImportTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "StartWirelessDeviceImportTask",
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds a tag to a 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 ARN of the resource to add tags to.
//
// This member is required.
ResourceArn *string
// Adds to or modifies the tags of the given resource. Tags are metadata that you
// can use to manage a 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: "iotwireless",
OperationName: "TagResource",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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"
)
// Simulates a provisioned device by sending an uplink data payload of Hello .
func (c *Client) TestWirelessDevice(ctx context.Context, params *TestWirelessDeviceInput, optFns ...func(*Options)) (*TestWirelessDeviceOutput, error) {
if params == nil {
params = &TestWirelessDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TestWirelessDevice", params, optFns, c.addOperationTestWirelessDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TestWirelessDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type TestWirelessDeviceInput struct {
// The ID of the wireless device to test.
//
// This member is required.
Id *string
noSmithyDocumentSerde
}
type TestWirelessDeviceOutput struct {
// The result returned by the test.
Result *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTestWirelessDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpTestWirelessDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpTestWirelessDevice{}, 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 = addOpTestWirelessDeviceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTestWirelessDevice(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_opTestWirelessDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "TestWirelessDevice",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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 one or more tags from a 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 ARN of the resource to remove tags from.
//
// This member is required.
ResourceArn *string
// A list of the keys of the tags to remove from the 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: "iotwireless",
OperationName: "UntagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates properties of a destination.
func (c *Client) UpdateDestination(ctx context.Context, params *UpdateDestinationInput, optFns ...func(*Options)) (*UpdateDestinationOutput, error) {
if params == nil {
params = &UpdateDestinationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateDestination", params, optFns, c.addOperationUpdateDestinationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateDestinationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateDestinationInput struct {
// The new name of the resource.
//
// This member is required.
Name *string
// A new description of the resource.
Description *string
// The new rule name or topic rule to send messages to.
Expression *string
// The type of value in Expression .
ExpressionType types.ExpressionType
// The ARN of the IAM Role that authorizes the destination.
RoleArn *string
noSmithyDocumentSerde
}
type UpdateDestinationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateDestinationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateDestination{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateDestination{}, 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 = addOpUpdateDestinationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateDestination(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_opUpdateDestination(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateDestination",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Update the event configuration based on resource types.
func (c *Client) UpdateEventConfigurationByResourceTypes(ctx context.Context, params *UpdateEventConfigurationByResourceTypesInput, optFns ...func(*Options)) (*UpdateEventConfigurationByResourceTypesOutput, error) {
if params == nil {
params = &UpdateEventConfigurationByResourceTypesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateEventConfigurationByResourceTypes", params, optFns, c.addOperationUpdateEventConfigurationByResourceTypesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateEventConfigurationByResourceTypesOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateEventConfigurationByResourceTypesInput struct {
// Connection status resource type event configuration object for enabling and
// disabling wireless gateway topic.
ConnectionStatus *types.ConnectionStatusResourceTypeEventConfiguration
// Device registration state resource type event configuration object for enabling
// and disabling wireless gateway topic.
DeviceRegistrationState *types.DeviceRegistrationStateResourceTypeEventConfiguration
// Join resource type event configuration object for enabling and disabling
// wireless device topic.
Join *types.JoinResourceTypeEventConfiguration
// Message delivery status resource type event configuration object for enabling
// and disabling wireless device topic.
MessageDeliveryStatus *types.MessageDeliveryStatusResourceTypeEventConfiguration
// Proximity resource type event configuration object for enabling and disabling
// wireless gateway topic.
Proximity *types.ProximityResourceTypeEventConfiguration
noSmithyDocumentSerde
}
type UpdateEventConfigurationByResourceTypesOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateEventConfigurationByResourceTypesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateEventConfigurationByResourceTypes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateEventConfigurationByResourceTypes{}, 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_opUpdateEventConfigurationByResourceTypes(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_opUpdateEventConfigurationByResourceTypes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateEventConfigurationByResourceTypes",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates properties of a FUOTA task.
func (c *Client) UpdateFuotaTask(ctx context.Context, params *UpdateFuotaTaskInput, optFns ...func(*Options)) (*UpdateFuotaTaskOutput, error) {
if params == nil {
params = &UpdateFuotaTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateFuotaTask", params, optFns, c.addOperationUpdateFuotaTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateFuotaTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateFuotaTaskInput struct {
// The ID of a FUOTA task.
//
// This member is required.
Id *string
// The description of the new resource.
Description *string
// The S3 URI points to a firmware update image that is to be used with a FUOTA
// task.
FirmwareUpdateImage *string
// The firmware update role that is to be used with a FUOTA task.
FirmwareUpdateRole *string
// The interval for sending fragments in milliseconds, rounded to the nearest
// second. This interval only determines the timing for when the Cloud sends down
// the fragments to yor device. There can be a delay for when your device will
// receive these fragments. This delay depends on the device's class and the
// communication delay with the cloud.
FragmentIntervalMS *int32
// The size of each fragment in bytes. This parameter is supported only for FUOTA
// tasks with multicast groups.
FragmentSizeBytes *int32
// The LoRaWAN information used with a FUOTA task.
LoRaWAN *types.LoRaWANFuotaTask
// The name of a FUOTA task.
Name *string
// The percentage of the added fragments that are redundant. For example, if the
// size of the firmware image file is 100 bytes and the fragment size is 10 bytes,
// with RedundancyPercent set to 50(%), the final number of encoded fragments is
// (100 / 10) + (100 / 10 * 50%) = 15.
RedundancyPercent *int32
noSmithyDocumentSerde
}
type UpdateFuotaTaskOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateFuotaTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateFuotaTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateFuotaTask{}, 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 = addOpUpdateFuotaTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateFuotaTask(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_opUpdateFuotaTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateFuotaTask",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Set default log level, or log levels by resource types. This can be for
// wireless device log options or wireless gateways log options and is used to
// control the log messages that'll be displayed in CloudWatch.
func (c *Client) UpdateLogLevelsByResourceTypes(ctx context.Context, params *UpdateLogLevelsByResourceTypesInput, optFns ...func(*Options)) (*UpdateLogLevelsByResourceTypesOutput, error) {
if params == nil {
params = &UpdateLogLevelsByResourceTypesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateLogLevelsByResourceTypes", params, optFns, c.addOperationUpdateLogLevelsByResourceTypesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateLogLevelsByResourceTypesOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateLogLevelsByResourceTypesInput struct {
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
DefaultLogLevel types.LogLevel
// The list of wireless device log options.
WirelessDeviceLogOptions []types.WirelessDeviceLogOption
// The list of wireless gateway log options.
WirelessGatewayLogOptions []types.WirelessGatewayLogOption
noSmithyDocumentSerde
}
type UpdateLogLevelsByResourceTypesOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateLogLevelsByResourceTypesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateLogLevelsByResourceTypes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateLogLevelsByResourceTypes{}, 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 = addOpUpdateLogLevelsByResourceTypesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateLogLevelsByResourceTypes(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_opUpdateLogLevelsByResourceTypes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateLogLevelsByResourceTypes",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates properties of a multicast group session.
func (c *Client) UpdateMulticastGroup(ctx context.Context, params *UpdateMulticastGroupInput, optFns ...func(*Options)) (*UpdateMulticastGroupOutput, error) {
if params == nil {
params = &UpdateMulticastGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateMulticastGroup", params, optFns, c.addOperationUpdateMulticastGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateMulticastGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateMulticastGroupInput struct {
// The ID of the multicast group.
//
// This member is required.
Id *string
// The description of the new resource.
Description *string
// The LoRaWAN information that is to be used with the multicast group.
LoRaWAN *types.LoRaWANMulticast
// The name of the multicast group.
Name *string
noSmithyDocumentSerde
}
type UpdateMulticastGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateMulticastGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateMulticastGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateMulticastGroup{}, 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 = addOpUpdateMulticastGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateMulticastGroup(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_opUpdateMulticastGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateMulticastGroup",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Update network analyzer configuration.
func (c *Client) UpdateNetworkAnalyzerConfiguration(ctx context.Context, params *UpdateNetworkAnalyzerConfigurationInput, optFns ...func(*Options)) (*UpdateNetworkAnalyzerConfigurationOutput, error) {
if params == nil {
params = &UpdateNetworkAnalyzerConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateNetworkAnalyzerConfiguration", params, optFns, c.addOperationUpdateNetworkAnalyzerConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateNetworkAnalyzerConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateNetworkAnalyzerConfigurationInput struct {
// Name of the network analyzer configuration.
//
// This member is required.
ConfigurationName *string
// The description of the new resource.
Description *string
// Multicast group resources to add to the network analyzer configuration. Provide
// the MulticastGroupId of the resource to add in the input array.
MulticastGroupsToAdd []string
// Multicast group resources to remove from the network analyzer configuration.
// Provide the MulticastGroupId of the resource to remove in the input array.
MulticastGroupsToRemove []string
// Trace content for your wireless gateway and wireless device resources.
TraceContent *types.TraceContent
// Wireless device resources to add to the network analyzer configuration. Provide
// the WirelessDeviceId of the resource to add in the input array.
WirelessDevicesToAdd []string
// Wireless device resources to remove from the network analyzer configuration.
// Provide the WirelessDeviceId of the resources to remove in the input array.
WirelessDevicesToRemove []string
// Wireless gateway resources to add to the network analyzer configuration.
// Provide the WirelessGatewayId of the resource to add in the input array.
WirelessGatewaysToAdd []string
// Wireless gateway resources to remove from the network analyzer configuration.
// Provide the WirelessGatewayId of the resources to remove in the input array.
WirelessGatewaysToRemove []string
noSmithyDocumentSerde
}
type UpdateNetworkAnalyzerConfigurationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateNetworkAnalyzerConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateNetworkAnalyzerConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateNetworkAnalyzerConfiguration{}, 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 = addOpUpdateNetworkAnalyzerConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateNetworkAnalyzerConfiguration(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_opUpdateNetworkAnalyzerConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateNetworkAnalyzerConfiguration",
}
}
| 151 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates properties of a partner account.
func (c *Client) UpdatePartnerAccount(ctx context.Context, params *UpdatePartnerAccountInput, optFns ...func(*Options)) (*UpdatePartnerAccountOutput, error) {
if params == nil {
params = &UpdatePartnerAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdatePartnerAccount", params, optFns, c.addOperationUpdatePartnerAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdatePartnerAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdatePartnerAccountInput struct {
// The ID of the partner account to update.
//
// This member is required.
PartnerAccountId *string
// The partner type.
//
// This member is required.
PartnerType types.PartnerType
// The Sidewalk account credentials.
//
// This member is required.
Sidewalk *types.SidewalkUpdateAccount
noSmithyDocumentSerde
}
type UpdatePartnerAccountOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdatePartnerAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdatePartnerAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdatePartnerAccount{}, 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 = addOpUpdatePartnerAccountValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdatePartnerAccount(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_opUpdatePartnerAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdatePartnerAccount",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Update the position information of a resource. This action is no longer
// supported. Calls to update the position information should use the
// UpdateResourcePosition (https://docs.aws.amazon.com/iot-wireless/2020-11-22/apireference/API_UpdateResourcePosition.html)
// API operation instead.
//
// Deprecated: This operation is no longer supported.
func (c *Client) UpdatePosition(ctx context.Context, params *UpdatePositionInput, optFns ...func(*Options)) (*UpdatePositionOutput, error) {
if params == nil {
params = &UpdatePositionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdatePosition", params, optFns, c.addOperationUpdatePositionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdatePositionOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdatePositionInput struct {
// The position information of the resource.
//
// This member is required.
Position []float32
// Resource identifier of the resource for which position is updated.
//
// This member is required.
ResourceIdentifier *string
// Resource type of the resource for which position is updated.
//
// This member is required.
ResourceType types.PositionResourceType
noSmithyDocumentSerde
}
type UpdatePositionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdatePositionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdatePosition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdatePosition{}, 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 = addOpUpdatePositionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdatePosition(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_opUpdatePosition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdatePosition",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Update the event configuration for a particular resource identifier.
func (c *Client) UpdateResourceEventConfiguration(ctx context.Context, params *UpdateResourceEventConfigurationInput, optFns ...func(*Options)) (*UpdateResourceEventConfigurationOutput, error) {
if params == nil {
params = &UpdateResourceEventConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateResourceEventConfiguration", params, optFns, c.addOperationUpdateResourceEventConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateResourceEventConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateResourceEventConfigurationInput struct {
// Resource identifier to opt in for event messaging.
//
// This member is required.
Identifier *string
// Identifier type of the particular resource identifier for event configuration.
//
// This member is required.
IdentifierType types.IdentifierType
// Event configuration for the connection status event.
ConnectionStatus *types.ConnectionStatusEventConfiguration
// Event configuration for the device registration state event.
DeviceRegistrationState *types.DeviceRegistrationStateEventConfiguration
// Event configuration for the join event.
Join *types.JoinEventConfiguration
// Event configuration for the message delivery status event.
MessageDeliveryStatus *types.MessageDeliveryStatusEventConfiguration
// Partner type of the resource if the identifier type is PartnerAccountId
PartnerType types.EventNotificationPartnerType
// Event configuration for the proximity event.
Proximity *types.ProximityEventConfiguration
noSmithyDocumentSerde
}
type UpdateResourceEventConfigurationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateResourceEventConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateResourceEventConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateResourceEventConfiguration{}, 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 = addOpUpdateResourceEventConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateResourceEventConfiguration(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_opUpdateResourceEventConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateResourceEventConfiguration",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Update the position information of a given wireless device or a wireless
// gateway resource. The position coordinates are based on the World Geodetic
// System (WGS84) (https://gisgeography.com/wgs84-world-geodetic-system/) .
func (c *Client) UpdateResourcePosition(ctx context.Context, params *UpdateResourcePositionInput, optFns ...func(*Options)) (*UpdateResourcePositionOutput, error) {
if params == nil {
params = &UpdateResourcePositionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateResourcePosition", params, optFns, c.addOperationUpdateResourcePositionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateResourcePositionOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateResourcePositionInput struct {
// The identifier of the resource for which position information is updated. It
// can be the wireless device ID or the wireless gateway ID, depending on the
// resource type.
//
// This member is required.
ResourceIdentifier *string
// The type of resource for which position information is updated, which can be a
// wireless device or a wireless gateway.
//
// This member is required.
ResourceType types.PositionResourceType
// The position information of the resource, displayed as a JSON payload. The
// payload uses the GeoJSON format, which a format that's used to encode geographic
// data structures. For more information, see GeoJSON (https://geojson.org/) .
GeoJsonPayload []byte
noSmithyDocumentSerde
}
type UpdateResourcePositionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateResourcePositionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateResourcePosition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateResourcePosition{}, 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 = addOpUpdateResourcePositionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateResourcePosition(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_opUpdateResourcePosition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateResourcePosition",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates properties of a wireless device.
func (c *Client) UpdateWirelessDevice(ctx context.Context, params *UpdateWirelessDeviceInput, optFns ...func(*Options)) (*UpdateWirelessDeviceOutput, error) {
if params == nil {
params = &UpdateWirelessDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateWirelessDevice", params, optFns, c.addOperationUpdateWirelessDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateWirelessDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateWirelessDeviceInput struct {
// The ID of the resource to update.
//
// This member is required.
Id *string
// A new description of the resource.
Description *string
// The name of the new destination for the device.
DestinationName *string
// The updated wireless device's configuration.
LoRaWAN *types.LoRaWANUpdateDevice
// The new name of the resource.
Name *string
// FPort values for the GNSS, stream, and ClockSync functions of the positioning
// information.
Positioning types.PositioningConfigStatus
noSmithyDocumentSerde
}
type UpdateWirelessDeviceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateWirelessDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateWirelessDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateWirelessDevice{}, 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 = addOpUpdateWirelessDeviceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateWirelessDevice(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_opUpdateWirelessDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateWirelessDevice",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Update an import task to add more devices to the task.
func (c *Client) UpdateWirelessDeviceImportTask(ctx context.Context, params *UpdateWirelessDeviceImportTaskInput, optFns ...func(*Options)) (*UpdateWirelessDeviceImportTaskOutput, error) {
if params == nil {
params = &UpdateWirelessDeviceImportTaskInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateWirelessDeviceImportTask", params, optFns, c.addOperationUpdateWirelessDeviceImportTaskMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateWirelessDeviceImportTaskOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateWirelessDeviceImportTaskInput struct {
// The identifier of the import task to be updated.
//
// This member is required.
Id *string
// The Sidewalk-related parameters of the import task to be updated.
//
// This member is required.
Sidewalk *types.SidewalkUpdateImportInfo
noSmithyDocumentSerde
}
type UpdateWirelessDeviceImportTaskOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateWirelessDeviceImportTaskMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateWirelessDeviceImportTask{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateWirelessDeviceImportTask{}, 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 = addOpUpdateWirelessDeviceImportTaskValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateWirelessDeviceImportTask(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_opUpdateWirelessDeviceImportTask(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateWirelessDeviceImportTask",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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 properties of a wireless gateway.
func (c *Client) UpdateWirelessGateway(ctx context.Context, params *UpdateWirelessGatewayInput, optFns ...func(*Options)) (*UpdateWirelessGatewayOutput, error) {
if params == nil {
params = &UpdateWirelessGatewayInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateWirelessGateway", params, optFns, c.addOperationUpdateWirelessGatewayMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateWirelessGatewayOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateWirelessGatewayInput struct {
// The ID of the resource to update.
//
// This member is required.
Id *string
// A new description of the resource.
Description *string
// A list of JoinEuiRange used by LoRa gateways to filter LoRa frames.
JoinEuiFilters [][]string
// The MaxEIRP value.
MaxEirp *float32
// The new name of the resource.
Name *string
// A list of NetId values that are used by LoRa gateways to filter the uplink
// frames.
NetIdFilters []string
noSmithyDocumentSerde
}
type UpdateWirelessGatewayOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateWirelessGatewayMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateWirelessGateway{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateWirelessGateway{}, 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 = addOpUpdateWirelessGatewayValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateWirelessGateway(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_opUpdateWirelessGateway(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotwireless",
OperationName: "UpdateWirelessGateway",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package iotwireless provides the API client, operations, and parameter types
// for AWS IoT Wireless.
//
// AWS IoT Wireless provides bi-directional communication between
// internet-connected wireless devices and the AWS Cloud. To onboard both LoRaWAN
// and Sidewalk devices to AWS IoT, use the IoT Wireless API. These wireless
// devices use the Low Power Wide Area Networking (LPWAN) communication protocol to
// communicate with AWS IoT. Using the API, you can perform create, read, update,
// and delete operations for your wireless devices, gateways, destinations, and
// profiles. After onboarding your devices, you can use the API operations to set
// log levels and monitor your devices with CloudWatch. You can also use the API
// operations to create multicast groups and schedule a multicast session for
// sending a downlink message to devices in the group. By using Firmware Updates
// Over-The-Air (FUOTA) API operations, you can create a FUOTA task and schedule a
// session to update the firmware of individual devices or an entire group of
// devices in a multicast group.
package iotwireless
| 20 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
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/iotwireless/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 = "iotwireless"
}
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 iotwireless
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.28.2"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/iotwireless/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"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"math"
)
type awsRestjson1_serializeOpAssociateAwsAccountWithPartnerAccount struct {
}
func (*awsRestjson1_serializeOpAssociateAwsAccountWithPartnerAccount) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateAwsAccountWithPartnerAccount) 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.(*AssociateAwsAccountWithPartnerAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/partner-accounts")
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_serializeOpDocumentAssociateAwsAccountWithPartnerAccountInput(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_serializeOpHttpBindingsAssociateAwsAccountWithPartnerAccountInput(v *AssociateAwsAccountWithPartnerAccountInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateAwsAccountWithPartnerAccountInput(v *AssociateAwsAccountWithPartnerAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkAccountInfo(v.Sidewalk, 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_serializeOpAssociateMulticastGroupWithFuotaTask struct {
}
func (*awsRestjson1_serializeOpAssociateMulticastGroupWithFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateMulticastGroupWithFuotaTask) 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.(*AssociateMulticastGroupWithFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}/multicast-group")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsAssociateMulticastGroupWithFuotaTaskInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateMulticastGroupWithFuotaTaskInput(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_serializeOpHttpBindingsAssociateMulticastGroupWithFuotaTaskInput(v *AssociateMulticastGroupWithFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateMulticastGroupWithFuotaTaskInput(v *AssociateMulticastGroupWithFuotaTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MulticastGroupId != nil {
ok := object.Key("MulticastGroupId")
ok.String(*v.MulticastGroupId)
}
return nil
}
type awsRestjson1_serializeOpAssociateWirelessDeviceWithFuotaTask struct {
}
func (*awsRestjson1_serializeOpAssociateWirelessDeviceWithFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateWirelessDeviceWithFuotaTask) 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.(*AssociateWirelessDeviceWithFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}/wireless-device")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsAssociateWirelessDeviceWithFuotaTaskInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateWirelessDeviceWithFuotaTaskInput(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_serializeOpHttpBindingsAssociateWirelessDeviceWithFuotaTaskInput(v *AssociateWirelessDeviceWithFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateWirelessDeviceWithFuotaTaskInput(v *AssociateWirelessDeviceWithFuotaTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.WirelessDeviceId != nil {
ok := object.Key("WirelessDeviceId")
ok.String(*v.WirelessDeviceId)
}
return nil
}
type awsRestjson1_serializeOpAssociateWirelessDeviceWithMulticastGroup struct {
}
func (*awsRestjson1_serializeOpAssociateWirelessDeviceWithMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateWirelessDeviceWithMulticastGroup) 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.(*AssociateWirelessDeviceWithMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/wireless-device")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsAssociateWirelessDeviceWithMulticastGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateWirelessDeviceWithMulticastGroupInput(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_serializeOpHttpBindingsAssociateWirelessDeviceWithMulticastGroupInput(v *AssociateWirelessDeviceWithMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateWirelessDeviceWithMulticastGroupInput(v *AssociateWirelessDeviceWithMulticastGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.WirelessDeviceId != nil {
ok := object.Key("WirelessDeviceId")
ok.String(*v.WirelessDeviceId)
}
return nil
}
type awsRestjson1_serializeOpAssociateWirelessDeviceWithThing struct {
}
func (*awsRestjson1_serializeOpAssociateWirelessDeviceWithThing) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateWirelessDeviceWithThing) 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.(*AssociateWirelessDeviceWithThingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}/thing")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsAssociateWirelessDeviceWithThingInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateWirelessDeviceWithThingInput(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_serializeOpHttpBindingsAssociateWirelessDeviceWithThingInput(v *AssociateWirelessDeviceWithThingInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateWirelessDeviceWithThingInput(v *AssociateWirelessDeviceWithThingInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ThingArn != nil {
ok := object.Key("ThingArn")
ok.String(*v.ThingArn)
}
return nil
}
type awsRestjson1_serializeOpAssociateWirelessGatewayWithCertificate struct {
}
func (*awsRestjson1_serializeOpAssociateWirelessGatewayWithCertificate) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateWirelessGatewayWithCertificate) 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.(*AssociateWirelessGatewayWithCertificateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/certificate")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsAssociateWirelessGatewayWithCertificateInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateWirelessGatewayWithCertificateInput(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_serializeOpHttpBindingsAssociateWirelessGatewayWithCertificateInput(v *AssociateWirelessGatewayWithCertificateInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateWirelessGatewayWithCertificateInput(v *AssociateWirelessGatewayWithCertificateInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IotCertificateId != nil {
ok := object.Key("IotCertificateId")
ok.String(*v.IotCertificateId)
}
return nil
}
type awsRestjson1_serializeOpAssociateWirelessGatewayWithThing struct {
}
func (*awsRestjson1_serializeOpAssociateWirelessGatewayWithThing) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateWirelessGatewayWithThing) 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.(*AssociateWirelessGatewayWithThingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/thing")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsAssociateWirelessGatewayWithThingInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateWirelessGatewayWithThingInput(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_serializeOpHttpBindingsAssociateWirelessGatewayWithThingInput(v *AssociateWirelessGatewayWithThingInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateWirelessGatewayWithThingInput(v *AssociateWirelessGatewayWithThingInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ThingArn != nil {
ok := object.Key("ThingArn")
ok.String(*v.ThingArn)
}
return nil
}
type awsRestjson1_serializeOpCancelMulticastGroupSession struct {
}
func (*awsRestjson1_serializeOpCancelMulticastGroupSession) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCancelMulticastGroupSession) 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.(*CancelMulticastGroupSessionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/session")
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_serializeOpHttpBindingsCancelMulticastGroupSessionInput(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_serializeOpHttpBindingsCancelMulticastGroupSessionInput(v *CancelMulticastGroupSessionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateDestination struct {
}
func (*awsRestjson1_serializeOpCreateDestination) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateDestination) 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.(*CreateDestinationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/destinations")
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_serializeOpDocumentCreateDestinationInput(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_serializeOpHttpBindingsCreateDestinationInput(v *CreateDestinationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateDestinationInput(v *CreateDestinationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Expression != nil {
ok := object.Key("Expression")
ok.String(*v.Expression)
}
if len(v.ExpressionType) > 0 {
ok := object.Key("ExpressionType")
ok.String(string(v.ExpressionType))
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateDeviceProfile struct {
}
func (*awsRestjson1_serializeOpCreateDeviceProfile) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateDeviceProfile) 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.(*CreateDeviceProfileInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/device-profiles")
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_serializeOpDocumentCreateDeviceProfileInput(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_serializeOpHttpBindingsCreateDeviceProfileInput(v *CreateDeviceProfileInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateDeviceProfileInput(v *CreateDeviceProfileInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANDeviceProfile(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkCreateDeviceProfile(v.Sidewalk, 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_serializeOpCreateFuotaTask struct {
}
func (*awsRestjson1_serializeOpCreateFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateFuotaTask) 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.(*CreateFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks")
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_serializeOpDocumentCreateFuotaTaskInput(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_serializeOpHttpBindingsCreateFuotaTaskInput(v *CreateFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateFuotaTaskInput(v *CreateFuotaTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.FirmwareUpdateImage != nil {
ok := object.Key("FirmwareUpdateImage")
ok.String(*v.FirmwareUpdateImage)
}
if v.FirmwareUpdateRole != nil {
ok := object.Key("FirmwareUpdateRole")
ok.String(*v.FirmwareUpdateRole)
}
if v.FragmentIntervalMS != nil {
ok := object.Key("FragmentIntervalMS")
ok.Integer(*v.FragmentIntervalMS)
}
if v.FragmentSizeBytes != nil {
ok := object.Key("FragmentSizeBytes")
ok.Integer(*v.FragmentSizeBytes)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANFuotaTask(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.RedundancyPercent != nil {
ok := object.Key("RedundancyPercent")
ok.Integer(*v.RedundancyPercent)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateMulticastGroup struct {
}
func (*awsRestjson1_serializeOpCreateMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateMulticastGroup) 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.(*CreateMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups")
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_serializeOpDocumentCreateMulticastGroupInput(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_serializeOpHttpBindingsCreateMulticastGroupInput(v *CreateMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateMulticastGroupInput(v *CreateMulticastGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANMulticast(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateNetworkAnalyzerConfiguration struct {
}
func (*awsRestjson1_serializeOpCreateNetworkAnalyzerConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateNetworkAnalyzerConfiguration) 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.(*CreateNetworkAnalyzerConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/network-analyzer-configurations")
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_serializeOpDocumentCreateNetworkAnalyzerConfigurationInput(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_serializeOpHttpBindingsCreateNetworkAnalyzerConfigurationInput(v *CreateNetworkAnalyzerConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateNetworkAnalyzerConfigurationInput(v *CreateNetworkAnalyzerConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.MulticastGroups != nil {
ok := object.Key("MulticastGroups")
if err := awsRestjson1_serializeDocumentNetworkAnalyzerMulticastGroupList(v.MulticastGroups, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.TraceContent != nil {
ok := object.Key("TraceContent")
if err := awsRestjson1_serializeDocumentTraceContent(v.TraceContent, ok); err != nil {
return err
}
}
if v.WirelessDevices != nil {
ok := object.Key("WirelessDevices")
if err := awsRestjson1_serializeDocumentWirelessDeviceList(v.WirelessDevices, ok); err != nil {
return err
}
}
if v.WirelessGateways != nil {
ok := object.Key("WirelessGateways")
if err := awsRestjson1_serializeDocumentWirelessGatewayList(v.WirelessGateways, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateServiceProfile struct {
}
func (*awsRestjson1_serializeOpCreateServiceProfile) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateServiceProfile) 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.(*CreateServiceProfileInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/service-profiles")
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_serializeOpDocumentCreateServiceProfileInput(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_serializeOpHttpBindingsCreateServiceProfileInput(v *CreateServiceProfileInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateServiceProfileInput(v *CreateServiceProfileInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANServiceProfile(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateWirelessDevice struct {
}
func (*awsRestjson1_serializeOpCreateWirelessDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateWirelessDevice) 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.(*CreateWirelessDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-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}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateWirelessDeviceInput(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_serializeOpHttpBindingsCreateWirelessDeviceInput(v *CreateWirelessDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateWirelessDeviceInput(v *CreateWirelessDeviceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.DestinationName != nil {
ok := object.Key("DestinationName")
ok.String(*v.DestinationName)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANDevice(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.Positioning) > 0 {
ok := object.Key("Positioning")
ok.String(string(v.Positioning))
}
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkCreateWirelessDevice(v.Sidewalk, 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 len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
type awsRestjson1_serializeOpCreateWirelessGateway struct {
}
func (*awsRestjson1_serializeOpCreateWirelessGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateWirelessGateway) 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.(*CreateWirelessGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways")
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_serializeOpDocumentCreateWirelessGatewayInput(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_serializeOpHttpBindingsCreateWirelessGatewayInput(v *CreateWirelessGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateWirelessGatewayInput(v *CreateWirelessGatewayInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANGateway(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateWirelessGatewayTask struct {
}
func (*awsRestjson1_serializeOpCreateWirelessGatewayTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateWirelessGatewayTask) 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.(*CreateWirelessGatewayTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/tasks")
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_serializeOpHttpBindingsCreateWirelessGatewayTaskInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateWirelessGatewayTaskInput(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_serializeOpHttpBindingsCreateWirelessGatewayTaskInput(v *CreateWirelessGatewayTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateWirelessGatewayTaskInput(v *CreateWirelessGatewayTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.WirelessGatewayTaskDefinitionId != nil {
ok := object.Key("WirelessGatewayTaskDefinitionId")
ok.String(*v.WirelessGatewayTaskDefinitionId)
}
return nil
}
type awsRestjson1_serializeOpCreateWirelessGatewayTaskDefinition struct {
}
func (*awsRestjson1_serializeOpCreateWirelessGatewayTaskDefinition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateWirelessGatewayTaskDefinition) 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.(*CreateWirelessGatewayTaskDefinitionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateway-task-definitions")
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_serializeOpDocumentCreateWirelessGatewayTaskDefinitionInput(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_serializeOpHttpBindingsCreateWirelessGatewayTaskDefinitionInput(v *CreateWirelessGatewayTaskDefinitionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateWirelessGatewayTaskDefinitionInput(v *CreateWirelessGatewayTaskDefinitionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
{
ok := object.Key("AutoCreateTasks")
ok.Boolean(v.AutoCreateTasks)
}
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.Update != nil {
ok := object.Key("Update")
if err := awsRestjson1_serializeDocumentUpdateWirelessGatewayTaskCreate(v.Update, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteDestination struct {
}
func (*awsRestjson1_serializeOpDeleteDestination) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteDestination) 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.(*DeleteDestinationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/destinations/{Name}")
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_serializeOpHttpBindingsDeleteDestinationInput(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_serializeOpHttpBindingsDeleteDestinationInput(v *DeleteDestinationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteDeviceProfile struct {
}
func (*awsRestjson1_serializeOpDeleteDeviceProfile) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteDeviceProfile) 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.(*DeleteDeviceProfileInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/device-profiles/{Id}")
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_serializeOpHttpBindingsDeleteDeviceProfileInput(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_serializeOpHttpBindingsDeleteDeviceProfileInput(v *DeleteDeviceProfileInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteFuotaTask struct {
}
func (*awsRestjson1_serializeOpDeleteFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteFuotaTask) 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.(*DeleteFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}")
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_serializeOpHttpBindingsDeleteFuotaTaskInput(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_serializeOpHttpBindingsDeleteFuotaTaskInput(v *DeleteFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteMulticastGroup struct {
}
func (*awsRestjson1_serializeOpDeleteMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteMulticastGroup) 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.(*DeleteMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}")
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_serializeOpHttpBindingsDeleteMulticastGroupInput(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_serializeOpHttpBindingsDeleteMulticastGroupInput(v *DeleteMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteNetworkAnalyzerConfiguration struct {
}
func (*awsRestjson1_serializeOpDeleteNetworkAnalyzerConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteNetworkAnalyzerConfiguration) 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.(*DeleteNetworkAnalyzerConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/network-analyzer-configurations/{ConfigurationName}")
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_serializeOpHttpBindingsDeleteNetworkAnalyzerConfigurationInput(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_serializeOpHttpBindingsDeleteNetworkAnalyzerConfigurationInput(v *DeleteNetworkAnalyzerConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConfigurationName == nil || len(*v.ConfigurationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationName must not be empty")}
}
if v.ConfigurationName != nil {
if err := encoder.SetURI("ConfigurationName").String(*v.ConfigurationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteQueuedMessages struct {
}
func (*awsRestjson1_serializeOpDeleteQueuedMessages) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteQueuedMessages) 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.(*DeleteQueuedMessagesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}/data")
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_serializeOpHttpBindingsDeleteQueuedMessagesInput(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_serializeOpHttpBindingsDeleteQueuedMessagesInput(v *DeleteQueuedMessagesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
if v.MessageId != nil {
encoder.SetQuery("messageId").String(*v.MessageId)
}
if len(v.WirelessDeviceType) > 0 {
encoder.SetQuery("WirelessDeviceType").String(string(v.WirelessDeviceType))
}
return nil
}
type awsRestjson1_serializeOpDeleteServiceProfile struct {
}
func (*awsRestjson1_serializeOpDeleteServiceProfile) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteServiceProfile) 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.(*DeleteServiceProfileInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/service-profiles/{Id}")
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_serializeOpHttpBindingsDeleteServiceProfileInput(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_serializeOpHttpBindingsDeleteServiceProfileInput(v *DeleteServiceProfileInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteWirelessDevice struct {
}
func (*awsRestjson1_serializeOpDeleteWirelessDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteWirelessDevice) 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.(*DeleteWirelessDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}")
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_serializeOpHttpBindingsDeleteWirelessDeviceInput(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_serializeOpHttpBindingsDeleteWirelessDeviceInput(v *DeleteWirelessDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteWirelessDeviceImportTask struct {
}
func (*awsRestjson1_serializeOpDeleteWirelessDeviceImportTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteWirelessDeviceImportTask) 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.(*DeleteWirelessDeviceImportTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless_device_import_task/{Id}")
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_serializeOpHttpBindingsDeleteWirelessDeviceImportTaskInput(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_serializeOpHttpBindingsDeleteWirelessDeviceImportTaskInput(v *DeleteWirelessDeviceImportTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteWirelessGateway struct {
}
func (*awsRestjson1_serializeOpDeleteWirelessGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteWirelessGateway) 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.(*DeleteWirelessGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}")
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_serializeOpHttpBindingsDeleteWirelessGatewayInput(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_serializeOpHttpBindingsDeleteWirelessGatewayInput(v *DeleteWirelessGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteWirelessGatewayTask struct {
}
func (*awsRestjson1_serializeOpDeleteWirelessGatewayTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteWirelessGatewayTask) 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.(*DeleteWirelessGatewayTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/tasks")
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_serializeOpHttpBindingsDeleteWirelessGatewayTaskInput(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_serializeOpHttpBindingsDeleteWirelessGatewayTaskInput(v *DeleteWirelessGatewayTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteWirelessGatewayTaskDefinition struct {
}
func (*awsRestjson1_serializeOpDeleteWirelessGatewayTaskDefinition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteWirelessGatewayTaskDefinition) 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.(*DeleteWirelessGatewayTaskDefinitionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateway-task-definitions/{Id}")
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_serializeOpHttpBindingsDeleteWirelessGatewayTaskDefinitionInput(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_serializeOpHttpBindingsDeleteWirelessGatewayTaskDefinitionInput(v *DeleteWirelessGatewayTaskDefinitionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeregisterWirelessDevice struct {
}
func (*awsRestjson1_serializeOpDeregisterWirelessDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeregisterWirelessDevice) 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.(*DeregisterWirelessDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Identifier}/deregister")
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_serializeOpHttpBindingsDeregisterWirelessDeviceInput(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_serializeOpHttpBindingsDeregisterWirelessDeviceInput(v *DeregisterWirelessDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Identifier == nil || len(*v.Identifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Identifier must not be empty")}
}
if v.Identifier != nil {
if err := encoder.SetURI("Identifier").String(*v.Identifier); err != nil {
return err
}
}
if len(v.WirelessDeviceType) > 0 {
encoder.SetQuery("WirelessDeviceType").String(string(v.WirelessDeviceType))
}
return nil
}
type awsRestjson1_serializeOpDisassociateAwsAccountFromPartnerAccount struct {
}
func (*awsRestjson1_serializeOpDisassociateAwsAccountFromPartnerAccount) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateAwsAccountFromPartnerAccount) 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.(*DisassociateAwsAccountFromPartnerAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/partner-accounts/{PartnerAccountId}")
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_serializeOpHttpBindingsDisassociateAwsAccountFromPartnerAccountInput(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_serializeOpHttpBindingsDisassociateAwsAccountFromPartnerAccountInput(v *DisassociateAwsAccountFromPartnerAccountInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.PartnerAccountId == nil || len(*v.PartnerAccountId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PartnerAccountId must not be empty")}
}
if v.PartnerAccountId != nil {
if err := encoder.SetURI("PartnerAccountId").String(*v.PartnerAccountId); err != nil {
return err
}
}
if len(v.PartnerType) > 0 {
encoder.SetQuery("partnerType").String(string(v.PartnerType))
}
return nil
}
type awsRestjson1_serializeOpDisassociateMulticastGroupFromFuotaTask struct {
}
func (*awsRestjson1_serializeOpDisassociateMulticastGroupFromFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateMulticastGroupFromFuotaTask) 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.(*DisassociateMulticastGroupFromFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}/multicast-groups/{MulticastGroupId}")
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_serializeOpHttpBindingsDisassociateMulticastGroupFromFuotaTaskInput(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_serializeOpHttpBindingsDisassociateMulticastGroupFromFuotaTaskInput(v *DisassociateMulticastGroupFromFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
if v.MulticastGroupId == nil || len(*v.MulticastGroupId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member MulticastGroupId must not be empty")}
}
if v.MulticastGroupId != nil {
if err := encoder.SetURI("MulticastGroupId").String(*v.MulticastGroupId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisassociateWirelessDeviceFromFuotaTask struct {
}
func (*awsRestjson1_serializeOpDisassociateWirelessDeviceFromFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateWirelessDeviceFromFuotaTask) 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.(*DisassociateWirelessDeviceFromFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}/wireless-devices/{WirelessDeviceId}")
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_serializeOpHttpBindingsDisassociateWirelessDeviceFromFuotaTaskInput(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_serializeOpHttpBindingsDisassociateWirelessDeviceFromFuotaTaskInput(v *DisassociateWirelessDeviceFromFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
if v.WirelessDeviceId == nil || len(*v.WirelessDeviceId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member WirelessDeviceId must not be empty")}
}
if v.WirelessDeviceId != nil {
if err := encoder.SetURI("WirelessDeviceId").String(*v.WirelessDeviceId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisassociateWirelessDeviceFromMulticastGroup struct {
}
func (*awsRestjson1_serializeOpDisassociateWirelessDeviceFromMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateWirelessDeviceFromMulticastGroup) 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.(*DisassociateWirelessDeviceFromMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/wireless-devices/{WirelessDeviceId}")
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_serializeOpHttpBindingsDisassociateWirelessDeviceFromMulticastGroupInput(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_serializeOpHttpBindingsDisassociateWirelessDeviceFromMulticastGroupInput(v *DisassociateWirelessDeviceFromMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
if v.WirelessDeviceId == nil || len(*v.WirelessDeviceId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member WirelessDeviceId must not be empty")}
}
if v.WirelessDeviceId != nil {
if err := encoder.SetURI("WirelessDeviceId").String(*v.WirelessDeviceId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisassociateWirelessDeviceFromThing struct {
}
func (*awsRestjson1_serializeOpDisassociateWirelessDeviceFromThing) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateWirelessDeviceFromThing) 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.(*DisassociateWirelessDeviceFromThingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}/thing")
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_serializeOpHttpBindingsDisassociateWirelessDeviceFromThingInput(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_serializeOpHttpBindingsDisassociateWirelessDeviceFromThingInput(v *DisassociateWirelessDeviceFromThingInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisassociateWirelessGatewayFromCertificate struct {
}
func (*awsRestjson1_serializeOpDisassociateWirelessGatewayFromCertificate) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateWirelessGatewayFromCertificate) 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.(*DisassociateWirelessGatewayFromCertificateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/certificate")
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_serializeOpHttpBindingsDisassociateWirelessGatewayFromCertificateInput(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_serializeOpHttpBindingsDisassociateWirelessGatewayFromCertificateInput(v *DisassociateWirelessGatewayFromCertificateInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisassociateWirelessGatewayFromThing struct {
}
func (*awsRestjson1_serializeOpDisassociateWirelessGatewayFromThing) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateWirelessGatewayFromThing) 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.(*DisassociateWirelessGatewayFromThingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/thing")
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_serializeOpHttpBindingsDisassociateWirelessGatewayFromThingInput(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_serializeOpHttpBindingsDisassociateWirelessGatewayFromThingInput(v *DisassociateWirelessGatewayFromThingInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetDestination struct {
}
func (*awsRestjson1_serializeOpGetDestination) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDestination) 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.(*GetDestinationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/destinations/{Name}")
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_serializeOpHttpBindingsGetDestinationInput(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_serializeOpHttpBindingsGetDestinationInput(v *GetDestinationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetDeviceProfile struct {
}
func (*awsRestjson1_serializeOpGetDeviceProfile) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDeviceProfile) 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.(*GetDeviceProfileInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/device-profiles/{Id}")
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_serializeOpHttpBindingsGetDeviceProfileInput(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_serializeOpHttpBindingsGetDeviceProfileInput(v *GetDeviceProfileInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetEventConfigurationByResourceTypes struct {
}
func (*awsRestjson1_serializeOpGetEventConfigurationByResourceTypes) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetEventConfigurationByResourceTypes) 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.(*GetEventConfigurationByResourceTypesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/event-configurations-resource-types")
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 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_serializeOpHttpBindingsGetEventConfigurationByResourceTypesInput(v *GetEventConfigurationByResourceTypesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpGetFuotaTask struct {
}
func (*awsRestjson1_serializeOpGetFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetFuotaTask) 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.(*GetFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}")
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_serializeOpHttpBindingsGetFuotaTaskInput(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_serializeOpHttpBindingsGetFuotaTaskInput(v *GetFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetLogLevelsByResourceTypes struct {
}
func (*awsRestjson1_serializeOpGetLogLevelsByResourceTypes) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetLogLevelsByResourceTypes) 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.(*GetLogLevelsByResourceTypesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/log-levels")
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 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_serializeOpHttpBindingsGetLogLevelsByResourceTypesInput(v *GetLogLevelsByResourceTypesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpGetMulticastGroup struct {
}
func (*awsRestjson1_serializeOpGetMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetMulticastGroup) 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.(*GetMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}")
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_serializeOpHttpBindingsGetMulticastGroupInput(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_serializeOpHttpBindingsGetMulticastGroupInput(v *GetMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetMulticastGroupSession struct {
}
func (*awsRestjson1_serializeOpGetMulticastGroupSession) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetMulticastGroupSession) 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.(*GetMulticastGroupSessionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/session")
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_serializeOpHttpBindingsGetMulticastGroupSessionInput(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_serializeOpHttpBindingsGetMulticastGroupSessionInput(v *GetMulticastGroupSessionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetNetworkAnalyzerConfiguration struct {
}
func (*awsRestjson1_serializeOpGetNetworkAnalyzerConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetNetworkAnalyzerConfiguration) 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.(*GetNetworkAnalyzerConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/network-analyzer-configurations/{ConfigurationName}")
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_serializeOpHttpBindingsGetNetworkAnalyzerConfigurationInput(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_serializeOpHttpBindingsGetNetworkAnalyzerConfigurationInput(v *GetNetworkAnalyzerConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConfigurationName == nil || len(*v.ConfigurationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationName must not be empty")}
}
if v.ConfigurationName != nil {
if err := encoder.SetURI("ConfigurationName").String(*v.ConfigurationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetPartnerAccount struct {
}
func (*awsRestjson1_serializeOpGetPartnerAccount) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetPartnerAccount) 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.(*GetPartnerAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/partner-accounts/{PartnerAccountId}")
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_serializeOpHttpBindingsGetPartnerAccountInput(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_serializeOpHttpBindingsGetPartnerAccountInput(v *GetPartnerAccountInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.PartnerAccountId == nil || len(*v.PartnerAccountId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PartnerAccountId must not be empty")}
}
if v.PartnerAccountId != nil {
if err := encoder.SetURI("PartnerAccountId").String(*v.PartnerAccountId); err != nil {
return err
}
}
if len(v.PartnerType) > 0 {
encoder.SetQuery("partnerType").String(string(v.PartnerType))
}
return nil
}
type awsRestjson1_serializeOpGetPosition struct {
}
func (*awsRestjson1_serializeOpGetPosition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetPosition) 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.(*GetPositionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/positions/{ResourceIdentifier}")
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_serializeOpHttpBindingsGetPositionInput(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_serializeOpHttpBindingsGetPositionInput(v *GetPositionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
type awsRestjson1_serializeOpGetPositionConfiguration struct {
}
func (*awsRestjson1_serializeOpGetPositionConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetPositionConfiguration) 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.(*GetPositionConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/position-configurations/{ResourceIdentifier}")
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_serializeOpHttpBindingsGetPositionConfigurationInput(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_serializeOpHttpBindingsGetPositionConfigurationInput(v *GetPositionConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
type awsRestjson1_serializeOpGetPositionEstimate struct {
}
func (*awsRestjson1_serializeOpGetPositionEstimate) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetPositionEstimate) 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.(*GetPositionEstimateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/position-estimate")
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_serializeOpDocumentGetPositionEstimateInput(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_serializeOpHttpBindingsGetPositionEstimateInput(v *GetPositionEstimateInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetPositionEstimateInput(v *GetPositionEstimateInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CellTowers != nil {
ok := object.Key("CellTowers")
if err := awsRestjson1_serializeDocumentCellTowers(v.CellTowers, ok); err != nil {
return err
}
}
if v.Gnss != nil {
ok := object.Key("Gnss")
if err := awsRestjson1_serializeDocumentGnss(v.Gnss, ok); err != nil {
return err
}
}
if v.Ip != nil {
ok := object.Key("Ip")
if err := awsRestjson1_serializeDocumentIp(v.Ip, ok); err != nil {
return err
}
}
if v.Timestamp != nil {
ok := object.Key("Timestamp")
ok.Double(smithytime.FormatEpochSeconds(*v.Timestamp))
}
if v.WiFiAccessPoints != nil {
ok := object.Key("WiFiAccessPoints")
if err := awsRestjson1_serializeDocumentWiFiAccessPoints(v.WiFiAccessPoints, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetResourceEventConfiguration struct {
}
func (*awsRestjson1_serializeOpGetResourceEventConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetResourceEventConfiguration) 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.(*GetResourceEventConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/event-configurations/{Identifier}")
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_serializeOpHttpBindingsGetResourceEventConfigurationInput(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_serializeOpHttpBindingsGetResourceEventConfigurationInput(v *GetResourceEventConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Identifier == nil || len(*v.Identifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Identifier must not be empty")}
}
if v.Identifier != nil {
if err := encoder.SetURI("Identifier").String(*v.Identifier); err != nil {
return err
}
}
if len(v.IdentifierType) > 0 {
encoder.SetQuery("identifierType").String(string(v.IdentifierType))
}
if len(v.PartnerType) > 0 {
encoder.SetQuery("partnerType").String(string(v.PartnerType))
}
return nil
}
type awsRestjson1_serializeOpGetResourceLogLevel struct {
}
func (*awsRestjson1_serializeOpGetResourceLogLevel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetResourceLogLevel) 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.(*GetResourceLogLevelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/log-levels/{ResourceIdentifier}")
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_serializeOpHttpBindingsGetResourceLogLevelInput(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_serializeOpHttpBindingsGetResourceLogLevelInput(v *GetResourceLogLevelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if v.ResourceType != nil {
encoder.SetQuery("resourceType").String(*v.ResourceType)
}
return nil
}
type awsRestjson1_serializeOpGetResourcePosition struct {
}
func (*awsRestjson1_serializeOpGetResourcePosition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetResourcePosition) 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.(*GetResourcePositionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/resource-positions/{ResourceIdentifier}")
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_serializeOpHttpBindingsGetResourcePositionInput(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_serializeOpHttpBindingsGetResourcePositionInput(v *GetResourcePositionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
type awsRestjson1_serializeOpGetServiceEndpoint struct {
}
func (*awsRestjson1_serializeOpGetServiceEndpoint) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetServiceEndpoint) 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.(*GetServiceEndpointInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/service-endpoint")
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_serializeOpHttpBindingsGetServiceEndpointInput(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_serializeOpHttpBindingsGetServiceEndpointInput(v *GetServiceEndpointInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.ServiceType) > 0 {
encoder.SetQuery("serviceType").String(string(v.ServiceType))
}
return nil
}
type awsRestjson1_serializeOpGetServiceProfile struct {
}
func (*awsRestjson1_serializeOpGetServiceProfile) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetServiceProfile) 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.(*GetServiceProfileInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/service-profiles/{Id}")
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_serializeOpHttpBindingsGetServiceProfileInput(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_serializeOpHttpBindingsGetServiceProfileInput(v *GetServiceProfileInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWirelessDevice struct {
}
func (*awsRestjson1_serializeOpGetWirelessDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessDevice) 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.(*GetWirelessDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Identifier}")
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_serializeOpHttpBindingsGetWirelessDeviceInput(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_serializeOpHttpBindingsGetWirelessDeviceInput(v *GetWirelessDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Identifier == nil || len(*v.Identifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Identifier must not be empty")}
}
if v.Identifier != nil {
if err := encoder.SetURI("Identifier").String(*v.Identifier); err != nil {
return err
}
}
if len(v.IdentifierType) > 0 {
encoder.SetQuery("identifierType").String(string(v.IdentifierType))
}
return nil
}
type awsRestjson1_serializeOpGetWirelessDeviceImportTask struct {
}
func (*awsRestjson1_serializeOpGetWirelessDeviceImportTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessDeviceImportTask) 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.(*GetWirelessDeviceImportTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless_device_import_task/{Id}")
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_serializeOpHttpBindingsGetWirelessDeviceImportTaskInput(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_serializeOpHttpBindingsGetWirelessDeviceImportTaskInput(v *GetWirelessDeviceImportTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWirelessDeviceStatistics struct {
}
func (*awsRestjson1_serializeOpGetWirelessDeviceStatistics) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessDeviceStatistics) 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.(*GetWirelessDeviceStatisticsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{WirelessDeviceId}/statistics")
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_serializeOpHttpBindingsGetWirelessDeviceStatisticsInput(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_serializeOpHttpBindingsGetWirelessDeviceStatisticsInput(v *GetWirelessDeviceStatisticsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.WirelessDeviceId == nil || len(*v.WirelessDeviceId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member WirelessDeviceId must not be empty")}
}
if v.WirelessDeviceId != nil {
if err := encoder.SetURI("WirelessDeviceId").String(*v.WirelessDeviceId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWirelessGateway struct {
}
func (*awsRestjson1_serializeOpGetWirelessGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessGateway) 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.(*GetWirelessGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Identifier}")
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_serializeOpHttpBindingsGetWirelessGatewayInput(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_serializeOpHttpBindingsGetWirelessGatewayInput(v *GetWirelessGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Identifier == nil || len(*v.Identifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Identifier must not be empty")}
}
if v.Identifier != nil {
if err := encoder.SetURI("Identifier").String(*v.Identifier); err != nil {
return err
}
}
if len(v.IdentifierType) > 0 {
encoder.SetQuery("identifierType").String(string(v.IdentifierType))
}
return nil
}
type awsRestjson1_serializeOpGetWirelessGatewayCertificate struct {
}
func (*awsRestjson1_serializeOpGetWirelessGatewayCertificate) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessGatewayCertificate) 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.(*GetWirelessGatewayCertificateInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/certificate")
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_serializeOpHttpBindingsGetWirelessGatewayCertificateInput(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_serializeOpHttpBindingsGetWirelessGatewayCertificateInput(v *GetWirelessGatewayCertificateInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWirelessGatewayFirmwareInformation struct {
}
func (*awsRestjson1_serializeOpGetWirelessGatewayFirmwareInformation) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessGatewayFirmwareInformation) 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.(*GetWirelessGatewayFirmwareInformationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/firmware-information")
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_serializeOpHttpBindingsGetWirelessGatewayFirmwareInformationInput(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_serializeOpHttpBindingsGetWirelessGatewayFirmwareInformationInput(v *GetWirelessGatewayFirmwareInformationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWirelessGatewayStatistics struct {
}
func (*awsRestjson1_serializeOpGetWirelessGatewayStatistics) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessGatewayStatistics) 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.(*GetWirelessGatewayStatisticsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{WirelessGatewayId}/statistics")
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_serializeOpHttpBindingsGetWirelessGatewayStatisticsInput(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_serializeOpHttpBindingsGetWirelessGatewayStatisticsInput(v *GetWirelessGatewayStatisticsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.WirelessGatewayId == nil || len(*v.WirelessGatewayId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member WirelessGatewayId must not be empty")}
}
if v.WirelessGatewayId != nil {
if err := encoder.SetURI("WirelessGatewayId").String(*v.WirelessGatewayId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWirelessGatewayTask struct {
}
func (*awsRestjson1_serializeOpGetWirelessGatewayTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessGatewayTask) 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.(*GetWirelessGatewayTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}/tasks")
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_serializeOpHttpBindingsGetWirelessGatewayTaskInput(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_serializeOpHttpBindingsGetWirelessGatewayTaskInput(v *GetWirelessGatewayTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetWirelessGatewayTaskDefinition struct {
}
func (*awsRestjson1_serializeOpGetWirelessGatewayTaskDefinition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetWirelessGatewayTaskDefinition) 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.(*GetWirelessGatewayTaskDefinitionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateway-task-definitions/{Id}")
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_serializeOpHttpBindingsGetWirelessGatewayTaskDefinitionInput(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_serializeOpHttpBindingsGetWirelessGatewayTaskDefinitionInput(v *GetWirelessGatewayTaskDefinitionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListDestinations struct {
}
func (*awsRestjson1_serializeOpListDestinations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDestinations) 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.(*ListDestinationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/destinations")
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_serializeOpHttpBindingsListDestinationsInput(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_serializeOpHttpBindingsListDestinationsInput(v *ListDestinationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListDeviceProfiles struct {
}
func (*awsRestjson1_serializeOpListDeviceProfiles) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDeviceProfiles) 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.(*ListDeviceProfilesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/device-profiles")
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_serializeOpHttpBindingsListDeviceProfilesInput(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_serializeOpHttpBindingsListDeviceProfilesInput(v *ListDeviceProfilesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.DeviceProfileType) > 0 {
encoder.SetQuery("deviceProfileType").String(string(v.DeviceProfileType))
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListDevicesForWirelessDeviceImportTask struct {
}
func (*awsRestjson1_serializeOpListDevicesForWirelessDeviceImportTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDevicesForWirelessDeviceImportTask) 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.(*ListDevicesForWirelessDeviceImportTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless_device_import_task")
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_serializeOpHttpBindingsListDevicesForWirelessDeviceImportTaskInput(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_serializeOpHttpBindingsListDevicesForWirelessDeviceImportTaskInput(v *ListDevicesForWirelessDeviceImportTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id != nil {
encoder.SetQuery("id").String(*v.Id)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if len(v.Status) > 0 {
encoder.SetQuery("status").String(string(v.Status))
}
return nil
}
type awsRestjson1_serializeOpListEventConfigurations struct {
}
func (*awsRestjson1_serializeOpListEventConfigurations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListEventConfigurations) 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.(*ListEventConfigurationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/event-configurations")
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_serializeOpHttpBindingsListEventConfigurationsInput(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_serializeOpHttpBindingsListEventConfigurationsInput(v *ListEventConfigurationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
type awsRestjson1_serializeOpListFuotaTasks struct {
}
func (*awsRestjson1_serializeOpListFuotaTasks) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListFuotaTasks) 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.(*ListFuotaTasksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks")
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_serializeOpHttpBindingsListFuotaTasksInput(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_serializeOpHttpBindingsListFuotaTasksInput(v *ListFuotaTasksInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListMulticastGroups struct {
}
func (*awsRestjson1_serializeOpListMulticastGroups) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListMulticastGroups) 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.(*ListMulticastGroupsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups")
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_serializeOpHttpBindingsListMulticastGroupsInput(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_serializeOpHttpBindingsListMulticastGroupsInput(v *ListMulticastGroupsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListMulticastGroupsByFuotaTask struct {
}
func (*awsRestjson1_serializeOpListMulticastGroupsByFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListMulticastGroupsByFuotaTask) 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.(*ListMulticastGroupsByFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}/multicast-groups")
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_serializeOpHttpBindingsListMulticastGroupsByFuotaTaskInput(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_serializeOpHttpBindingsListMulticastGroupsByFuotaTaskInput(v *ListMulticastGroupsByFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListNetworkAnalyzerConfigurations struct {
}
func (*awsRestjson1_serializeOpListNetworkAnalyzerConfigurations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListNetworkAnalyzerConfigurations) 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.(*ListNetworkAnalyzerConfigurationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/network-analyzer-configurations")
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_serializeOpHttpBindingsListNetworkAnalyzerConfigurationsInput(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_serializeOpHttpBindingsListNetworkAnalyzerConfigurationsInput(v *ListNetworkAnalyzerConfigurationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListPartnerAccounts struct {
}
func (*awsRestjson1_serializeOpListPartnerAccounts) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListPartnerAccounts) 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.(*ListPartnerAccountsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/partner-accounts")
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_serializeOpHttpBindingsListPartnerAccountsInput(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_serializeOpHttpBindingsListPartnerAccountsInput(v *ListPartnerAccountsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListPositionConfigurations struct {
}
func (*awsRestjson1_serializeOpListPositionConfigurations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListPositionConfigurations) 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.(*ListPositionConfigurationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/position-configurations")
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_serializeOpHttpBindingsListPositionConfigurationsInput(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_serializeOpHttpBindingsListPositionConfigurationsInput(v *ListPositionConfigurationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
type awsRestjson1_serializeOpListQueuedMessages struct {
}
func (*awsRestjson1_serializeOpListQueuedMessages) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListQueuedMessages) 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.(*ListQueuedMessagesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}/data")
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_serializeOpHttpBindingsListQueuedMessagesInput(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_serializeOpHttpBindingsListQueuedMessagesInput(v *ListQueuedMessagesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if len(v.WirelessDeviceType) > 0 {
encoder.SetQuery("WirelessDeviceType").String(string(v.WirelessDeviceType))
}
return nil
}
type awsRestjson1_serializeOpListServiceProfiles struct {
}
func (*awsRestjson1_serializeOpListServiceProfiles) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListServiceProfiles) 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.(*ListServiceProfilesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/service-profiles")
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_serializeOpHttpBindingsListServiceProfilesInput(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_serializeOpHttpBindingsListServiceProfilesInput(v *ListServiceProfilesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
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")
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 {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
return nil
}
type awsRestjson1_serializeOpListWirelessDeviceImportTasks struct {
}
func (*awsRestjson1_serializeOpListWirelessDeviceImportTasks) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListWirelessDeviceImportTasks) 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.(*ListWirelessDeviceImportTasksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless_device_import_tasks")
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_serializeOpHttpBindingsListWirelessDeviceImportTasksInput(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_serializeOpHttpBindingsListWirelessDeviceImportTasksInput(v *ListWirelessDeviceImportTasksInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListWirelessDevices struct {
}
func (*awsRestjson1_serializeOpListWirelessDevices) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListWirelessDevices) 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.(*ListWirelessDevicesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-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_serializeOpHttpBindingsListWirelessDevicesInput(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_serializeOpHttpBindingsListWirelessDevicesInput(v *ListWirelessDevicesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DestinationName != nil {
encoder.SetQuery("destinationName").String(*v.DestinationName)
}
if v.DeviceProfileId != nil {
encoder.SetQuery("deviceProfileId").String(*v.DeviceProfileId)
}
if v.FuotaTaskId != nil {
encoder.SetQuery("fuotaTaskId").String(*v.FuotaTaskId)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.MulticastGroupId != nil {
encoder.SetQuery("multicastGroupId").String(*v.MulticastGroupId)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.ServiceProfileId != nil {
encoder.SetQuery("serviceProfileId").String(*v.ServiceProfileId)
}
if len(v.WirelessDeviceType) > 0 {
encoder.SetQuery("wirelessDeviceType").String(string(v.WirelessDeviceType))
}
return nil
}
type awsRestjson1_serializeOpListWirelessGateways struct {
}
func (*awsRestjson1_serializeOpListWirelessGateways) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListWirelessGateways) 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.(*ListWirelessGatewaysInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways")
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_serializeOpHttpBindingsListWirelessGatewaysInput(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_serializeOpHttpBindingsListWirelessGatewaysInput(v *ListWirelessGatewaysInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListWirelessGatewayTaskDefinitions struct {
}
func (*awsRestjson1_serializeOpListWirelessGatewayTaskDefinitions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListWirelessGatewayTaskDefinitions) 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.(*ListWirelessGatewayTaskDefinitionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateway-task-definitions")
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_serializeOpHttpBindingsListWirelessGatewayTaskDefinitionsInput(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_serializeOpHttpBindingsListWirelessGatewayTaskDefinitionsInput(v *ListWirelessGatewayTaskDefinitionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if len(v.TaskDefinitionType) > 0 {
encoder.SetQuery("taskDefinitionType").String(string(v.TaskDefinitionType))
}
return nil
}
type awsRestjson1_serializeOpPutPositionConfiguration struct {
}
func (*awsRestjson1_serializeOpPutPositionConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutPositionConfiguration) 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.(*PutPositionConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/position-configurations/{ResourceIdentifier}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsPutPositionConfigurationInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentPutPositionConfigurationInput(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_serializeOpHttpBindingsPutPositionConfigurationInput(v *PutPositionConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
func awsRestjson1_serializeOpDocumentPutPositionConfigurationInput(v *PutPositionConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Destination != nil {
ok := object.Key("Destination")
ok.String(*v.Destination)
}
if v.Solvers != nil {
ok := object.Key("Solvers")
if err := awsRestjson1_serializeDocumentPositionSolverConfigurations(v.Solvers, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpPutResourceLogLevel struct {
}
func (*awsRestjson1_serializeOpPutResourceLogLevel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutResourceLogLevel) 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.(*PutResourceLogLevelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/log-levels/{ResourceIdentifier}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsPutResourceLogLevelInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentPutResourceLogLevelInput(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_serializeOpHttpBindingsPutResourceLogLevelInput(v *PutResourceLogLevelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if v.ResourceType != nil {
encoder.SetQuery("resourceType").String(*v.ResourceType)
}
return nil
}
func awsRestjson1_serializeOpDocumentPutResourceLogLevelInput(v *PutResourceLogLevelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.LogLevel) > 0 {
ok := object.Key("LogLevel")
ok.String(string(v.LogLevel))
}
return nil
}
type awsRestjson1_serializeOpResetAllResourceLogLevels struct {
}
func (*awsRestjson1_serializeOpResetAllResourceLogLevels) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpResetAllResourceLogLevels) 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.(*ResetAllResourceLogLevelsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/log-levels")
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 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_serializeOpHttpBindingsResetAllResourceLogLevelsInput(v *ResetAllResourceLogLevelsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpResetResourceLogLevel struct {
}
func (*awsRestjson1_serializeOpResetResourceLogLevel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpResetResourceLogLevel) 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.(*ResetResourceLogLevelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/log-levels/{ResourceIdentifier}")
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_serializeOpHttpBindingsResetResourceLogLevelInput(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_serializeOpHttpBindingsResetResourceLogLevelInput(v *ResetResourceLogLevelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if v.ResourceType != nil {
encoder.SetQuery("resourceType").String(*v.ResourceType)
}
return nil
}
type awsRestjson1_serializeOpSendDataToMulticastGroup struct {
}
func (*awsRestjson1_serializeOpSendDataToMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpSendDataToMulticastGroup) 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.(*SendDataToMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/data")
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_serializeOpHttpBindingsSendDataToMulticastGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentSendDataToMulticastGroupInput(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_serializeOpHttpBindingsSendDataToMulticastGroupInput(v *SendDataToMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentSendDataToMulticastGroupInput(v *SendDataToMulticastGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PayloadData != nil {
ok := object.Key("PayloadData")
ok.String(*v.PayloadData)
}
if v.WirelessMetadata != nil {
ok := object.Key("WirelessMetadata")
if err := awsRestjson1_serializeDocumentMulticastWirelessMetadata(v.WirelessMetadata, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpSendDataToWirelessDevice struct {
}
func (*awsRestjson1_serializeOpSendDataToWirelessDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpSendDataToWirelessDevice) 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.(*SendDataToWirelessDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}/data")
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_serializeOpHttpBindingsSendDataToWirelessDeviceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentSendDataToWirelessDeviceInput(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_serializeOpHttpBindingsSendDataToWirelessDeviceInput(v *SendDataToWirelessDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentSendDataToWirelessDeviceInput(v *SendDataToWirelessDeviceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PayloadData != nil {
ok := object.Key("PayloadData")
ok.String(*v.PayloadData)
}
if v.TransmitMode != nil {
ok := object.Key("TransmitMode")
ok.Integer(*v.TransmitMode)
}
if v.WirelessMetadata != nil {
ok := object.Key("WirelessMetadata")
if err := awsRestjson1_serializeDocumentWirelessMetadata(v.WirelessMetadata, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartBulkAssociateWirelessDeviceWithMulticastGroup struct {
}
func (*awsRestjson1_serializeOpStartBulkAssociateWirelessDeviceWithMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartBulkAssociateWirelessDeviceWithMulticastGroup) 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.(*StartBulkAssociateWirelessDeviceWithMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/bulk")
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_serializeOpHttpBindingsStartBulkAssociateWirelessDeviceWithMulticastGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartBulkAssociateWirelessDeviceWithMulticastGroupInput(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_serializeOpHttpBindingsStartBulkAssociateWirelessDeviceWithMulticastGroupInput(v *StartBulkAssociateWirelessDeviceWithMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartBulkAssociateWirelessDeviceWithMulticastGroupInput(v *StartBulkAssociateWirelessDeviceWithMulticastGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.QueryString != nil {
ok := object.Key("QueryString")
ok.String(*v.QueryString)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartBulkDisassociateWirelessDeviceFromMulticastGroup struct {
}
func (*awsRestjson1_serializeOpStartBulkDisassociateWirelessDeviceFromMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartBulkDisassociateWirelessDeviceFromMulticastGroup) 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.(*StartBulkDisassociateWirelessDeviceFromMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/bulk")
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_serializeOpHttpBindingsStartBulkDisassociateWirelessDeviceFromMulticastGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartBulkDisassociateWirelessDeviceFromMulticastGroupInput(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_serializeOpHttpBindingsStartBulkDisassociateWirelessDeviceFromMulticastGroupInput(v *StartBulkDisassociateWirelessDeviceFromMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartBulkDisassociateWirelessDeviceFromMulticastGroupInput(v *StartBulkDisassociateWirelessDeviceFromMulticastGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.QueryString != nil {
ok := object.Key("QueryString")
ok.String(*v.QueryString)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartFuotaTask struct {
}
func (*awsRestjson1_serializeOpStartFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartFuotaTask) 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.(*StartFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsStartFuotaTaskInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartFuotaTaskInput(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_serializeOpHttpBindingsStartFuotaTaskInput(v *StartFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartFuotaTaskInput(v *StartFuotaTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANStartFuotaTask(v.LoRaWAN, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartMulticastGroupSession struct {
}
func (*awsRestjson1_serializeOpStartMulticastGroupSession) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartMulticastGroupSession) 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.(*StartMulticastGroupSessionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}/session")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpHttpBindingsStartMulticastGroupSessionInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartMulticastGroupSessionInput(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_serializeOpHttpBindingsStartMulticastGroupSessionInput(v *StartMulticastGroupSessionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartMulticastGroupSessionInput(v *StartMulticastGroupSessionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANMulticastSession(v.LoRaWAN, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartSingleWirelessDeviceImportTask struct {
}
func (*awsRestjson1_serializeOpStartSingleWirelessDeviceImportTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartSingleWirelessDeviceImportTask) 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.(*StartSingleWirelessDeviceImportTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless_single_device_import_task")
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_serializeOpDocumentStartSingleWirelessDeviceImportTaskInput(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_serializeOpHttpBindingsStartSingleWirelessDeviceImportTaskInput(v *StartSingleWirelessDeviceImportTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartSingleWirelessDeviceImportTaskInput(v *StartSingleWirelessDeviceImportTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.DestinationName != nil {
ok := object.Key("DestinationName")
ok.String(*v.DestinationName)
}
if v.DeviceName != nil {
ok := object.Key("DeviceName")
ok.String(*v.DeviceName)
}
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkSingleStartImportInfo(v.Sidewalk, 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_serializeOpStartWirelessDeviceImportTask struct {
}
func (*awsRestjson1_serializeOpStartWirelessDeviceImportTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartWirelessDeviceImportTask) 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.(*StartWirelessDeviceImportTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless_device_import_task")
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_serializeOpDocumentStartWirelessDeviceImportTaskInput(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_serializeOpHttpBindingsStartWirelessDeviceImportTaskInput(v *StartWirelessDeviceImportTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartWirelessDeviceImportTaskInput(v *StartWirelessDeviceImportTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientRequestToken != nil {
ok := object.Key("ClientRequestToken")
ok.String(*v.ClientRequestToken)
}
if v.DestinationName != nil {
ok := object.Key("DestinationName")
ok.String(*v.DestinationName)
}
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkStartImportInfo(v.Sidewalk, 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_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")
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 {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
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_serializeOpTestWirelessDevice struct {
}
func (*awsRestjson1_serializeOpTestWirelessDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpTestWirelessDevice) 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.(*TestWirelessDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}/test")
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_serializeOpHttpBindingsTestWirelessDeviceInput(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_serializeOpHttpBindingsTestWirelessDeviceInput(v *TestWirelessDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); 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")
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 {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
if v.TagKeys != nil {
for i := range v.TagKeys {
encoder.AddQuery("tagKeys").String(v.TagKeys[i])
}
}
return nil
}
type awsRestjson1_serializeOpUpdateDestination struct {
}
func (*awsRestjson1_serializeOpUpdateDestination) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateDestination) 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.(*UpdateDestinationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/destinations/{Name}")
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_serializeOpHttpBindingsUpdateDestinationInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateDestinationInput(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_serializeOpHttpBindingsUpdateDestinationInput(v *UpdateDestinationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateDestinationInput(v *UpdateDestinationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Expression != nil {
ok := object.Key("Expression")
ok.String(*v.Expression)
}
if len(v.ExpressionType) > 0 {
ok := object.Key("ExpressionType")
ok.String(string(v.ExpressionType))
}
if v.RoleArn != nil {
ok := object.Key("RoleArn")
ok.String(*v.RoleArn)
}
return nil
}
type awsRestjson1_serializeOpUpdateEventConfigurationByResourceTypes struct {
}
func (*awsRestjson1_serializeOpUpdateEventConfigurationByResourceTypes) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateEventConfigurationByResourceTypes) 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.(*UpdateEventConfigurationByResourceTypesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/event-configurations-resource-types")
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}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateEventConfigurationByResourceTypesInput(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_serializeOpHttpBindingsUpdateEventConfigurationByResourceTypesInput(v *UpdateEventConfigurationByResourceTypesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateEventConfigurationByResourceTypesInput(v *UpdateEventConfigurationByResourceTypesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConnectionStatus != nil {
ok := object.Key("ConnectionStatus")
if err := awsRestjson1_serializeDocumentConnectionStatusResourceTypeEventConfiguration(v.ConnectionStatus, ok); err != nil {
return err
}
}
if v.DeviceRegistrationState != nil {
ok := object.Key("DeviceRegistrationState")
if err := awsRestjson1_serializeDocumentDeviceRegistrationStateResourceTypeEventConfiguration(v.DeviceRegistrationState, ok); err != nil {
return err
}
}
if v.Join != nil {
ok := object.Key("Join")
if err := awsRestjson1_serializeDocumentJoinResourceTypeEventConfiguration(v.Join, ok); err != nil {
return err
}
}
if v.MessageDeliveryStatus != nil {
ok := object.Key("MessageDeliveryStatus")
if err := awsRestjson1_serializeDocumentMessageDeliveryStatusResourceTypeEventConfiguration(v.MessageDeliveryStatus, ok); err != nil {
return err
}
}
if v.Proximity != nil {
ok := object.Key("Proximity")
if err := awsRestjson1_serializeDocumentProximityResourceTypeEventConfiguration(v.Proximity, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateFuotaTask struct {
}
func (*awsRestjson1_serializeOpUpdateFuotaTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateFuotaTask) 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.(*UpdateFuotaTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/fuota-tasks/{Id}")
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_serializeOpHttpBindingsUpdateFuotaTaskInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateFuotaTaskInput(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_serializeOpHttpBindingsUpdateFuotaTaskInput(v *UpdateFuotaTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateFuotaTaskInput(v *UpdateFuotaTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.FirmwareUpdateImage != nil {
ok := object.Key("FirmwareUpdateImage")
ok.String(*v.FirmwareUpdateImage)
}
if v.FirmwareUpdateRole != nil {
ok := object.Key("FirmwareUpdateRole")
ok.String(*v.FirmwareUpdateRole)
}
if v.FragmentIntervalMS != nil {
ok := object.Key("FragmentIntervalMS")
ok.Integer(*v.FragmentIntervalMS)
}
if v.FragmentSizeBytes != nil {
ok := object.Key("FragmentSizeBytes")
ok.Integer(*v.FragmentSizeBytes)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANFuotaTask(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.RedundancyPercent != nil {
ok := object.Key("RedundancyPercent")
ok.Integer(*v.RedundancyPercent)
}
return nil
}
type awsRestjson1_serializeOpUpdateLogLevelsByResourceTypes struct {
}
func (*awsRestjson1_serializeOpUpdateLogLevelsByResourceTypes) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateLogLevelsByResourceTypes) 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.(*UpdateLogLevelsByResourceTypesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/log-levels")
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_serializeOpDocumentUpdateLogLevelsByResourceTypesInput(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_serializeOpHttpBindingsUpdateLogLevelsByResourceTypesInput(v *UpdateLogLevelsByResourceTypesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateLogLevelsByResourceTypesInput(v *UpdateLogLevelsByResourceTypesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DefaultLogLevel) > 0 {
ok := object.Key("DefaultLogLevel")
ok.String(string(v.DefaultLogLevel))
}
if v.WirelessDeviceLogOptions != nil {
ok := object.Key("WirelessDeviceLogOptions")
if err := awsRestjson1_serializeDocumentWirelessDeviceLogOptionList(v.WirelessDeviceLogOptions, ok); err != nil {
return err
}
}
if v.WirelessGatewayLogOptions != nil {
ok := object.Key("WirelessGatewayLogOptions")
if err := awsRestjson1_serializeDocumentWirelessGatewayLogOptionList(v.WirelessGatewayLogOptions, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateMulticastGroup struct {
}
func (*awsRestjson1_serializeOpUpdateMulticastGroup) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateMulticastGroup) 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.(*UpdateMulticastGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/multicast-groups/{Id}")
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_serializeOpHttpBindingsUpdateMulticastGroupInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateMulticastGroupInput(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_serializeOpHttpBindingsUpdateMulticastGroupInput(v *UpdateMulticastGroupInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateMulticastGroupInput(v *UpdateMulticastGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANMulticast(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
type awsRestjson1_serializeOpUpdateNetworkAnalyzerConfiguration struct {
}
func (*awsRestjson1_serializeOpUpdateNetworkAnalyzerConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateNetworkAnalyzerConfiguration) 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.(*UpdateNetworkAnalyzerConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/network-analyzer-configurations/{ConfigurationName}")
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_serializeOpHttpBindingsUpdateNetworkAnalyzerConfigurationInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateNetworkAnalyzerConfigurationInput(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_serializeOpHttpBindingsUpdateNetworkAnalyzerConfigurationInput(v *UpdateNetworkAnalyzerConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ConfigurationName == nil || len(*v.ConfigurationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationName must not be empty")}
}
if v.ConfigurationName != nil {
if err := encoder.SetURI("ConfigurationName").String(*v.ConfigurationName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateNetworkAnalyzerConfigurationInput(v *UpdateNetworkAnalyzerConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.MulticastGroupsToAdd != nil {
ok := object.Key("MulticastGroupsToAdd")
if err := awsRestjson1_serializeDocumentNetworkAnalyzerMulticastGroupList(v.MulticastGroupsToAdd, ok); err != nil {
return err
}
}
if v.MulticastGroupsToRemove != nil {
ok := object.Key("MulticastGroupsToRemove")
if err := awsRestjson1_serializeDocumentNetworkAnalyzerMulticastGroupList(v.MulticastGroupsToRemove, ok); err != nil {
return err
}
}
if v.TraceContent != nil {
ok := object.Key("TraceContent")
if err := awsRestjson1_serializeDocumentTraceContent(v.TraceContent, ok); err != nil {
return err
}
}
if v.WirelessDevicesToAdd != nil {
ok := object.Key("WirelessDevicesToAdd")
if err := awsRestjson1_serializeDocumentWirelessDeviceList(v.WirelessDevicesToAdd, ok); err != nil {
return err
}
}
if v.WirelessDevicesToRemove != nil {
ok := object.Key("WirelessDevicesToRemove")
if err := awsRestjson1_serializeDocumentWirelessDeviceList(v.WirelessDevicesToRemove, ok); err != nil {
return err
}
}
if v.WirelessGatewaysToAdd != nil {
ok := object.Key("WirelessGatewaysToAdd")
if err := awsRestjson1_serializeDocumentWirelessGatewayList(v.WirelessGatewaysToAdd, ok); err != nil {
return err
}
}
if v.WirelessGatewaysToRemove != nil {
ok := object.Key("WirelessGatewaysToRemove")
if err := awsRestjson1_serializeDocumentWirelessGatewayList(v.WirelessGatewaysToRemove, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdatePartnerAccount struct {
}
func (*awsRestjson1_serializeOpUpdatePartnerAccount) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdatePartnerAccount) 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.(*UpdatePartnerAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/partner-accounts/{PartnerAccountId}")
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_serializeOpHttpBindingsUpdatePartnerAccountInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdatePartnerAccountInput(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_serializeOpHttpBindingsUpdatePartnerAccountInput(v *UpdatePartnerAccountInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.PartnerAccountId == nil || len(*v.PartnerAccountId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PartnerAccountId must not be empty")}
}
if v.PartnerAccountId != nil {
if err := encoder.SetURI("PartnerAccountId").String(*v.PartnerAccountId); err != nil {
return err
}
}
if len(v.PartnerType) > 0 {
encoder.SetQuery("partnerType").String(string(v.PartnerType))
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdatePartnerAccountInput(v *UpdatePartnerAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkUpdateAccount(v.Sidewalk, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdatePosition struct {
}
func (*awsRestjson1_serializeOpUpdatePosition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdatePosition) 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.(*UpdatePositionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/positions/{ResourceIdentifier}")
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_serializeOpHttpBindingsUpdatePositionInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdatePositionInput(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_serializeOpHttpBindingsUpdatePositionInput(v *UpdatePositionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdatePositionInput(v *UpdatePositionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Position != nil {
ok := object.Key("Position")
if err := awsRestjson1_serializeDocumentPositionCoordinate(v.Position, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateResourceEventConfiguration struct {
}
func (*awsRestjson1_serializeOpUpdateResourceEventConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateResourceEventConfiguration) 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.(*UpdateResourceEventConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/event-configurations/{Identifier}")
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_serializeOpHttpBindingsUpdateResourceEventConfigurationInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateResourceEventConfigurationInput(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_serializeOpHttpBindingsUpdateResourceEventConfigurationInput(v *UpdateResourceEventConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Identifier == nil || len(*v.Identifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Identifier must not be empty")}
}
if v.Identifier != nil {
if err := encoder.SetURI("Identifier").String(*v.Identifier); err != nil {
return err
}
}
if len(v.IdentifierType) > 0 {
encoder.SetQuery("identifierType").String(string(v.IdentifierType))
}
if len(v.PartnerType) > 0 {
encoder.SetQuery("partnerType").String(string(v.PartnerType))
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateResourceEventConfigurationInput(v *UpdateResourceEventConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ConnectionStatus != nil {
ok := object.Key("ConnectionStatus")
if err := awsRestjson1_serializeDocumentConnectionStatusEventConfiguration(v.ConnectionStatus, ok); err != nil {
return err
}
}
if v.DeviceRegistrationState != nil {
ok := object.Key("DeviceRegistrationState")
if err := awsRestjson1_serializeDocumentDeviceRegistrationStateEventConfiguration(v.DeviceRegistrationState, ok); err != nil {
return err
}
}
if v.Join != nil {
ok := object.Key("Join")
if err := awsRestjson1_serializeDocumentJoinEventConfiguration(v.Join, ok); err != nil {
return err
}
}
if v.MessageDeliveryStatus != nil {
ok := object.Key("MessageDeliveryStatus")
if err := awsRestjson1_serializeDocumentMessageDeliveryStatusEventConfiguration(v.MessageDeliveryStatus, ok); err != nil {
return err
}
}
if v.Proximity != nil {
ok := object.Key("Proximity")
if err := awsRestjson1_serializeDocumentProximityEventConfiguration(v.Proximity, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateResourcePosition struct {
}
func (*awsRestjson1_serializeOpUpdateResourcePosition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateResourcePosition) 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.(*UpdateResourcePositionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/resource-positions/{ResourceIdentifier}")
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_serializeOpHttpBindingsUpdateResourcePositionInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if !restEncoder.HasHeader("Content-Type") {
ctx = smithyhttp.SetIsContentTypeDefaultValue(ctx, true)
restEncoder.SetHeader("Content-Type").String("application/octet-stream")
}
if input.GeoJsonPayload != nil {
payload := bytes.NewReader(input.GeoJsonPayload)
if request, err = request.SetStream(payload); 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_serializeOpHttpBindingsUpdateResourcePositionInput(v *UpdateResourcePositionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceIdentifier == nil || len(*v.ResourceIdentifier) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceIdentifier must not be empty")}
}
if v.ResourceIdentifier != nil {
if err := encoder.SetURI("ResourceIdentifier").String(*v.ResourceIdentifier); err != nil {
return err
}
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
return nil
}
type awsRestjson1_serializeOpUpdateWirelessDevice struct {
}
func (*awsRestjson1_serializeOpUpdateWirelessDevice) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateWirelessDevice) 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.(*UpdateWirelessDeviceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-devices/{Id}")
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_serializeOpHttpBindingsUpdateWirelessDeviceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateWirelessDeviceInput(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_serializeOpHttpBindingsUpdateWirelessDeviceInput(v *UpdateWirelessDeviceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateWirelessDeviceInput(v *UpdateWirelessDeviceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.DestinationName != nil {
ok := object.Key("DestinationName")
ok.String(*v.DestinationName)
}
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANUpdateDevice(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.Positioning) > 0 {
ok := object.Key("Positioning")
ok.String(string(v.Positioning))
}
return nil
}
type awsRestjson1_serializeOpUpdateWirelessDeviceImportTask struct {
}
func (*awsRestjson1_serializeOpUpdateWirelessDeviceImportTask) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateWirelessDeviceImportTask) 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.(*UpdateWirelessDeviceImportTaskInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless_device_import_task/{Id}")
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_serializeOpHttpBindingsUpdateWirelessDeviceImportTaskInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateWirelessDeviceImportTaskInput(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_serializeOpHttpBindingsUpdateWirelessDeviceImportTaskInput(v *UpdateWirelessDeviceImportTaskInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateWirelessDeviceImportTaskInput(v *UpdateWirelessDeviceImportTaskInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkUpdateImportInfo(v.Sidewalk, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateWirelessGateway struct {
}
func (*awsRestjson1_serializeOpUpdateWirelessGateway) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateWirelessGateway) 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.(*UpdateWirelessGatewayInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/wireless-gateways/{Id}")
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_serializeOpHttpBindingsUpdateWirelessGatewayInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateWirelessGatewayInput(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_serializeOpHttpBindingsUpdateWirelessGatewayInput(v *UpdateWirelessGatewayInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Id == nil || len(*v.Id) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")}
}
if v.Id != nil {
if err := encoder.SetURI("Id").String(*v.Id); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateWirelessGatewayInput(v *UpdateWirelessGatewayInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.JoinEuiFilters != nil {
ok := object.Key("JoinEuiFilters")
if err := awsRestjson1_serializeDocumentJoinEuiFilters(v.JoinEuiFilters, ok); err != nil {
return err
}
}
if v.MaxEirp != nil {
ok := object.Key("MaxEirp")
switch {
case math.IsNaN(float64(*v.MaxEirp)):
ok.String("NaN")
case math.IsInf(float64(*v.MaxEirp), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.MaxEirp), -1):
ok.String("-Infinity")
default:
ok.Float(*v.MaxEirp)
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.NetIdFilters != nil {
ok := object.Key("NetIdFilters")
if err := awsRestjson1_serializeDocumentNetIdFilters(v.NetIdFilters, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAbpV1_0_x(v *types.AbpV1_0_x, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DevAddr != nil {
ok := object.Key("DevAddr")
ok.String(*v.DevAddr)
}
if v.FCntStart != nil {
ok := object.Key("FCntStart")
ok.Integer(*v.FCntStart)
}
if v.SessionKeys != nil {
ok := object.Key("SessionKeys")
if err := awsRestjson1_serializeDocumentSessionKeysAbpV1_0_x(v.SessionKeys, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAbpV1_1(v *types.AbpV1_1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DevAddr != nil {
ok := object.Key("DevAddr")
ok.String(*v.DevAddr)
}
if v.FCntStart != nil {
ok := object.Key("FCntStart")
ok.Integer(*v.FCntStart)
}
if v.SessionKeys != nil {
ok := object.Key("SessionKeys")
if err := awsRestjson1_serializeDocumentSessionKeysAbpV1_1(v.SessionKeys, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentApplicationConfig(v *types.ApplicationConfig, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DestinationName != nil {
ok := object.Key("DestinationName")
ok.String(*v.DestinationName)
}
if v.FPort != nil {
ok := object.Key("FPort")
ok.Integer(*v.FPort)
}
if len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
func awsRestjson1_serializeDocumentApplications(v []types.ApplicationConfig, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentApplicationConfig(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAssistPosition(v []float32, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
switch {
case math.IsNaN(float64(v[i])):
av.String("NaN")
case math.IsInf(float64(v[i]), 1):
av.String("Infinity")
case math.IsInf(float64(v[i]), -1):
av.String("-Infinity")
default:
av.Float(v[i])
}
}
return nil
}
func awsRestjson1_serializeDocumentBeaconing(v *types.Beaconing, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DataRate != nil {
ok := object.Key("DataRate")
ok.Integer(*v.DataRate)
}
if v.Frequencies != nil {
ok := object.Key("Frequencies")
if err := awsRestjson1_serializeDocumentBeaconingFrequencies(v.Frequencies, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentBeaconingFrequencies(v []int32, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.Integer(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentCdmaList(v []types.CdmaObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentCdmaObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCdmaLocalId(v *types.CdmaLocalId, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CdmaChannel != nil {
ok := object.Key("CdmaChannel")
ok.Integer(*v.CdmaChannel)
}
if v.PnOffset != nil {
ok := object.Key("PnOffset")
ok.Integer(*v.PnOffset)
}
return nil
}
func awsRestjson1_serializeDocumentCdmaNmrList(v []types.CdmaNmrObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentCdmaNmrObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCdmaNmrObj(v *types.CdmaNmrObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BaseStationId != nil {
ok := object.Key("BaseStationId")
ok.Integer(*v.BaseStationId)
}
if v.CdmaChannel != nil {
ok := object.Key("CdmaChannel")
ok.Integer(*v.CdmaChannel)
}
if v.PilotPower != nil {
ok := object.Key("PilotPower")
ok.Integer(*v.PilotPower)
}
if v.PnOffset != nil {
ok := object.Key("PnOffset")
ok.Integer(*v.PnOffset)
}
return nil
}
func awsRestjson1_serializeDocumentCdmaObj(v *types.CdmaObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BaseLat != nil {
ok := object.Key("BaseLat")
switch {
case math.IsNaN(float64(*v.BaseLat)):
ok.String("NaN")
case math.IsInf(float64(*v.BaseLat), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.BaseLat), -1):
ok.String("-Infinity")
default:
ok.Float(*v.BaseLat)
}
}
if v.BaseLng != nil {
ok := object.Key("BaseLng")
switch {
case math.IsNaN(float64(*v.BaseLng)):
ok.String("NaN")
case math.IsInf(float64(*v.BaseLng), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.BaseLng), -1):
ok.String("-Infinity")
default:
ok.Float(*v.BaseLng)
}
}
if v.BaseStationId != nil {
ok := object.Key("BaseStationId")
ok.Integer(*v.BaseStationId)
}
if v.CdmaLocalId != nil {
ok := object.Key("CdmaLocalId")
if err := awsRestjson1_serializeDocumentCdmaLocalId(v.CdmaLocalId, ok); err != nil {
return err
}
}
if v.CdmaNmr != nil {
ok := object.Key("CdmaNmr")
if err := awsRestjson1_serializeDocumentCdmaNmrList(v.CdmaNmr, ok); err != nil {
return err
}
}
if v.NetworkId != nil {
ok := object.Key("NetworkId")
ok.Integer(*v.NetworkId)
}
if v.PilotPower != nil {
ok := object.Key("PilotPower")
ok.Integer(*v.PilotPower)
}
if v.RegistrationZone != nil {
ok := object.Key("RegistrationZone")
ok.Integer(*v.RegistrationZone)
}
if v.SystemId != nil {
ok := object.Key("SystemId")
ok.Integer(*v.SystemId)
}
return nil
}
func awsRestjson1_serializeDocumentCellTowers(v *types.CellTowers, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Cdma != nil {
ok := object.Key("Cdma")
if err := awsRestjson1_serializeDocumentCdmaList(v.Cdma, ok); err != nil {
return err
}
}
if v.Gsm != nil {
ok := object.Key("Gsm")
if err := awsRestjson1_serializeDocumentGsmList(v.Gsm, ok); err != nil {
return err
}
}
if v.Lte != nil {
ok := object.Key("Lte")
if err := awsRestjson1_serializeDocumentLteList(v.Lte, ok); err != nil {
return err
}
}
if v.Tdscdma != nil {
ok := object.Key("Tdscdma")
if err := awsRestjson1_serializeDocumentTdscdmaList(v.Tdscdma, ok); err != nil {
return err
}
}
if v.Wcdma != nil {
ok := object.Key("Wcdma")
if err := awsRestjson1_serializeDocumentWcdmaList(v.Wcdma, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentConnectionStatusEventConfiguration(v *types.ConnectionStatusEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANConnectionStatusEventNotificationConfigurations(v.LoRaWAN, ok); err != nil {
return err
}
}
if len(v.WirelessGatewayIdEventTopic) > 0 {
ok := object.Key("WirelessGatewayIdEventTopic")
ok.String(string(v.WirelessGatewayIdEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentConnectionStatusResourceTypeEventConfiguration(v *types.ConnectionStatusResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANConnectionStatusResourceTypeEventConfiguration(v.LoRaWAN, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDeviceRegistrationStateEventConfiguration(v *types.DeviceRegistrationStateEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkEventNotificationConfigurations(v.Sidewalk, ok); err != nil {
return err
}
}
if len(v.WirelessDeviceIdEventTopic) > 0 {
ok := object.Key("WirelessDeviceIdEventTopic")
ok.String(string(v.WirelessDeviceIdEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentDeviceRegistrationStateResourceTypeEventConfiguration(v *types.DeviceRegistrationStateResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkResourceTypeEventConfiguration(v.Sidewalk, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFactoryPresetFreqsList(v []int32, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.Integer(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentFPorts(v *types.FPorts, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Applications != nil {
ok := object.Key("Applications")
if err := awsRestjson1_serializeDocumentApplications(v.Applications, ok); err != nil {
return err
}
}
if v.ClockSync != nil {
ok := object.Key("ClockSync")
ok.Integer(*v.ClockSync)
}
if v.Fuota != nil {
ok := object.Key("Fuota")
ok.Integer(*v.Fuota)
}
if v.Multicast != nil {
ok := object.Key("Multicast")
ok.Integer(*v.Multicast)
}
if v.Positioning != nil {
ok := object.Key("Positioning")
if err := awsRestjson1_serializeDocumentPositioning(v.Positioning, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentGatewayList(v []types.GatewayListItem, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentGatewayListItem(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentGatewayListItem(v *types.GatewayListItem, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DownlinkFrequency != nil {
ok := object.Key("DownlinkFrequency")
ok.Integer(*v.DownlinkFrequency)
}
if v.GatewayId != nil {
ok := object.Key("GatewayId")
ok.String(*v.GatewayId)
}
return nil
}
func awsRestjson1_serializeDocumentGlobalIdentity(v *types.GlobalIdentity, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GeranCid != nil {
ok := object.Key("GeranCid")
ok.Integer(*v.GeranCid)
}
if v.Lac != nil {
ok := object.Key("Lac")
ok.Integer(*v.Lac)
}
return nil
}
func awsRestjson1_serializeDocumentGnss(v *types.Gnss, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AssistAltitude != nil {
ok := object.Key("AssistAltitude")
switch {
case math.IsNaN(float64(*v.AssistAltitude)):
ok.String("NaN")
case math.IsInf(float64(*v.AssistAltitude), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.AssistAltitude), -1):
ok.String("-Infinity")
default:
ok.Float(*v.AssistAltitude)
}
}
if v.AssistPosition != nil {
ok := object.Key("AssistPosition")
if err := awsRestjson1_serializeDocumentAssistPosition(v.AssistPosition, ok); err != nil {
return err
}
}
if v.CaptureTime != nil {
ok := object.Key("CaptureTime")
switch {
case math.IsNaN(float64(*v.CaptureTime)):
ok.String("NaN")
case math.IsInf(float64(*v.CaptureTime), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.CaptureTime), -1):
ok.String("-Infinity")
default:
ok.Float(*v.CaptureTime)
}
}
if v.CaptureTimeAccuracy != nil {
ok := object.Key("CaptureTimeAccuracy")
switch {
case math.IsNaN(float64(*v.CaptureTimeAccuracy)):
ok.String("NaN")
case math.IsInf(float64(*v.CaptureTimeAccuracy), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.CaptureTimeAccuracy), -1):
ok.String("-Infinity")
default:
ok.Float(*v.CaptureTimeAccuracy)
}
}
if v.Payload != nil {
ok := object.Key("Payload")
ok.String(*v.Payload)
}
if v.Use2DSolver {
ok := object.Key("Use2DSolver")
ok.Boolean(v.Use2DSolver)
}
return nil
}
func awsRestjson1_serializeDocumentGsmList(v []types.GsmObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentGsmObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentGsmLocalId(v *types.GsmLocalId, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Bcch != nil {
ok := object.Key("Bcch")
ok.Integer(*v.Bcch)
}
if v.Bsic != nil {
ok := object.Key("Bsic")
ok.Integer(*v.Bsic)
}
return nil
}
func awsRestjson1_serializeDocumentGsmNmrList(v []types.GsmNmrObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentGsmNmrObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentGsmNmrObj(v *types.GsmNmrObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Bcch != nil {
ok := object.Key("Bcch")
ok.Integer(*v.Bcch)
}
if v.Bsic != nil {
ok := object.Key("Bsic")
ok.Integer(*v.Bsic)
}
if v.GlobalIdentity != nil {
ok := object.Key("GlobalIdentity")
if err := awsRestjson1_serializeDocumentGlobalIdentity(v.GlobalIdentity, ok); err != nil {
return err
}
}
if v.RxLevel != nil {
ok := object.Key("RxLevel")
ok.Integer(*v.RxLevel)
}
return nil
}
func awsRestjson1_serializeDocumentGsmObj(v *types.GsmObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.GeranCid != nil {
ok := object.Key("GeranCid")
ok.Integer(*v.GeranCid)
}
if v.GsmLocalId != nil {
ok := object.Key("GsmLocalId")
if err := awsRestjson1_serializeDocumentGsmLocalId(v.GsmLocalId, ok); err != nil {
return err
}
}
if v.GsmNmr != nil {
ok := object.Key("GsmNmr")
if err := awsRestjson1_serializeDocumentGsmNmrList(v.GsmNmr, ok); err != nil {
return err
}
}
if v.GsmTimingAdvance != nil {
ok := object.Key("GsmTimingAdvance")
ok.Integer(*v.GsmTimingAdvance)
}
if v.Lac != nil {
ok := object.Key("Lac")
ok.Integer(*v.Lac)
}
if v.Mcc != nil {
ok := object.Key("Mcc")
ok.Integer(*v.Mcc)
}
if v.Mnc != nil {
ok := object.Key("Mnc")
ok.Integer(*v.Mnc)
}
if v.RxLevel != nil {
ok := object.Key("RxLevel")
ok.Integer(*v.RxLevel)
}
return nil
}
func awsRestjson1_serializeDocumentIp(v *types.Ip, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IpAddress != nil {
ok := object.Key("IpAddress")
ok.String(*v.IpAddress)
}
return nil
}
func awsRestjson1_serializeDocumentJoinEuiFilters(v [][]string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if vv := v[i]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocumentJoinEuiRange(v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentJoinEuiRange(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_serializeDocumentJoinEventConfiguration(v *types.JoinEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANJoinEventNotificationConfigurations(v.LoRaWAN, ok); err != nil {
return err
}
}
if len(v.WirelessDeviceIdEventTopic) > 0 {
ok := object.Key("WirelessDeviceIdEventTopic")
ok.String(string(v.WirelessDeviceIdEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentJoinResourceTypeEventConfiguration(v *types.JoinResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANJoinResourceTypeEventConfiguration(v.LoRaWAN, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANConnectionStatusEventNotificationConfigurations(v *types.LoRaWANConnectionStatusEventNotificationConfigurations, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.GatewayEuiEventTopic) > 0 {
ok := object.Key("GatewayEuiEventTopic")
ok.String(string(v.GatewayEuiEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANConnectionStatusResourceTypeEventConfiguration(v *types.LoRaWANConnectionStatusResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.WirelessGatewayEventTopic) > 0 {
ok := object.Key("WirelessGatewayEventTopic")
ok.String(string(v.WirelessGatewayEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANDevice(v *types.LoRaWANDevice, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AbpV1_0_x != nil {
ok := object.Key("AbpV1_0_x")
if err := awsRestjson1_serializeDocumentAbpV1_0_x(v.AbpV1_0_x, ok); err != nil {
return err
}
}
if v.AbpV1_1 != nil {
ok := object.Key("AbpV1_1")
if err := awsRestjson1_serializeDocumentAbpV1_1(v.AbpV1_1, ok); err != nil {
return err
}
}
if v.DevEui != nil {
ok := object.Key("DevEui")
ok.String(*v.DevEui)
}
if v.DeviceProfileId != nil {
ok := object.Key("DeviceProfileId")
ok.String(*v.DeviceProfileId)
}
if v.FPorts != nil {
ok := object.Key("FPorts")
if err := awsRestjson1_serializeDocumentFPorts(v.FPorts, ok); err != nil {
return err
}
}
if v.OtaaV1_0_x != nil {
ok := object.Key("OtaaV1_0_x")
if err := awsRestjson1_serializeDocumentOtaaV1_0_x(v.OtaaV1_0_x, ok); err != nil {
return err
}
}
if v.OtaaV1_1 != nil {
ok := object.Key("OtaaV1_1")
if err := awsRestjson1_serializeDocumentOtaaV1_1(v.OtaaV1_1, ok); err != nil {
return err
}
}
if v.ServiceProfileId != nil {
ok := object.Key("ServiceProfileId")
ok.String(*v.ServiceProfileId)
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANDeviceProfile(v *types.LoRaWANDeviceProfile, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClassBTimeout != nil {
ok := object.Key("ClassBTimeout")
ok.Integer(*v.ClassBTimeout)
}
if v.ClassCTimeout != nil {
ok := object.Key("ClassCTimeout")
ok.Integer(*v.ClassCTimeout)
}
if v.FactoryPresetFreqsList != nil {
ok := object.Key("FactoryPresetFreqsList")
if err := awsRestjson1_serializeDocumentFactoryPresetFreqsList(v.FactoryPresetFreqsList, ok); err != nil {
return err
}
}
if v.MacVersion != nil {
ok := object.Key("MacVersion")
ok.String(*v.MacVersion)
}
if v.MaxDutyCycle != nil {
ok := object.Key("MaxDutyCycle")
ok.Integer(*v.MaxDutyCycle)
}
if v.MaxEirp != nil {
ok := object.Key("MaxEirp")
ok.Integer(*v.MaxEirp)
}
if v.PingSlotDr != nil {
ok := object.Key("PingSlotDr")
ok.Integer(*v.PingSlotDr)
}
if v.PingSlotFreq != nil {
ok := object.Key("PingSlotFreq")
ok.Integer(*v.PingSlotFreq)
}
if v.PingSlotPeriod != nil {
ok := object.Key("PingSlotPeriod")
ok.Integer(*v.PingSlotPeriod)
}
if v.RegParamsRevision != nil {
ok := object.Key("RegParamsRevision")
ok.String(*v.RegParamsRevision)
}
if v.RfRegion != nil {
ok := object.Key("RfRegion")
ok.String(*v.RfRegion)
}
if v.RxDataRate2 != nil {
ok := object.Key("RxDataRate2")
ok.Integer(*v.RxDataRate2)
}
if v.RxDelay1 != nil {
ok := object.Key("RxDelay1")
ok.Integer(*v.RxDelay1)
}
if v.RxDrOffset1 != nil {
ok := object.Key("RxDrOffset1")
ok.Integer(*v.RxDrOffset1)
}
if v.RxFreq2 != nil {
ok := object.Key("RxFreq2")
ok.Integer(*v.RxFreq2)
}
if v.Supports32BitFCnt {
ok := object.Key("Supports32BitFCnt")
ok.Boolean(v.Supports32BitFCnt)
}
if v.SupportsClassB {
ok := object.Key("SupportsClassB")
ok.Boolean(v.SupportsClassB)
}
if v.SupportsClassC {
ok := object.Key("SupportsClassC")
ok.Boolean(v.SupportsClassC)
}
if v.SupportsJoin != nil {
ok := object.Key("SupportsJoin")
ok.Boolean(*v.SupportsJoin)
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANFuotaTask(v *types.LoRaWANFuotaTask, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.RfRegion) > 0 {
ok := object.Key("RfRegion")
ok.String(string(v.RfRegion))
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANGateway(v *types.LoRaWANGateway, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Beaconing != nil {
ok := object.Key("Beaconing")
if err := awsRestjson1_serializeDocumentBeaconing(v.Beaconing, ok); err != nil {
return err
}
}
if v.GatewayEui != nil {
ok := object.Key("GatewayEui")
ok.String(*v.GatewayEui)
}
if v.JoinEuiFilters != nil {
ok := object.Key("JoinEuiFilters")
if err := awsRestjson1_serializeDocumentJoinEuiFilters(v.JoinEuiFilters, ok); err != nil {
return err
}
}
if v.MaxEirp != nil {
ok := object.Key("MaxEirp")
switch {
case math.IsNaN(float64(*v.MaxEirp)):
ok.String("NaN")
case math.IsInf(float64(*v.MaxEirp), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.MaxEirp), -1):
ok.String("-Infinity")
default:
ok.Float(*v.MaxEirp)
}
}
if v.NetIdFilters != nil {
ok := object.Key("NetIdFilters")
if err := awsRestjson1_serializeDocumentNetIdFilters(v.NetIdFilters, ok); err != nil {
return err
}
}
if v.RfRegion != nil {
ok := object.Key("RfRegion")
ok.String(*v.RfRegion)
}
if v.SubBands != nil {
ok := object.Key("SubBands")
if err := awsRestjson1_serializeDocumentSubBands(v.SubBands, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANGatewayVersion(v *types.LoRaWANGatewayVersion, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Model != nil {
ok := object.Key("Model")
ok.String(*v.Model)
}
if v.PackageVersion != nil {
ok := object.Key("PackageVersion")
ok.String(*v.PackageVersion)
}
if v.Station != nil {
ok := object.Key("Station")
ok.String(*v.Station)
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANJoinEventNotificationConfigurations(v *types.LoRaWANJoinEventNotificationConfigurations, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DevEuiEventTopic) > 0 {
ok := object.Key("DevEuiEventTopic")
ok.String(string(v.DevEuiEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANJoinResourceTypeEventConfiguration(v *types.LoRaWANJoinResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.WirelessDeviceEventTopic) > 0 {
ok := object.Key("WirelessDeviceEventTopic")
ok.String(string(v.WirelessDeviceEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANMulticast(v *types.LoRaWANMulticast, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DlClass) > 0 {
ok := object.Key("DlClass")
ok.String(string(v.DlClass))
}
if len(v.RfRegion) > 0 {
ok := object.Key("RfRegion")
ok.String(string(v.RfRegion))
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANMulticastMetadata(v *types.LoRaWANMulticastMetadata, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FPort != nil {
ok := object.Key("FPort")
ok.Integer(*v.FPort)
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANMulticastSession(v *types.LoRaWANMulticastSession, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DlDr != nil {
ok := object.Key("DlDr")
ok.Integer(*v.DlDr)
}
if v.DlFreq != nil {
ok := object.Key("DlFreq")
ok.Integer(*v.DlFreq)
}
if v.PingSlotPeriod != nil {
ok := object.Key("PingSlotPeriod")
ok.Integer(*v.PingSlotPeriod)
}
if v.SessionStartTime != nil {
ok := object.Key("SessionStartTime")
ok.String(smithytime.FormatDateTime(*v.SessionStartTime))
}
if v.SessionTimeout != nil {
ok := object.Key("SessionTimeout")
ok.Integer(*v.SessionTimeout)
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANSendDataToDevice(v *types.LoRaWANSendDataToDevice, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FPort != nil {
ok := object.Key("FPort")
ok.Integer(*v.FPort)
}
if v.ParticipatingGateways != nil {
ok := object.Key("ParticipatingGateways")
if err := awsRestjson1_serializeDocumentParticipatingGateways(v.ParticipatingGateways, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANServiceProfile(v *types.LoRaWANServiceProfile, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AddGwMetadata {
ok := object.Key("AddGwMetadata")
ok.Boolean(v.AddGwMetadata)
}
if v.DrMax != nil {
ok := object.Key("DrMax")
ok.Integer(*v.DrMax)
}
if v.DrMin != nil {
ok := object.Key("DrMin")
ok.Integer(*v.DrMin)
}
if v.PrAllowed {
ok := object.Key("PrAllowed")
ok.Boolean(v.PrAllowed)
}
if v.RaAllowed {
ok := object.Key("RaAllowed")
ok.Boolean(v.RaAllowed)
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANStartFuotaTask(v *types.LoRaWANStartFuotaTask, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.StartTime != nil {
ok := object.Key("StartTime")
ok.String(smithytime.FormatDateTime(*v.StartTime))
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANUpdateDevice(v *types.LoRaWANUpdateDevice, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AbpV1_0_x != nil {
ok := object.Key("AbpV1_0_x")
if err := awsRestjson1_serializeDocumentUpdateAbpV1_0_x(v.AbpV1_0_x, ok); err != nil {
return err
}
}
if v.AbpV1_1 != nil {
ok := object.Key("AbpV1_1")
if err := awsRestjson1_serializeDocumentUpdateAbpV1_1(v.AbpV1_1, ok); err != nil {
return err
}
}
if v.DeviceProfileId != nil {
ok := object.Key("DeviceProfileId")
ok.String(*v.DeviceProfileId)
}
if v.FPorts != nil {
ok := object.Key("FPorts")
if err := awsRestjson1_serializeDocumentUpdateFPorts(v.FPorts, ok); err != nil {
return err
}
}
if v.ServiceProfileId != nil {
ok := object.Key("ServiceProfileId")
ok.String(*v.ServiceProfileId)
}
return nil
}
func awsRestjson1_serializeDocumentLoRaWANUpdateGatewayTaskCreate(v *types.LoRaWANUpdateGatewayTaskCreate, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CurrentVersion != nil {
ok := object.Key("CurrentVersion")
if err := awsRestjson1_serializeDocumentLoRaWANGatewayVersion(v.CurrentVersion, ok); err != nil {
return err
}
}
if v.SigKeyCrc != nil {
ok := object.Key("SigKeyCrc")
ok.Long(*v.SigKeyCrc)
}
if v.UpdateSignature != nil {
ok := object.Key("UpdateSignature")
ok.String(*v.UpdateSignature)
}
if v.UpdateVersion != nil {
ok := object.Key("UpdateVersion")
if err := awsRestjson1_serializeDocumentLoRaWANGatewayVersion(v.UpdateVersion, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLteList(v []types.LteObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentLteObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLteLocalId(v *types.LteLocalId, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Earfcn != nil {
ok := object.Key("Earfcn")
ok.Integer(*v.Earfcn)
}
if v.Pci != nil {
ok := object.Key("Pci")
ok.Integer(*v.Pci)
}
return nil
}
func awsRestjson1_serializeDocumentLteNmrList(v []types.LteNmrObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentLteNmrObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLteNmrObj(v *types.LteNmrObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Earfcn != nil {
ok := object.Key("Earfcn")
ok.Integer(*v.Earfcn)
}
if v.EutranCid != nil {
ok := object.Key("EutranCid")
ok.Integer(*v.EutranCid)
}
if v.Pci != nil {
ok := object.Key("Pci")
ok.Integer(*v.Pci)
}
if v.Rsrp != nil {
ok := object.Key("Rsrp")
ok.Integer(*v.Rsrp)
}
if v.Rsrq != nil {
ok := object.Key("Rsrq")
switch {
case math.IsNaN(float64(*v.Rsrq)):
ok.String("NaN")
case math.IsInf(float64(*v.Rsrq), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.Rsrq), -1):
ok.String("-Infinity")
default:
ok.Float(*v.Rsrq)
}
}
return nil
}
func awsRestjson1_serializeDocumentLteObj(v *types.LteObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EutranCid != nil {
ok := object.Key("EutranCid")
ok.Integer(*v.EutranCid)
}
if v.LteLocalId != nil {
ok := object.Key("LteLocalId")
if err := awsRestjson1_serializeDocumentLteLocalId(v.LteLocalId, ok); err != nil {
return err
}
}
if v.LteNmr != nil {
ok := object.Key("LteNmr")
if err := awsRestjson1_serializeDocumentLteNmrList(v.LteNmr, ok); err != nil {
return err
}
}
if v.LteTimingAdvance != nil {
ok := object.Key("LteTimingAdvance")
ok.Integer(*v.LteTimingAdvance)
}
if v.Mcc != nil {
ok := object.Key("Mcc")
ok.Integer(*v.Mcc)
}
if v.Mnc != nil {
ok := object.Key("Mnc")
ok.Integer(*v.Mnc)
}
if v.NrCapable {
ok := object.Key("NrCapable")
ok.Boolean(v.NrCapable)
}
if v.Rsrp != nil {
ok := object.Key("Rsrp")
ok.Integer(*v.Rsrp)
}
if v.Rsrq != nil {
ok := object.Key("Rsrq")
switch {
case math.IsNaN(float64(*v.Rsrq)):
ok.String("NaN")
case math.IsInf(float64(*v.Rsrq), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.Rsrq), -1):
ok.String("-Infinity")
default:
ok.Float(*v.Rsrq)
}
}
if v.Tac != nil {
ok := object.Key("Tac")
ok.Integer(*v.Tac)
}
return nil
}
func awsRestjson1_serializeDocumentMessageDeliveryStatusEventConfiguration(v *types.MessageDeliveryStatusEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkEventNotificationConfigurations(v.Sidewalk, ok); err != nil {
return err
}
}
if len(v.WirelessDeviceIdEventTopic) > 0 {
ok := object.Key("WirelessDeviceIdEventTopic")
ok.String(string(v.WirelessDeviceIdEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentMessageDeliveryStatusResourceTypeEventConfiguration(v *types.MessageDeliveryStatusResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkResourceTypeEventConfiguration(v.Sidewalk, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentMulticastWirelessMetadata(v *types.MulticastWirelessMetadata, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANMulticastMetadata(v.LoRaWAN, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentNetIdFilters(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_serializeDocumentNetworkAnalyzerMulticastGroupList(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_serializeDocumentOtaaV1_0_x(v *types.OtaaV1_0_x, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppEui != nil {
ok := object.Key("AppEui")
ok.String(*v.AppEui)
}
if v.AppKey != nil {
ok := object.Key("AppKey")
ok.String(*v.AppKey)
}
if v.GenAppKey != nil {
ok := object.Key("GenAppKey")
ok.String(*v.GenAppKey)
}
return nil
}
func awsRestjson1_serializeDocumentOtaaV1_1(v *types.OtaaV1_1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppKey != nil {
ok := object.Key("AppKey")
ok.String(*v.AppKey)
}
if v.JoinEui != nil {
ok := object.Key("JoinEui")
ok.String(*v.JoinEui)
}
if v.NwkKey != nil {
ok := object.Key("NwkKey")
ok.String(*v.NwkKey)
}
return nil
}
func awsRestjson1_serializeDocumentParticipatingGateways(v *types.ParticipatingGateways, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DownlinkMode) > 0 {
ok := object.Key("DownlinkMode")
ok.String(string(v.DownlinkMode))
}
if v.GatewayList != nil {
ok := object.Key("GatewayList")
if err := awsRestjson1_serializeDocumentGatewayList(v.GatewayList, ok); err != nil {
return err
}
}
if v.TransmissionInterval != nil {
ok := object.Key("TransmissionInterval")
ok.Integer(*v.TransmissionInterval)
}
return nil
}
func awsRestjson1_serializeDocumentPositionCoordinate(v []float32, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
switch {
case math.IsNaN(float64(v[i])):
av.String("NaN")
case math.IsInf(float64(v[i]), 1):
av.String("Infinity")
case math.IsInf(float64(v[i]), -1):
av.String("-Infinity")
default:
av.Float(v[i])
}
}
return nil
}
func awsRestjson1_serializeDocumentPositioning(v *types.Positioning, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClockSync != nil {
ok := object.Key("ClockSync")
ok.Integer(*v.ClockSync)
}
if v.Gnss != nil {
ok := object.Key("Gnss")
ok.Integer(*v.Gnss)
}
if v.Stream != nil {
ok := object.Key("Stream")
ok.Integer(*v.Stream)
}
return nil
}
func awsRestjson1_serializeDocumentPositionSolverConfigurations(v *types.PositionSolverConfigurations, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SemtechGnss != nil {
ok := object.Key("SemtechGnss")
if err := awsRestjson1_serializeDocumentSemtechGnssConfiguration(v.SemtechGnss, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentProximityEventConfiguration(v *types.ProximityEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkEventNotificationConfigurations(v.Sidewalk, ok); err != nil {
return err
}
}
if len(v.WirelessDeviceIdEventTopic) > 0 {
ok := object.Key("WirelessDeviceIdEventTopic")
ok.String(string(v.WirelessDeviceIdEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentProximityResourceTypeEventConfiguration(v *types.ProximityResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkResourceTypeEventConfiguration(v.Sidewalk, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSemtechGnssConfiguration(v *types.SemtechGnssConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Fec) > 0 {
ok := object.Key("Fec")
ok.String(string(v.Fec))
}
if len(v.Status) > 0 {
ok := object.Key("Status")
ok.String(string(v.Status))
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeysAbpV1_0_x(v *types.SessionKeysAbpV1_0_x, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppSKey != nil {
ok := object.Key("AppSKey")
ok.String(*v.AppSKey)
}
if v.NwkSKey != nil {
ok := object.Key("NwkSKey")
ok.String(*v.NwkSKey)
}
return nil
}
func awsRestjson1_serializeDocumentSessionKeysAbpV1_1(v *types.SessionKeysAbpV1_1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppSKey != nil {
ok := object.Key("AppSKey")
ok.String(*v.AppSKey)
}
if v.FNwkSIntKey != nil {
ok := object.Key("FNwkSIntKey")
ok.String(*v.FNwkSIntKey)
}
if v.NwkSEncKey != nil {
ok := object.Key("NwkSEncKey")
ok.String(*v.NwkSEncKey)
}
if v.SNwkSIntKey != nil {
ok := object.Key("SNwkSIntKey")
ok.String(*v.SNwkSIntKey)
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkAccountInfo(v *types.SidewalkAccountInfo, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AmazonId != nil {
ok := object.Key("AmazonId")
ok.String(*v.AmazonId)
}
if v.AppServerPrivateKey != nil {
ok := object.Key("AppServerPrivateKey")
ok.String(*v.AppServerPrivateKey)
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkCreateDeviceProfile(v *types.SidewalkCreateDeviceProfile, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsRestjson1_serializeDocumentSidewalkCreateWirelessDevice(v *types.SidewalkCreateWirelessDevice, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeviceProfileId != nil {
ok := object.Key("DeviceProfileId")
ok.String(*v.DeviceProfileId)
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkEventNotificationConfigurations(v *types.SidewalkEventNotificationConfigurations, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.AmazonIdEventTopic) > 0 {
ok := object.Key("AmazonIdEventTopic")
ok.String(string(v.AmazonIdEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkResourceTypeEventConfiguration(v *types.SidewalkResourceTypeEventConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.WirelessDeviceEventTopic) > 0 {
ok := object.Key("WirelessDeviceEventTopic")
ok.String(string(v.WirelessDeviceEventTopic))
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkSendDataToDevice(v *types.SidewalkSendDataToDevice, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AckModeRetryDurationSecs != nil {
ok := object.Key("AckModeRetryDurationSecs")
ok.Integer(*v.AckModeRetryDurationSecs)
}
if len(v.MessageType) > 0 {
ok := object.Key("MessageType")
ok.String(string(v.MessageType))
}
if v.Seq != nil {
ok := object.Key("Seq")
ok.Integer(*v.Seq)
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkSingleStartImportInfo(v *types.SidewalkSingleStartImportInfo, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SidewalkManufacturingSn != nil {
ok := object.Key("SidewalkManufacturingSn")
ok.String(*v.SidewalkManufacturingSn)
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkStartImportInfo(v *types.SidewalkStartImportInfo, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeviceCreationFile != nil {
ok := object.Key("DeviceCreationFile")
ok.String(*v.DeviceCreationFile)
}
if v.Role != nil {
ok := object.Key("Role")
ok.String(*v.Role)
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkUpdateAccount(v *types.SidewalkUpdateAccount, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppServerPrivateKey != nil {
ok := object.Key("AppServerPrivateKey")
ok.String(*v.AppServerPrivateKey)
}
return nil
}
func awsRestjson1_serializeDocumentSidewalkUpdateImportInfo(v *types.SidewalkUpdateImportInfo, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeviceCreationFile != nil {
ok := object.Key("DeviceCreationFile")
ok.String(*v.DeviceCreationFile)
}
return nil
}
func awsRestjson1_serializeDocumentSubBands(v []int32, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.Integer(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_serializeDocumentTdscdmaList(v []types.TdscdmaObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentTdscdmaObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTdscdmaLocalId(v *types.TdscdmaLocalId, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CellParams != nil {
ok := object.Key("CellParams")
ok.Integer(*v.CellParams)
}
if v.Uarfcn != nil {
ok := object.Key("Uarfcn")
ok.Integer(*v.Uarfcn)
}
return nil
}
func awsRestjson1_serializeDocumentTdscdmaNmrList(v []types.TdscdmaNmrObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentTdscdmaNmrObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTdscdmaNmrObj(v *types.TdscdmaNmrObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CellParams != nil {
ok := object.Key("CellParams")
ok.Integer(*v.CellParams)
}
if v.PathLoss != nil {
ok := object.Key("PathLoss")
ok.Integer(*v.PathLoss)
}
if v.Rscp != nil {
ok := object.Key("Rscp")
ok.Integer(*v.Rscp)
}
if v.Uarfcn != nil {
ok := object.Key("Uarfcn")
ok.Integer(*v.Uarfcn)
}
if v.UtranCid != nil {
ok := object.Key("UtranCid")
ok.Integer(*v.UtranCid)
}
return nil
}
func awsRestjson1_serializeDocumentTdscdmaObj(v *types.TdscdmaObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Lac != nil {
ok := object.Key("Lac")
ok.Integer(*v.Lac)
}
if v.Mcc != nil {
ok := object.Key("Mcc")
ok.Integer(*v.Mcc)
}
if v.Mnc != nil {
ok := object.Key("Mnc")
ok.Integer(*v.Mnc)
}
if v.PathLoss != nil {
ok := object.Key("PathLoss")
ok.Integer(*v.PathLoss)
}
if v.Rscp != nil {
ok := object.Key("Rscp")
ok.Integer(*v.Rscp)
}
if v.TdscdmaLocalId != nil {
ok := object.Key("TdscdmaLocalId")
if err := awsRestjson1_serializeDocumentTdscdmaLocalId(v.TdscdmaLocalId, ok); err != nil {
return err
}
}
if v.TdscdmaNmr != nil {
ok := object.Key("TdscdmaNmr")
if err := awsRestjson1_serializeDocumentTdscdmaNmrList(v.TdscdmaNmr, ok); err != nil {
return err
}
}
if v.TdscdmaTimingAdvance != nil {
ok := object.Key("TdscdmaTimingAdvance")
ok.Integer(*v.TdscdmaTimingAdvance)
}
if v.UtranCid != nil {
ok := object.Key("UtranCid")
ok.Integer(*v.UtranCid)
}
return nil
}
func awsRestjson1_serializeDocumentTraceContent(v *types.TraceContent, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.LogLevel) > 0 {
ok := object.Key("LogLevel")
ok.String(string(v.LogLevel))
}
if len(v.MulticastFrameInfo) > 0 {
ok := object.Key("MulticastFrameInfo")
ok.String(string(v.MulticastFrameInfo))
}
if len(v.WirelessDeviceFrameInfo) > 0 {
ok := object.Key("WirelessDeviceFrameInfo")
ok.String(string(v.WirelessDeviceFrameInfo))
}
return nil
}
func awsRestjson1_serializeDocumentUpdateAbpV1_0_x(v *types.UpdateAbpV1_0_x, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FCntStart != nil {
ok := object.Key("FCntStart")
ok.Integer(*v.FCntStart)
}
return nil
}
func awsRestjson1_serializeDocumentUpdateAbpV1_1(v *types.UpdateAbpV1_1, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FCntStart != nil {
ok := object.Key("FCntStart")
ok.Integer(*v.FCntStart)
}
return nil
}
func awsRestjson1_serializeDocumentUpdateFPorts(v *types.UpdateFPorts, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Applications != nil {
ok := object.Key("Applications")
if err := awsRestjson1_serializeDocumentApplications(v.Applications, ok); err != nil {
return err
}
}
if v.Positioning != nil {
ok := object.Key("Positioning")
if err := awsRestjson1_serializeDocumentPositioning(v.Positioning, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentUpdateWirelessGatewayTaskCreate(v *types.UpdateWirelessGatewayTaskCreate, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANUpdateGatewayTaskCreate(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.UpdateDataRole != nil {
ok := object.Key("UpdateDataRole")
ok.String(*v.UpdateDataRole)
}
if v.UpdateDataSource != nil {
ok := object.Key("UpdateDataSource")
ok.String(*v.UpdateDataSource)
}
return nil
}
func awsRestjson1_serializeDocumentWcdmaList(v []types.WcdmaObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWcdmaObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWcdmaLocalId(v *types.WcdmaLocalId, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Psc != nil {
ok := object.Key("Psc")
ok.Integer(*v.Psc)
}
if v.Uarfcndl != nil {
ok := object.Key("Uarfcndl")
ok.Integer(*v.Uarfcndl)
}
return nil
}
func awsRestjson1_serializeDocumentWcdmaNmrList(v []types.WcdmaNmrObj, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWcdmaNmrObj(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWcdmaNmrObj(v *types.WcdmaNmrObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PathLoss != nil {
ok := object.Key("PathLoss")
ok.Integer(*v.PathLoss)
}
if v.Psc != nil {
ok := object.Key("Psc")
ok.Integer(*v.Psc)
}
if v.Rscp != nil {
ok := object.Key("Rscp")
ok.Integer(*v.Rscp)
}
if v.Uarfcndl != nil {
ok := object.Key("Uarfcndl")
ok.Integer(*v.Uarfcndl)
}
if v.UtranCid != nil {
ok := object.Key("UtranCid")
ok.Integer(*v.UtranCid)
}
return nil
}
func awsRestjson1_serializeDocumentWcdmaObj(v *types.WcdmaObj, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Lac != nil {
ok := object.Key("Lac")
ok.Integer(*v.Lac)
}
if v.Mcc != nil {
ok := object.Key("Mcc")
ok.Integer(*v.Mcc)
}
if v.Mnc != nil {
ok := object.Key("Mnc")
ok.Integer(*v.Mnc)
}
if v.PathLoss != nil {
ok := object.Key("PathLoss")
ok.Integer(*v.PathLoss)
}
if v.Rscp != nil {
ok := object.Key("Rscp")
ok.Integer(*v.Rscp)
}
if v.UtranCid != nil {
ok := object.Key("UtranCid")
ok.Integer(*v.UtranCid)
}
if v.WcdmaLocalId != nil {
ok := object.Key("WcdmaLocalId")
if err := awsRestjson1_serializeDocumentWcdmaLocalId(v.WcdmaLocalId, ok); err != nil {
return err
}
}
if v.WcdmaNmr != nil {
ok := object.Key("WcdmaNmr")
if err := awsRestjson1_serializeDocumentWcdmaNmrList(v.WcdmaNmr, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWiFiAccessPoint(v *types.WiFiAccessPoint, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MacAddress != nil {
ok := object.Key("MacAddress")
ok.String(*v.MacAddress)
}
if v.Rss != nil {
ok := object.Key("Rss")
ok.Integer(*v.Rss)
}
return nil
}
func awsRestjson1_serializeDocumentWiFiAccessPoints(v []types.WiFiAccessPoint, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWiFiAccessPoint(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWirelessDeviceEventLogOption(v *types.WirelessDeviceEventLogOption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Event) > 0 {
ok := object.Key("Event")
ok.String(string(v.Event))
}
if len(v.LogLevel) > 0 {
ok := object.Key("LogLevel")
ok.String(string(v.LogLevel))
}
return nil
}
func awsRestjson1_serializeDocumentWirelessDeviceEventLogOptionList(v []types.WirelessDeviceEventLogOption, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWirelessDeviceEventLogOption(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWirelessDeviceList(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_serializeDocumentWirelessDeviceLogOption(v *types.WirelessDeviceLogOption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Events != nil {
ok := object.Key("Events")
if err := awsRestjson1_serializeDocumentWirelessDeviceEventLogOptionList(v.Events, ok); err != nil {
return err
}
}
if len(v.LogLevel) > 0 {
ok := object.Key("LogLevel")
ok.String(string(v.LogLevel))
}
if len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
func awsRestjson1_serializeDocumentWirelessDeviceLogOptionList(v []types.WirelessDeviceLogOption, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWirelessDeviceLogOption(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWirelessGatewayEventLogOption(v *types.WirelessGatewayEventLogOption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Event) > 0 {
ok := object.Key("Event")
ok.String(string(v.Event))
}
if len(v.LogLevel) > 0 {
ok := object.Key("LogLevel")
ok.String(string(v.LogLevel))
}
return nil
}
func awsRestjson1_serializeDocumentWirelessGatewayEventLogOptionList(v []types.WirelessGatewayEventLogOption, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWirelessGatewayEventLogOption(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWirelessGatewayList(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_serializeDocumentWirelessGatewayLogOption(v *types.WirelessGatewayLogOption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Events != nil {
ok := object.Key("Events")
if err := awsRestjson1_serializeDocumentWirelessGatewayEventLogOptionList(v.Events, ok); err != nil {
return err
}
}
if len(v.LogLevel) > 0 {
ok := object.Key("LogLevel")
ok.String(string(v.LogLevel))
}
if len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
func awsRestjson1_serializeDocumentWirelessGatewayLogOptionList(v []types.WirelessGatewayLogOption, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentWirelessGatewayLogOption(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentWirelessMetadata(v *types.WirelessMetadata, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoRaWAN != nil {
ok := object.Key("LoRaWAN")
if err := awsRestjson1_serializeDocumentLoRaWANSendDataToDevice(v.LoRaWAN, ok); err != nil {
return err
}
}
if v.Sidewalk != nil {
ok := object.Key("Sidewalk")
if err := awsRestjson1_serializeDocumentSidewalkSendDataToDevice(v.Sidewalk, ok); err != nil {
return err
}
}
return nil
}
| 10,331 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotwireless
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/iotwireless/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpAssociateAwsAccountWithPartnerAccount struct {
}
func (*validateOpAssociateAwsAccountWithPartnerAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateAwsAccountWithPartnerAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateAwsAccountWithPartnerAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateAwsAccountWithPartnerAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateMulticastGroupWithFuotaTask struct {
}
func (*validateOpAssociateMulticastGroupWithFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateMulticastGroupWithFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateMulticastGroupWithFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateMulticastGroupWithFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateWirelessDeviceWithFuotaTask struct {
}
func (*validateOpAssociateWirelessDeviceWithFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateWirelessDeviceWithFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateWirelessDeviceWithFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateWirelessDeviceWithFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateWirelessDeviceWithMulticastGroup struct {
}
func (*validateOpAssociateWirelessDeviceWithMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateWirelessDeviceWithMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateWirelessDeviceWithMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateWirelessDeviceWithMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateWirelessDeviceWithThing struct {
}
func (*validateOpAssociateWirelessDeviceWithThing) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateWirelessDeviceWithThing) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateWirelessDeviceWithThingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateWirelessDeviceWithThingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateWirelessGatewayWithCertificate struct {
}
func (*validateOpAssociateWirelessGatewayWithCertificate) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateWirelessGatewayWithCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateWirelessGatewayWithCertificateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateWirelessGatewayWithCertificateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateWirelessGatewayWithThing struct {
}
func (*validateOpAssociateWirelessGatewayWithThing) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateWirelessGatewayWithThing) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateWirelessGatewayWithThingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateWirelessGatewayWithThingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelMulticastGroupSession struct {
}
func (*validateOpCancelMulticastGroupSession) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelMulticastGroupSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelMulticastGroupSessionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelMulticastGroupSessionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateDestination struct {
}
func (*validateOpCreateDestination) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateDestinationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateDestinationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateDeviceProfile struct {
}
func (*validateOpCreateDeviceProfile) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateDeviceProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateDeviceProfileInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateDeviceProfileInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateFuotaTask struct {
}
func (*validateOpCreateFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateMulticastGroup struct {
}
func (*validateOpCreateMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateNetworkAnalyzerConfiguration struct {
}
func (*validateOpCreateNetworkAnalyzerConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateNetworkAnalyzerConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateNetworkAnalyzerConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateNetworkAnalyzerConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateServiceProfile struct {
}
func (*validateOpCreateServiceProfile) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateServiceProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateServiceProfileInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateServiceProfileInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateWirelessDevice struct {
}
func (*validateOpCreateWirelessDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateWirelessDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateWirelessDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateWirelessDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateWirelessGateway struct {
}
func (*validateOpCreateWirelessGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateWirelessGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateWirelessGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateWirelessGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateWirelessGatewayTaskDefinition struct {
}
func (*validateOpCreateWirelessGatewayTaskDefinition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateWirelessGatewayTaskDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateWirelessGatewayTaskDefinitionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateWirelessGatewayTaskDefinitionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateWirelessGatewayTask struct {
}
func (*validateOpCreateWirelessGatewayTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateWirelessGatewayTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateWirelessGatewayTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateWirelessGatewayTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteDestination struct {
}
func (*validateOpDeleteDestination) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteDestinationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteDestinationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteDeviceProfile struct {
}
func (*validateOpDeleteDeviceProfile) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteDeviceProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteDeviceProfileInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteDeviceProfileInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteFuotaTask struct {
}
func (*validateOpDeleteFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteMulticastGroup struct {
}
func (*validateOpDeleteMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteNetworkAnalyzerConfiguration struct {
}
func (*validateOpDeleteNetworkAnalyzerConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteNetworkAnalyzerConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteNetworkAnalyzerConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteNetworkAnalyzerConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteQueuedMessages struct {
}
func (*validateOpDeleteQueuedMessages) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteQueuedMessages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteQueuedMessagesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteQueuedMessagesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteServiceProfile struct {
}
func (*validateOpDeleteServiceProfile) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteServiceProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteServiceProfileInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteServiceProfileInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteWirelessDeviceImportTask struct {
}
func (*validateOpDeleteWirelessDeviceImportTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteWirelessDeviceImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteWirelessDeviceImportTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteWirelessDevice struct {
}
func (*validateOpDeleteWirelessDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteWirelessDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteWirelessDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteWirelessDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteWirelessGateway struct {
}
func (*validateOpDeleteWirelessGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteWirelessGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteWirelessGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteWirelessGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteWirelessGatewayTaskDefinition struct {
}
func (*validateOpDeleteWirelessGatewayTaskDefinition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteWirelessGatewayTaskDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteWirelessGatewayTaskDefinitionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteWirelessGatewayTaskDefinitionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteWirelessGatewayTask struct {
}
func (*validateOpDeleteWirelessGatewayTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteWirelessGatewayTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteWirelessGatewayTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteWirelessGatewayTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeregisterWirelessDevice struct {
}
func (*validateOpDeregisterWirelessDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeregisterWirelessDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeregisterWirelessDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeregisterWirelessDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateAwsAccountFromPartnerAccount struct {
}
func (*validateOpDisassociateAwsAccountFromPartnerAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateAwsAccountFromPartnerAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateAwsAccountFromPartnerAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateAwsAccountFromPartnerAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateMulticastGroupFromFuotaTask struct {
}
func (*validateOpDisassociateMulticastGroupFromFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateMulticastGroupFromFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateMulticastGroupFromFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateMulticastGroupFromFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateWirelessDeviceFromFuotaTask struct {
}
func (*validateOpDisassociateWirelessDeviceFromFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateWirelessDeviceFromFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateWirelessDeviceFromFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateWirelessDeviceFromFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateWirelessDeviceFromMulticastGroup struct {
}
func (*validateOpDisassociateWirelessDeviceFromMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateWirelessDeviceFromMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateWirelessDeviceFromMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateWirelessDeviceFromMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateWirelessDeviceFromThing struct {
}
func (*validateOpDisassociateWirelessDeviceFromThing) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateWirelessDeviceFromThing) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateWirelessDeviceFromThingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateWirelessDeviceFromThingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateWirelessGatewayFromCertificate struct {
}
func (*validateOpDisassociateWirelessGatewayFromCertificate) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateWirelessGatewayFromCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateWirelessGatewayFromCertificateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateWirelessGatewayFromCertificateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateWirelessGatewayFromThing struct {
}
func (*validateOpDisassociateWirelessGatewayFromThing) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateWirelessGatewayFromThing) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateWirelessGatewayFromThingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateWirelessGatewayFromThingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetDestination struct {
}
func (*validateOpGetDestination) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDestinationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDestinationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetDeviceProfile struct {
}
func (*validateOpGetDeviceProfile) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDeviceProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDeviceProfileInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDeviceProfileInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetFuotaTask struct {
}
func (*validateOpGetFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetMulticastGroup struct {
}
func (*validateOpGetMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetMulticastGroupSession struct {
}
func (*validateOpGetMulticastGroupSession) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetMulticastGroupSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetMulticastGroupSessionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetMulticastGroupSessionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetNetworkAnalyzerConfiguration struct {
}
func (*validateOpGetNetworkAnalyzerConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetNetworkAnalyzerConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetNetworkAnalyzerConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetNetworkAnalyzerConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPartnerAccount struct {
}
func (*validateOpGetPartnerAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPartnerAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPartnerAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPartnerAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPositionConfiguration struct {
}
func (*validateOpGetPositionConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPositionConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPositionConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPositionConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPositionEstimate struct {
}
func (*validateOpGetPositionEstimate) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPositionEstimate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPositionEstimateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPositionEstimateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPosition struct {
}
func (*validateOpGetPosition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPosition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPositionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPositionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetResourceEventConfiguration struct {
}
func (*validateOpGetResourceEventConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetResourceEventConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetResourceEventConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetResourceEventConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetResourceLogLevel struct {
}
func (*validateOpGetResourceLogLevel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetResourceLogLevel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetResourceLogLevelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetResourceLogLevelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetResourcePosition struct {
}
func (*validateOpGetResourcePosition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetResourcePosition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetResourcePositionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetResourcePositionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetServiceProfile struct {
}
func (*validateOpGetServiceProfile) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetServiceProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetServiceProfileInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetServiceProfileInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessDeviceImportTask struct {
}
func (*validateOpGetWirelessDeviceImportTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessDeviceImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessDeviceImportTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessDevice struct {
}
func (*validateOpGetWirelessDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessDeviceStatistics struct {
}
func (*validateOpGetWirelessDeviceStatistics) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessDeviceStatistics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessDeviceStatisticsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessDeviceStatisticsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessGatewayCertificate struct {
}
func (*validateOpGetWirelessGatewayCertificate) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessGatewayCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessGatewayCertificateInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessGatewayCertificateInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessGatewayFirmwareInformation struct {
}
func (*validateOpGetWirelessGatewayFirmwareInformation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessGatewayFirmwareInformation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessGatewayFirmwareInformationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessGatewayFirmwareInformationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessGateway struct {
}
func (*validateOpGetWirelessGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessGatewayStatistics struct {
}
func (*validateOpGetWirelessGatewayStatistics) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessGatewayStatistics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessGatewayStatisticsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessGatewayStatisticsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessGatewayTaskDefinition struct {
}
func (*validateOpGetWirelessGatewayTaskDefinition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessGatewayTaskDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessGatewayTaskDefinitionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessGatewayTaskDefinitionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetWirelessGatewayTask struct {
}
func (*validateOpGetWirelessGatewayTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetWirelessGatewayTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetWirelessGatewayTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetWirelessGatewayTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListDevicesForWirelessDeviceImportTask struct {
}
func (*validateOpListDevicesForWirelessDeviceImportTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListDevicesForWirelessDeviceImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListDevicesForWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListDevicesForWirelessDeviceImportTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListEventConfigurations struct {
}
func (*validateOpListEventConfigurations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListEventConfigurations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListEventConfigurationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListEventConfigurationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListMulticastGroupsByFuotaTask struct {
}
func (*validateOpListMulticastGroupsByFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListMulticastGroupsByFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListMulticastGroupsByFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListMulticastGroupsByFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListQueuedMessages struct {
}
func (*validateOpListQueuedMessages) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListQueuedMessages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListQueuedMessagesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListQueuedMessagesInput(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 validateOpPutPositionConfiguration struct {
}
func (*validateOpPutPositionConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutPositionConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutPositionConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutPositionConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutResourceLogLevel struct {
}
func (*validateOpPutResourceLogLevel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutResourceLogLevel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutResourceLogLevelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutResourceLogLevelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpResetResourceLogLevel struct {
}
func (*validateOpResetResourceLogLevel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpResetResourceLogLevel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ResetResourceLogLevelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpResetResourceLogLevelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSendDataToMulticastGroup struct {
}
func (*validateOpSendDataToMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSendDataToMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SendDataToMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSendDataToMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSendDataToWirelessDevice struct {
}
func (*validateOpSendDataToWirelessDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSendDataToWirelessDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SendDataToWirelessDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSendDataToWirelessDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartBulkAssociateWirelessDeviceWithMulticastGroup struct {
}
func (*validateOpStartBulkAssociateWirelessDeviceWithMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartBulkAssociateWirelessDeviceWithMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartBulkAssociateWirelessDeviceWithMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartBulkAssociateWirelessDeviceWithMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroup struct {
}
func (*validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartBulkDisassociateWirelessDeviceFromMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartFuotaTask struct {
}
func (*validateOpStartFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartMulticastGroupSession struct {
}
func (*validateOpStartMulticastGroupSession) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartMulticastGroupSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartMulticastGroupSessionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartMulticastGroupSessionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartSingleWirelessDeviceImportTask struct {
}
func (*validateOpStartSingleWirelessDeviceImportTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartSingleWirelessDeviceImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartSingleWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartSingleWirelessDeviceImportTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartWirelessDeviceImportTask struct {
}
func (*validateOpStartWirelessDeviceImportTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartWirelessDeviceImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartWirelessDeviceImportTaskInput(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 validateOpTestWirelessDevice struct {
}
func (*validateOpTestWirelessDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpTestWirelessDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*TestWirelessDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpTestWirelessDeviceInput(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 validateOpUpdateDestination struct {
}
func (*validateOpUpdateDestination) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateDestinationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateDestinationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateFuotaTask struct {
}
func (*validateOpUpdateFuotaTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateFuotaTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateFuotaTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateFuotaTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateLogLevelsByResourceTypes struct {
}
func (*validateOpUpdateLogLevelsByResourceTypes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateLogLevelsByResourceTypes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateLogLevelsByResourceTypesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateLogLevelsByResourceTypesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateMulticastGroup struct {
}
func (*validateOpUpdateMulticastGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateMulticastGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateMulticastGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateMulticastGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateNetworkAnalyzerConfiguration struct {
}
func (*validateOpUpdateNetworkAnalyzerConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateNetworkAnalyzerConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateNetworkAnalyzerConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateNetworkAnalyzerConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdatePartnerAccount struct {
}
func (*validateOpUpdatePartnerAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdatePartnerAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdatePartnerAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdatePartnerAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdatePosition struct {
}
func (*validateOpUpdatePosition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdatePosition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdatePositionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdatePositionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateResourceEventConfiguration struct {
}
func (*validateOpUpdateResourceEventConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateResourceEventConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateResourceEventConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateResourceEventConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateResourcePosition struct {
}
func (*validateOpUpdateResourcePosition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateResourcePosition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateResourcePositionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateResourcePositionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateWirelessDeviceImportTask struct {
}
func (*validateOpUpdateWirelessDeviceImportTask) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateWirelessDeviceImportTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateWirelessDeviceImportTaskInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateWirelessDeviceImportTaskInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateWirelessDevice struct {
}
func (*validateOpUpdateWirelessDevice) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateWirelessDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateWirelessDeviceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateWirelessDeviceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateWirelessGateway struct {
}
func (*validateOpUpdateWirelessGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateWirelessGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateWirelessGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateWirelessGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpAssociateAwsAccountWithPartnerAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateAwsAccountWithPartnerAccount{}, middleware.After)
}
func addOpAssociateMulticastGroupWithFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateMulticastGroupWithFuotaTask{}, middleware.After)
}
func addOpAssociateWirelessDeviceWithFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateWirelessDeviceWithFuotaTask{}, middleware.After)
}
func addOpAssociateWirelessDeviceWithMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateWirelessDeviceWithMulticastGroup{}, middleware.After)
}
func addOpAssociateWirelessDeviceWithThingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateWirelessDeviceWithThing{}, middleware.After)
}
func addOpAssociateWirelessGatewayWithCertificateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateWirelessGatewayWithCertificate{}, middleware.After)
}
func addOpAssociateWirelessGatewayWithThingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateWirelessGatewayWithThing{}, middleware.After)
}
func addOpCancelMulticastGroupSessionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelMulticastGroupSession{}, middleware.After)
}
func addOpCreateDestinationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateDestination{}, middleware.After)
}
func addOpCreateDeviceProfileValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateDeviceProfile{}, middleware.After)
}
func addOpCreateFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateFuotaTask{}, middleware.After)
}
func addOpCreateMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateMulticastGroup{}, middleware.After)
}
func addOpCreateNetworkAnalyzerConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateNetworkAnalyzerConfiguration{}, middleware.After)
}
func addOpCreateServiceProfileValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateServiceProfile{}, middleware.After)
}
func addOpCreateWirelessDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateWirelessDevice{}, middleware.After)
}
func addOpCreateWirelessGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateWirelessGateway{}, middleware.After)
}
func addOpCreateWirelessGatewayTaskDefinitionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateWirelessGatewayTaskDefinition{}, middleware.After)
}
func addOpCreateWirelessGatewayTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateWirelessGatewayTask{}, middleware.After)
}
func addOpDeleteDestinationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteDestination{}, middleware.After)
}
func addOpDeleteDeviceProfileValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteDeviceProfile{}, middleware.After)
}
func addOpDeleteFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteFuotaTask{}, middleware.After)
}
func addOpDeleteMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteMulticastGroup{}, middleware.After)
}
func addOpDeleteNetworkAnalyzerConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteNetworkAnalyzerConfiguration{}, middleware.After)
}
func addOpDeleteQueuedMessagesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteQueuedMessages{}, middleware.After)
}
func addOpDeleteServiceProfileValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteServiceProfile{}, middleware.After)
}
func addOpDeleteWirelessDeviceImportTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteWirelessDeviceImportTask{}, middleware.After)
}
func addOpDeleteWirelessDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteWirelessDevice{}, middleware.After)
}
func addOpDeleteWirelessGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteWirelessGateway{}, middleware.After)
}
func addOpDeleteWirelessGatewayTaskDefinitionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteWirelessGatewayTaskDefinition{}, middleware.After)
}
func addOpDeleteWirelessGatewayTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteWirelessGatewayTask{}, middleware.After)
}
func addOpDeregisterWirelessDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeregisterWirelessDevice{}, middleware.After)
}
func addOpDisassociateAwsAccountFromPartnerAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateAwsAccountFromPartnerAccount{}, middleware.After)
}
func addOpDisassociateMulticastGroupFromFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateMulticastGroupFromFuotaTask{}, middleware.After)
}
func addOpDisassociateWirelessDeviceFromFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateWirelessDeviceFromFuotaTask{}, middleware.After)
}
func addOpDisassociateWirelessDeviceFromMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateWirelessDeviceFromMulticastGroup{}, middleware.After)
}
func addOpDisassociateWirelessDeviceFromThingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateWirelessDeviceFromThing{}, middleware.After)
}
func addOpDisassociateWirelessGatewayFromCertificateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateWirelessGatewayFromCertificate{}, middleware.After)
}
func addOpDisassociateWirelessGatewayFromThingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateWirelessGatewayFromThing{}, middleware.After)
}
func addOpGetDestinationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDestination{}, middleware.After)
}
func addOpGetDeviceProfileValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDeviceProfile{}, middleware.After)
}
func addOpGetFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetFuotaTask{}, middleware.After)
}
func addOpGetMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetMulticastGroup{}, middleware.After)
}
func addOpGetMulticastGroupSessionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetMulticastGroupSession{}, middleware.After)
}
func addOpGetNetworkAnalyzerConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetNetworkAnalyzerConfiguration{}, middleware.After)
}
func addOpGetPartnerAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPartnerAccount{}, middleware.After)
}
func addOpGetPositionConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPositionConfiguration{}, middleware.After)
}
func addOpGetPositionEstimateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPositionEstimate{}, middleware.After)
}
func addOpGetPositionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPosition{}, middleware.After)
}
func addOpGetResourceEventConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetResourceEventConfiguration{}, middleware.After)
}
func addOpGetResourceLogLevelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetResourceLogLevel{}, middleware.After)
}
func addOpGetResourcePositionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetResourcePosition{}, middleware.After)
}
func addOpGetServiceProfileValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetServiceProfile{}, middleware.After)
}
func addOpGetWirelessDeviceImportTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessDeviceImportTask{}, middleware.After)
}
func addOpGetWirelessDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessDevice{}, middleware.After)
}
func addOpGetWirelessDeviceStatisticsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessDeviceStatistics{}, middleware.After)
}
func addOpGetWirelessGatewayCertificateValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessGatewayCertificate{}, middleware.After)
}
func addOpGetWirelessGatewayFirmwareInformationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessGatewayFirmwareInformation{}, middleware.After)
}
func addOpGetWirelessGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessGateway{}, middleware.After)
}
func addOpGetWirelessGatewayStatisticsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessGatewayStatistics{}, middleware.After)
}
func addOpGetWirelessGatewayTaskDefinitionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessGatewayTaskDefinition{}, middleware.After)
}
func addOpGetWirelessGatewayTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetWirelessGatewayTask{}, middleware.After)
}
func addOpListDevicesForWirelessDeviceImportTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListDevicesForWirelessDeviceImportTask{}, middleware.After)
}
func addOpListEventConfigurationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListEventConfigurations{}, middleware.After)
}
func addOpListMulticastGroupsByFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListMulticastGroupsByFuotaTask{}, middleware.After)
}
func addOpListQueuedMessagesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListQueuedMessages{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpPutPositionConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutPositionConfiguration{}, middleware.After)
}
func addOpPutResourceLogLevelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutResourceLogLevel{}, middleware.After)
}
func addOpResetResourceLogLevelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpResetResourceLogLevel{}, middleware.After)
}
func addOpSendDataToMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSendDataToMulticastGroup{}, middleware.After)
}
func addOpSendDataToWirelessDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSendDataToWirelessDevice{}, middleware.After)
}
func addOpStartBulkAssociateWirelessDeviceWithMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartBulkAssociateWirelessDeviceWithMulticastGroup{}, middleware.After)
}
func addOpStartBulkDisassociateWirelessDeviceFromMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroup{}, middleware.After)
}
func addOpStartFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartFuotaTask{}, middleware.After)
}
func addOpStartMulticastGroupSessionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartMulticastGroupSession{}, middleware.After)
}
func addOpStartSingleWirelessDeviceImportTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartSingleWirelessDeviceImportTask{}, middleware.After)
}
func addOpStartWirelessDeviceImportTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartWirelessDeviceImportTask{}, middleware.After)
}
func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}
func addOpTestWirelessDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpTestWirelessDevice{}, middleware.After)
}
func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}
func addOpUpdateDestinationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateDestination{}, middleware.After)
}
func addOpUpdateFuotaTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateFuotaTask{}, middleware.After)
}
func addOpUpdateLogLevelsByResourceTypesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateLogLevelsByResourceTypes{}, middleware.After)
}
func addOpUpdateMulticastGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateMulticastGroup{}, middleware.After)
}
func addOpUpdateNetworkAnalyzerConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateNetworkAnalyzerConfiguration{}, middleware.After)
}
func addOpUpdatePartnerAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdatePartnerAccount{}, middleware.After)
}
func addOpUpdatePositionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdatePosition{}, middleware.After)
}
func addOpUpdateResourceEventConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateResourceEventConfiguration{}, middleware.After)
}
func addOpUpdateResourcePositionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateResourcePosition{}, middleware.After)
}
func addOpUpdateWirelessDeviceImportTaskValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateWirelessDeviceImportTask{}, middleware.After)
}
func addOpUpdateWirelessDeviceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateWirelessDevice{}, middleware.After)
}
func addOpUpdateWirelessGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateWirelessGateway{}, middleware.After)
}
func validateCdmaList(v []types.CdmaObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CdmaList"}
for i := range v {
if err := validateCdmaObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCdmaLocalId(v *types.CdmaLocalId) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CdmaLocalId"}
if v.PnOffset == nil {
invalidParams.Add(smithy.NewErrParamRequired("PnOffset"))
}
if v.CdmaChannel == nil {
invalidParams.Add(smithy.NewErrParamRequired("CdmaChannel"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCdmaNmrList(v []types.CdmaNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CdmaNmrList"}
for i := range v {
if err := validateCdmaNmrObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCdmaNmrObj(v *types.CdmaNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CdmaNmrObj"}
if v.PnOffset == nil {
invalidParams.Add(smithy.NewErrParamRequired("PnOffset"))
}
if v.CdmaChannel == nil {
invalidParams.Add(smithy.NewErrParamRequired("CdmaChannel"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCdmaObj(v *types.CdmaObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CdmaObj"}
if v.SystemId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SystemId"))
}
if v.NetworkId == nil {
invalidParams.Add(smithy.NewErrParamRequired("NetworkId"))
}
if v.BaseStationId == nil {
invalidParams.Add(smithy.NewErrParamRequired("BaseStationId"))
}
if v.CdmaLocalId != nil {
if err := validateCdmaLocalId(v.CdmaLocalId); err != nil {
invalidParams.AddNested("CdmaLocalId", err.(smithy.InvalidParamsError))
}
}
if v.CdmaNmr != nil {
if err := validateCdmaNmrList(v.CdmaNmr); err != nil {
invalidParams.AddNested("CdmaNmr", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCellTowers(v *types.CellTowers) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CellTowers"}
if v.Gsm != nil {
if err := validateGsmList(v.Gsm); err != nil {
invalidParams.AddNested("Gsm", err.(smithy.InvalidParamsError))
}
}
if v.Wcdma != nil {
if err := validateWcdmaList(v.Wcdma); err != nil {
invalidParams.AddNested("Wcdma", err.(smithy.InvalidParamsError))
}
}
if v.Tdscdma != nil {
if err := validateTdscdmaList(v.Tdscdma); err != nil {
invalidParams.AddNested("Tdscdma", err.(smithy.InvalidParamsError))
}
}
if v.Lte != nil {
if err := validateLteList(v.Lte); err != nil {
invalidParams.AddNested("Lte", err.(smithy.InvalidParamsError))
}
}
if v.Cdma != nil {
if err := validateCdmaList(v.Cdma); err != nil {
invalidParams.AddNested("Cdma", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGatewayList(v []types.GatewayListItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GatewayList"}
for i := range v {
if err := validateGatewayListItem(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGatewayListItem(v *types.GatewayListItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GatewayListItem"}
if v.GatewayId == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
}
if v.DownlinkFrequency == nil {
invalidParams.Add(smithy.NewErrParamRequired("DownlinkFrequency"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGlobalIdentity(v *types.GlobalIdentity) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GlobalIdentity"}
if v.Lac == nil {
invalidParams.Add(smithy.NewErrParamRequired("Lac"))
}
if v.GeranCid == nil {
invalidParams.Add(smithy.NewErrParamRequired("GeranCid"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGnss(v *types.Gnss) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Gnss"}
if v.Payload == nil {
invalidParams.Add(smithy.NewErrParamRequired("Payload"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGsmList(v []types.GsmObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GsmList"}
for i := range v {
if err := validateGsmObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGsmLocalId(v *types.GsmLocalId) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GsmLocalId"}
if v.Bsic == nil {
invalidParams.Add(smithy.NewErrParamRequired("Bsic"))
}
if v.Bcch == nil {
invalidParams.Add(smithy.NewErrParamRequired("Bcch"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGsmNmrList(v []types.GsmNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GsmNmrList"}
for i := range v {
if err := validateGsmNmrObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGsmNmrObj(v *types.GsmNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GsmNmrObj"}
if v.Bsic == nil {
invalidParams.Add(smithy.NewErrParamRequired("Bsic"))
}
if v.Bcch == nil {
invalidParams.Add(smithy.NewErrParamRequired("Bcch"))
}
if v.GlobalIdentity != nil {
if err := validateGlobalIdentity(v.GlobalIdentity); err != nil {
invalidParams.AddNested("GlobalIdentity", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateGsmObj(v *types.GsmObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GsmObj"}
if v.Mcc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
}
if v.Mnc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
}
if v.Lac == nil {
invalidParams.Add(smithy.NewErrParamRequired("Lac"))
}
if v.GeranCid == nil {
invalidParams.Add(smithy.NewErrParamRequired("GeranCid"))
}
if v.GsmLocalId != nil {
if err := validateGsmLocalId(v.GsmLocalId); err != nil {
invalidParams.AddNested("GsmLocalId", err.(smithy.InvalidParamsError))
}
}
if v.GsmNmr != nil {
if err := validateGsmNmrList(v.GsmNmr); err != nil {
invalidParams.AddNested("GsmNmr", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIp(v *types.Ip) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Ip"}
if v.IpAddress == nil {
invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLoRaWANSendDataToDevice(v *types.LoRaWANSendDataToDevice) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LoRaWANSendDataToDevice"}
if v.ParticipatingGateways != nil {
if err := validateParticipatingGateways(v.ParticipatingGateways); err != nil {
invalidParams.AddNested("ParticipatingGateways", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLteList(v []types.LteObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LteList"}
for i := range v {
if err := validateLteObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLteLocalId(v *types.LteLocalId) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LteLocalId"}
if v.Pci == nil {
invalidParams.Add(smithy.NewErrParamRequired("Pci"))
}
if v.Earfcn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Earfcn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLteNmrList(v []types.LteNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LteNmrList"}
for i := range v {
if err := validateLteNmrObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLteNmrObj(v *types.LteNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LteNmrObj"}
if v.Pci == nil {
invalidParams.Add(smithy.NewErrParamRequired("Pci"))
}
if v.Earfcn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Earfcn"))
}
if v.EutranCid == nil {
invalidParams.Add(smithy.NewErrParamRequired("EutranCid"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLteObj(v *types.LteObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LteObj"}
if v.Mcc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
}
if v.Mnc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
}
if v.EutranCid == nil {
invalidParams.Add(smithy.NewErrParamRequired("EutranCid"))
}
if v.LteLocalId != nil {
if err := validateLteLocalId(v.LteLocalId); err != nil {
invalidParams.AddNested("LteLocalId", err.(smithy.InvalidParamsError))
}
}
if v.LteNmr != nil {
if err := validateLteNmrList(v.LteNmr); err != nil {
invalidParams.AddNested("LteNmr", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateParticipatingGateways(v *types.ParticipatingGateways) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ParticipatingGateways"}
if len(v.DownlinkMode) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("DownlinkMode"))
}
if v.GatewayList == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayList"))
} else if v.GatewayList != nil {
if err := validateGatewayList(v.GatewayList); err != nil {
invalidParams.AddNested("GatewayList", err.(smithy.InvalidParamsError))
}
}
if v.TransmissionInterval == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransmissionInterval"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePositionSolverConfigurations(v *types.PositionSolverConfigurations) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PositionSolverConfigurations"}
if v.SemtechGnss != nil {
if err := validateSemtechGnssConfiguration(v.SemtechGnss); err != nil {
invalidParams.AddNested("SemtechGnss", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSemtechGnssConfiguration(v *types.SemtechGnssConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SemtechGnssConfiguration"}
if len(v.Status) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Status"))
}
if len(v.Fec) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Fec"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTag(v *types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tag"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTagList(v []types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagList"}
for i := range v {
if err := validateTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTdscdmaList(v []types.TdscdmaObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TdscdmaList"}
for i := range v {
if err := validateTdscdmaObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTdscdmaLocalId(v *types.TdscdmaLocalId) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TdscdmaLocalId"}
if v.Uarfcn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Uarfcn"))
}
if v.CellParams == nil {
invalidParams.Add(smithy.NewErrParamRequired("CellParams"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTdscdmaNmrList(v []types.TdscdmaNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TdscdmaNmrList"}
for i := range v {
if err := validateTdscdmaNmrObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTdscdmaNmrObj(v *types.TdscdmaNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TdscdmaNmrObj"}
if v.Uarfcn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Uarfcn"))
}
if v.CellParams == nil {
invalidParams.Add(smithy.NewErrParamRequired("CellParams"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTdscdmaObj(v *types.TdscdmaObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TdscdmaObj"}
if v.Mcc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
}
if v.Mnc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
}
if v.UtranCid == nil {
invalidParams.Add(smithy.NewErrParamRequired("UtranCid"))
}
if v.TdscdmaLocalId != nil {
if err := validateTdscdmaLocalId(v.TdscdmaLocalId); err != nil {
invalidParams.AddNested("TdscdmaLocalId", err.(smithy.InvalidParamsError))
}
}
if v.TdscdmaNmr != nil {
if err := validateTdscdmaNmrList(v.TdscdmaNmr); err != nil {
invalidParams.AddNested("TdscdmaNmr", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWcdmaList(v []types.WcdmaObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WcdmaList"}
for i := range v {
if err := validateWcdmaObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWcdmaLocalId(v *types.WcdmaLocalId) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WcdmaLocalId"}
if v.Uarfcndl == nil {
invalidParams.Add(smithy.NewErrParamRequired("Uarfcndl"))
}
if v.Psc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Psc"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWcdmaNmrList(v []types.WcdmaNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WcdmaNmrList"}
for i := range v {
if err := validateWcdmaNmrObj(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWcdmaNmrObj(v *types.WcdmaNmrObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WcdmaNmrObj"}
if v.Uarfcndl == nil {
invalidParams.Add(smithy.NewErrParamRequired("Uarfcndl"))
}
if v.Psc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Psc"))
}
if v.UtranCid == nil {
invalidParams.Add(smithy.NewErrParamRequired("UtranCid"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWcdmaObj(v *types.WcdmaObj) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WcdmaObj"}
if v.Mcc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
}
if v.Mnc == nil {
invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
}
if v.UtranCid == nil {
invalidParams.Add(smithy.NewErrParamRequired("UtranCid"))
}
if v.WcdmaLocalId != nil {
if err := validateWcdmaLocalId(v.WcdmaLocalId); err != nil {
invalidParams.AddNested("WcdmaLocalId", err.(smithy.InvalidParamsError))
}
}
if v.WcdmaNmr != nil {
if err := validateWcdmaNmrList(v.WcdmaNmr); err != nil {
invalidParams.AddNested("WcdmaNmr", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWiFiAccessPoint(v *types.WiFiAccessPoint) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WiFiAccessPoint"}
if v.MacAddress == nil {
invalidParams.Add(smithy.NewErrParamRequired("MacAddress"))
}
if v.Rss == nil {
invalidParams.Add(smithy.NewErrParamRequired("Rss"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWiFiAccessPoints(v []types.WiFiAccessPoint) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WiFiAccessPoints"}
for i := range v {
if err := validateWiFiAccessPoint(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessDeviceEventLogOption(v *types.WirelessDeviceEventLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessDeviceEventLogOption"}
if len(v.Event) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Event"))
}
if len(v.LogLevel) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessDeviceEventLogOptionList(v []types.WirelessDeviceEventLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessDeviceEventLogOptionList"}
for i := range v {
if err := validateWirelessDeviceEventLogOption(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessDeviceLogOption(v *types.WirelessDeviceLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessDeviceLogOption"}
if len(v.Type) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if len(v.LogLevel) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
}
if v.Events != nil {
if err := validateWirelessDeviceEventLogOptionList(v.Events); err != nil {
invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessDeviceLogOptionList(v []types.WirelessDeviceLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessDeviceLogOptionList"}
for i := range v {
if err := validateWirelessDeviceLogOption(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessGatewayEventLogOption(v *types.WirelessGatewayEventLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessGatewayEventLogOption"}
if len(v.Event) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Event"))
}
if len(v.LogLevel) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessGatewayEventLogOptionList(v []types.WirelessGatewayEventLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessGatewayEventLogOptionList"}
for i := range v {
if err := validateWirelessGatewayEventLogOption(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessGatewayLogOption(v *types.WirelessGatewayLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessGatewayLogOption"}
if len(v.Type) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if len(v.LogLevel) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
}
if v.Events != nil {
if err := validateWirelessGatewayEventLogOptionList(v.Events); err != nil {
invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessGatewayLogOptionList(v []types.WirelessGatewayLogOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessGatewayLogOptionList"}
for i := range v {
if err := validateWirelessGatewayLogOption(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateWirelessMetadata(v *types.WirelessMetadata) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "WirelessMetadata"}
if v.LoRaWAN != nil {
if err := validateLoRaWANSendDataToDevice(v.LoRaWAN); err != nil {
invalidParams.AddNested("LoRaWAN", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateAwsAccountWithPartnerAccountInput(v *AssociateAwsAccountWithPartnerAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateAwsAccountWithPartnerAccountInput"}
if v.Sidewalk == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateMulticastGroupWithFuotaTaskInput(v *AssociateMulticastGroupWithFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateMulticastGroupWithFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.MulticastGroupId == nil {
invalidParams.Add(smithy.NewErrParamRequired("MulticastGroupId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateWirelessDeviceWithFuotaTaskInput(v *AssociateWirelessDeviceWithFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateWirelessDeviceWithFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.WirelessDeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessDeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateWirelessDeviceWithMulticastGroupInput(v *AssociateWirelessDeviceWithMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateWirelessDeviceWithMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.WirelessDeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessDeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateWirelessDeviceWithThingInput(v *AssociateWirelessDeviceWithThingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateWirelessDeviceWithThingInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.ThingArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ThingArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateWirelessGatewayWithCertificateInput(v *AssociateWirelessGatewayWithCertificateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateWirelessGatewayWithCertificateInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.IotCertificateId == nil {
invalidParams.Add(smithy.NewErrParamRequired("IotCertificateId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateWirelessGatewayWithThingInput(v *AssociateWirelessGatewayWithThingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateWirelessGatewayWithThingInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.ThingArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ThingArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelMulticastGroupSessionInput(v *CancelMulticastGroupSessionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelMulticastGroupSessionInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateDestinationInput(v *CreateDestinationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateDestinationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if len(v.ExpressionType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ExpressionType"))
}
if v.Expression == nil {
invalidParams.Add(smithy.NewErrParamRequired("Expression"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateDeviceProfileInput(v *CreateDeviceProfileInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateDeviceProfileInput"}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateFuotaTaskInput(v *CreateFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateFuotaTaskInput"}
if v.FirmwareUpdateImage == nil {
invalidParams.Add(smithy.NewErrParamRequired("FirmwareUpdateImage"))
}
if v.FirmwareUpdateRole == nil {
invalidParams.Add(smithy.NewErrParamRequired("FirmwareUpdateRole"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateMulticastGroupInput(v *CreateMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateMulticastGroupInput"}
if v.LoRaWAN == nil {
invalidParams.Add(smithy.NewErrParamRequired("LoRaWAN"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateNetworkAnalyzerConfigurationInput(v *CreateNetworkAnalyzerConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkAnalyzerConfigurationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateServiceProfileInput(v *CreateServiceProfileInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateServiceProfileInput"}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateWirelessDeviceInput(v *CreateWirelessDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateWirelessDeviceInput"}
if len(v.Type) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if v.DestinationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateWirelessGatewayInput(v *CreateWirelessGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateWirelessGatewayInput"}
if v.LoRaWAN == nil {
invalidParams.Add(smithy.NewErrParamRequired("LoRaWAN"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateWirelessGatewayTaskDefinitionInput(v *CreateWirelessGatewayTaskDefinitionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateWirelessGatewayTaskDefinitionInput"}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateWirelessGatewayTaskInput(v *CreateWirelessGatewayTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateWirelessGatewayTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.WirelessGatewayTaskDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessGatewayTaskDefinitionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteDestinationInput(v *DeleteDestinationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteDestinationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteDeviceProfileInput(v *DeleteDeviceProfileInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteDeviceProfileInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteFuotaTaskInput(v *DeleteFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteMulticastGroupInput(v *DeleteMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteNetworkAnalyzerConfigurationInput(v *DeleteNetworkAnalyzerConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkAnalyzerConfigurationInput"}
if v.ConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConfigurationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteQueuedMessagesInput(v *DeleteQueuedMessagesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteQueuedMessagesInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.MessageId == nil {
invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteServiceProfileInput(v *DeleteServiceProfileInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteServiceProfileInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteWirelessDeviceImportTaskInput(v *DeleteWirelessDeviceImportTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteWirelessDeviceImportTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteWirelessDeviceInput(v *DeleteWirelessDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteWirelessDeviceInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteWirelessGatewayInput(v *DeleteWirelessGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteWirelessGatewayInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteWirelessGatewayTaskDefinitionInput(v *DeleteWirelessGatewayTaskDefinitionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteWirelessGatewayTaskDefinitionInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteWirelessGatewayTaskInput(v *DeleteWirelessGatewayTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteWirelessGatewayTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeregisterWirelessDeviceInput(v *DeregisterWirelessDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeregisterWirelessDeviceInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateAwsAccountFromPartnerAccountInput(v *DisassociateAwsAccountFromPartnerAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateAwsAccountFromPartnerAccountInput"}
if v.PartnerAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PartnerAccountId"))
}
if len(v.PartnerType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PartnerType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateMulticastGroupFromFuotaTaskInput(v *DisassociateMulticastGroupFromFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateMulticastGroupFromFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.MulticastGroupId == nil {
invalidParams.Add(smithy.NewErrParamRequired("MulticastGroupId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateWirelessDeviceFromFuotaTaskInput(v *DisassociateWirelessDeviceFromFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateWirelessDeviceFromFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.WirelessDeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessDeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateWirelessDeviceFromMulticastGroupInput(v *DisassociateWirelessDeviceFromMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateWirelessDeviceFromMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.WirelessDeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessDeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateWirelessDeviceFromThingInput(v *DisassociateWirelessDeviceFromThingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateWirelessDeviceFromThingInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateWirelessGatewayFromCertificateInput(v *DisassociateWirelessGatewayFromCertificateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateWirelessGatewayFromCertificateInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateWirelessGatewayFromThingInput(v *DisassociateWirelessGatewayFromThingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateWirelessGatewayFromThingInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetDestinationInput(v *GetDestinationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDestinationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetDeviceProfileInput(v *GetDeviceProfileInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDeviceProfileInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetFuotaTaskInput(v *GetFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetMulticastGroupInput(v *GetMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetMulticastGroupSessionInput(v *GetMulticastGroupSessionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetMulticastGroupSessionInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetNetworkAnalyzerConfigurationInput(v *GetNetworkAnalyzerConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetNetworkAnalyzerConfigurationInput"}
if v.ConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConfigurationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPartnerAccountInput(v *GetPartnerAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPartnerAccountInput"}
if v.PartnerAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PartnerAccountId"))
}
if len(v.PartnerType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PartnerType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPositionConfigurationInput(v *GetPositionConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPositionConfigurationInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPositionEstimateInput(v *GetPositionEstimateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPositionEstimateInput"}
if v.WiFiAccessPoints != nil {
if err := validateWiFiAccessPoints(v.WiFiAccessPoints); err != nil {
invalidParams.AddNested("WiFiAccessPoints", err.(smithy.InvalidParamsError))
}
}
if v.CellTowers != nil {
if err := validateCellTowers(v.CellTowers); err != nil {
invalidParams.AddNested("CellTowers", err.(smithy.InvalidParamsError))
}
}
if v.Ip != nil {
if err := validateIp(v.Ip); err != nil {
invalidParams.AddNested("Ip", err.(smithy.InvalidParamsError))
}
}
if v.Gnss != nil {
if err := validateGnss(v.Gnss); err != nil {
invalidParams.AddNested("Gnss", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPositionInput(v *GetPositionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPositionInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetResourceEventConfigurationInput(v *GetResourceEventConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetResourceEventConfigurationInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
if len(v.IdentifierType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("IdentifierType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetResourceLogLevelInput(v *GetResourceLogLevelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetResourceLogLevelInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if v.ResourceType == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetResourcePositionInput(v *GetResourcePositionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetResourcePositionInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetServiceProfileInput(v *GetServiceProfileInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetServiceProfileInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessDeviceImportTaskInput(v *GetWirelessDeviceImportTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessDeviceImportTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessDeviceInput(v *GetWirelessDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessDeviceInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
if len(v.IdentifierType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("IdentifierType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessDeviceStatisticsInput(v *GetWirelessDeviceStatisticsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessDeviceStatisticsInput"}
if v.WirelessDeviceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessDeviceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessGatewayCertificateInput(v *GetWirelessGatewayCertificateInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessGatewayCertificateInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessGatewayFirmwareInformationInput(v *GetWirelessGatewayFirmwareInformationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessGatewayFirmwareInformationInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessGatewayInput(v *GetWirelessGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessGatewayInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
if len(v.IdentifierType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("IdentifierType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessGatewayStatisticsInput(v *GetWirelessGatewayStatisticsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessGatewayStatisticsInput"}
if v.WirelessGatewayId == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessGatewayId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessGatewayTaskDefinitionInput(v *GetWirelessGatewayTaskDefinitionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessGatewayTaskDefinitionInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetWirelessGatewayTaskInput(v *GetWirelessGatewayTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetWirelessGatewayTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListDevicesForWirelessDeviceImportTaskInput(v *ListDevicesForWirelessDeviceImportTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListDevicesForWirelessDeviceImportTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListEventConfigurationsInput(v *ListEventConfigurationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListEventConfigurationsInput"}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListMulticastGroupsByFuotaTaskInput(v *ListMulticastGroupsByFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListMulticastGroupsByFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListQueuedMessagesInput(v *ListQueuedMessagesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListQueuedMessagesInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
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 validateOpPutPositionConfigurationInput(v *PutPositionConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutPositionConfigurationInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if v.Solvers != nil {
if err := validatePositionSolverConfigurations(v.Solvers); err != nil {
invalidParams.AddNested("Solvers", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutResourceLogLevelInput(v *PutResourceLogLevelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutResourceLogLevelInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if v.ResourceType == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if len(v.LogLevel) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpResetResourceLogLevelInput(v *ResetResourceLogLevelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResetResourceLogLevelInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if v.ResourceType == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSendDataToMulticastGroupInput(v *SendDataToMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SendDataToMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.PayloadData == nil {
invalidParams.Add(smithy.NewErrParamRequired("PayloadData"))
}
if v.WirelessMetadata == nil {
invalidParams.Add(smithy.NewErrParamRequired("WirelessMetadata"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSendDataToWirelessDeviceInput(v *SendDataToWirelessDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SendDataToWirelessDeviceInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.TransmitMode == nil {
invalidParams.Add(smithy.NewErrParamRequired("TransmitMode"))
}
if v.PayloadData == nil {
invalidParams.Add(smithy.NewErrParamRequired("PayloadData"))
}
if v.WirelessMetadata != nil {
if err := validateWirelessMetadata(v.WirelessMetadata); err != nil {
invalidParams.AddNested("WirelessMetadata", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartBulkAssociateWirelessDeviceWithMulticastGroupInput(v *StartBulkAssociateWirelessDeviceWithMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartBulkAssociateWirelessDeviceWithMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroupInput(v *StartBulkDisassociateWirelessDeviceFromMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartBulkDisassociateWirelessDeviceFromMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartFuotaTaskInput(v *StartFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartMulticastGroupSessionInput(v *StartMulticastGroupSessionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartMulticastGroupSessionInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.LoRaWAN == nil {
invalidParams.Add(smithy.NewErrParamRequired("LoRaWAN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartSingleWirelessDeviceImportTaskInput(v *StartSingleWirelessDeviceImportTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartSingleWirelessDeviceImportTaskInput"}
if v.DestinationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if v.Sidewalk == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartWirelessDeviceImportTaskInput(v *StartWirelessDeviceImportTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartWirelessDeviceImportTaskInput"}
if v.DestinationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
}
if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if v.Sidewalk == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTagResourceInput(v *TagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
} else if v.Tags != nil {
if err := validateTagList(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTestWirelessDeviceInput(v *TestWirelessDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TestWirelessDeviceInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
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 validateOpUpdateDestinationInput(v *UpdateDestinationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateDestinationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateFuotaTaskInput(v *UpdateFuotaTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateFuotaTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateLogLevelsByResourceTypesInput(v *UpdateLogLevelsByResourceTypesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateLogLevelsByResourceTypesInput"}
if v.WirelessDeviceLogOptions != nil {
if err := validateWirelessDeviceLogOptionList(v.WirelessDeviceLogOptions); err != nil {
invalidParams.AddNested("WirelessDeviceLogOptions", err.(smithy.InvalidParamsError))
}
}
if v.WirelessGatewayLogOptions != nil {
if err := validateWirelessGatewayLogOptionList(v.WirelessGatewayLogOptions); err != nil {
invalidParams.AddNested("WirelessGatewayLogOptions", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateMulticastGroupInput(v *UpdateMulticastGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateMulticastGroupInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateNetworkAnalyzerConfigurationInput(v *UpdateNetworkAnalyzerConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateNetworkAnalyzerConfigurationInput"}
if v.ConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ConfigurationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdatePartnerAccountInput(v *UpdatePartnerAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdatePartnerAccountInput"}
if v.Sidewalk == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
}
if v.PartnerAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PartnerAccountId"))
}
if len(v.PartnerType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PartnerType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdatePositionInput(v *UpdatePositionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdatePositionInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if v.Position == nil {
invalidParams.Add(smithy.NewErrParamRequired("Position"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateResourceEventConfigurationInput(v *UpdateResourceEventConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceEventConfigurationInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
if len(v.IdentifierType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("IdentifierType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateResourcePositionInput(v *UpdateResourcePositionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateResourcePositionInput"}
if v.ResourceIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateWirelessDeviceImportTaskInput(v *UpdateWirelessDeviceImportTaskInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateWirelessDeviceImportTaskInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if v.Sidewalk == nil {
invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateWirelessDeviceInput(v *UpdateWirelessDeviceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateWirelessDeviceInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateWirelessGatewayInput(v *UpdateWirelessGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateWirelessGatewayInput"}
if v.Id == nil {
invalidParams.Add(smithy.NewErrParamRequired("Id"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 4,787 |
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 IoT Wireless 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: "api.iotwireless.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.iotwireless-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.iotwireless-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotwireless.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "ap-northeast-1",
}: endpoints.Endpoint{
Hostname: "api.iotwireless.ap-northeast-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-northeast-1",
},
},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{
Hostname: "api.iotwireless.ap-southeast-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-southeast-2",
},
},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{
Hostname: "api.iotwireless.eu-central-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-central-1",
},
},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{
Hostname: "api.iotwireless.eu-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-west-1",
},
},
endpoints.EndpointKey{
Region: "sa-east-1",
}: endpoints.Endpoint{
Hostname: "api.iotwireless.sa-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "sa-east-1",
},
},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{
Hostname: "api.iotwireless.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{
Hostname: "api.iotwireless.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: "api.iotwireless.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.iotwireless-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.iotwireless-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotwireless.{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: "api.iotwireless-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotwireless.{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: "api.iotwireless-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotwireless.{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: "api.iotwireless-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotwireless.{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: "api.iotwireless-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotwireless.{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: "api.iotwireless.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.iotwireless-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.iotwireless-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotwireless.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 355 |
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 ApplicationConfigType string
// Enum values for ApplicationConfigType
const (
ApplicationConfigTypeSemtechGeoLocation ApplicationConfigType = "SemtechGeolocation"
)
// Values returns all known values for ApplicationConfigType. 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 (ApplicationConfigType) Values() []ApplicationConfigType {
return []ApplicationConfigType{
"SemtechGeolocation",
}
}
type BatteryLevel string
// Enum values for BatteryLevel
const (
BatteryLevelNormal BatteryLevel = "normal"
BatteryLevelLow BatteryLevel = "low"
BatteryLevelCritical BatteryLevel = "critical"
)
// Values returns all known values for BatteryLevel. 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 (BatteryLevel) Values() []BatteryLevel {
return []BatteryLevel{
"normal",
"low",
"critical",
}
}
type ConnectionStatus string
// Enum values for ConnectionStatus
const (
ConnectionStatusConnected ConnectionStatus = "Connected"
ConnectionStatusDisconnected ConnectionStatus = "Disconnected"
)
// 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{
"Connected",
"Disconnected",
}
}
type DeviceProfileType string
// Enum values for DeviceProfileType
const (
DeviceProfileTypeSidewalk DeviceProfileType = "Sidewalk"
DeviceProfileTypeLoRaWAN DeviceProfileType = "LoRaWAN"
)
// Values returns all known values for DeviceProfileType. 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 (DeviceProfileType) Values() []DeviceProfileType {
return []DeviceProfileType{
"Sidewalk",
"LoRaWAN",
}
}
type DeviceState string
// Enum values for DeviceState
const (
DeviceStateProvisioned DeviceState = "Provisioned"
DeviceStateRegisterednotseen DeviceState = "RegisteredNotSeen"
DeviceStateRegisteredreachable DeviceState = "RegisteredReachable"
DeviceStateRegisteredunreachable DeviceState = "RegisteredUnreachable"
)
// 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{
"Provisioned",
"RegisteredNotSeen",
"RegisteredReachable",
"RegisteredUnreachable",
}
}
type DlClass string
// Enum values for DlClass
const (
DlClassClassB DlClass = "ClassB"
DlClassClassC DlClass = "ClassC"
)
// Values returns all known values for DlClass. 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 (DlClass) Values() []DlClass {
return []DlClass{
"ClassB",
"ClassC",
}
}
type DownlinkMode string
// Enum values for DownlinkMode
const (
DownlinkModeSequential DownlinkMode = "SEQUENTIAL"
DownlinkModeConcurrent DownlinkMode = "CONCURRENT"
DownlinkModeUsingUplinkGateway DownlinkMode = "USING_UPLINK_GATEWAY"
)
// Values returns all known values for DownlinkMode. 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 (DownlinkMode) Values() []DownlinkMode {
return []DownlinkMode{
"SEQUENTIAL",
"CONCURRENT",
"USING_UPLINK_GATEWAY",
}
}
type Event string
// Enum values for Event
const (
EventDiscovered Event = "discovered"
EventLost Event = "lost"
EventAck Event = "ack"
EventNack Event = "nack"
EventPassthrough Event = "passthrough"
)
// Values returns all known values for Event. 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 (Event) Values() []Event {
return []Event{
"discovered",
"lost",
"ack",
"nack",
"passthrough",
}
}
type EventNotificationPartnerType string
// Enum values for EventNotificationPartnerType
const (
EventNotificationPartnerTypeSidewalk EventNotificationPartnerType = "Sidewalk"
)
// Values returns all known values for EventNotificationPartnerType. 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 (EventNotificationPartnerType) Values() []EventNotificationPartnerType {
return []EventNotificationPartnerType{
"Sidewalk",
}
}
type EventNotificationResourceType string
// Enum values for EventNotificationResourceType
const (
EventNotificationResourceTypeSidewalkAccount EventNotificationResourceType = "SidewalkAccount"
EventNotificationResourceTypeWirelessDevice EventNotificationResourceType = "WirelessDevice"
EventNotificationResourceTypeWirelessGateway EventNotificationResourceType = "WirelessGateway"
)
// Values returns all known values for EventNotificationResourceType. 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 (EventNotificationResourceType) Values() []EventNotificationResourceType {
return []EventNotificationResourceType{
"SidewalkAccount",
"WirelessDevice",
"WirelessGateway",
}
}
type EventNotificationTopicStatus string
// Enum values for EventNotificationTopicStatus
const (
EventNotificationTopicStatusEnabled EventNotificationTopicStatus = "Enabled"
EventNotificationTopicStatusDisabled EventNotificationTopicStatus = "Disabled"
)
// Values returns all known values for EventNotificationTopicStatus. 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 (EventNotificationTopicStatus) Values() []EventNotificationTopicStatus {
return []EventNotificationTopicStatus{
"Enabled",
"Disabled",
}
}
type ExpressionType string
// Enum values for ExpressionType
const (
ExpressionTypeRuleName ExpressionType = "RuleName"
ExpressionTypeMqttTopic ExpressionType = "MqttTopic"
)
// Values returns all known values for ExpressionType. 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 (ExpressionType) Values() []ExpressionType {
return []ExpressionType{
"RuleName",
"MqttTopic",
}
}
type FuotaDeviceStatus string
// Enum values for FuotaDeviceStatus
const (
FuotaDeviceStatusInitial FuotaDeviceStatus = "Initial"
FuotaDeviceStatusPackageNotSupported FuotaDeviceStatus = "Package_Not_Supported"
FuotaDeviceStatusFragAlgoUnsupported FuotaDeviceStatus = "FragAlgo_unsupported"
FuotaDeviceStatusNotEnoughMemory FuotaDeviceStatus = "Not_enough_memory"
FuotaDeviceStatusFragIndexUnsupported FuotaDeviceStatus = "FragIndex_unsupported"
FuotaDeviceStatusWrongDescriptor FuotaDeviceStatus = "Wrong_descriptor"
FuotaDeviceStatusSessionCntReplay FuotaDeviceStatus = "SessionCnt_replay"
FuotaDeviceStatusMissingFrag FuotaDeviceStatus = "MissingFrag"
FuotaDeviceStatusMemoryError FuotaDeviceStatus = "MemoryError"
FuotaDeviceStatusMICError FuotaDeviceStatus = "MICError"
FuotaDeviceStatusSuccessful FuotaDeviceStatus = "Successful"
)
// Values returns all known values for FuotaDeviceStatus. 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 (FuotaDeviceStatus) Values() []FuotaDeviceStatus {
return []FuotaDeviceStatus{
"Initial",
"Package_Not_Supported",
"FragAlgo_unsupported",
"Not_enough_memory",
"FragIndex_unsupported",
"Wrong_descriptor",
"SessionCnt_replay",
"MissingFrag",
"MemoryError",
"MICError",
"Successful",
}
}
type FuotaTaskStatus string
// Enum values for FuotaTaskStatus
const (
FuotaTaskStatusPending FuotaTaskStatus = "Pending"
FuotaTaskStatusFuotaSessionWaiting FuotaTaskStatus = "FuotaSession_Waiting"
FuotaTaskStatusInFuotaSession FuotaTaskStatus = "In_FuotaSession"
FuotaTaskStatusFuotaDone FuotaTaskStatus = "FuotaDone"
FuotaTaskStatusDeleteWaiting FuotaTaskStatus = "Delete_Waiting"
)
// Values returns all known values for FuotaTaskStatus. 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 (FuotaTaskStatus) Values() []FuotaTaskStatus {
return []FuotaTaskStatus{
"Pending",
"FuotaSession_Waiting",
"In_FuotaSession",
"FuotaDone",
"Delete_Waiting",
}
}
type IdentifierType string
// Enum values for IdentifierType
const (
IdentifierTypePartnerAccountId IdentifierType = "PartnerAccountId"
IdentifierTypeDevEui IdentifierType = "DevEui"
IdentifierTypeGatewayEui IdentifierType = "GatewayEui"
IdentifierTypeWirelessDeviceId IdentifierType = "WirelessDeviceId"
IdentifierTypeWirelessGatewayId IdentifierType = "WirelessGatewayId"
)
// Values returns all known values for IdentifierType. 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 (IdentifierType) Values() []IdentifierType {
return []IdentifierType{
"PartnerAccountId",
"DevEui",
"GatewayEui",
"WirelessDeviceId",
"WirelessGatewayId",
}
}
type ImportTaskStatus string
// Enum values for ImportTaskStatus
const (
ImportTaskStatusInitializing ImportTaskStatus = "INITIALIZING"
ImportTaskStatusInitialized ImportTaskStatus = "INITIALIZED"
ImportTaskStatusPending ImportTaskStatus = "PENDING"
ImportTaskStatusComplete ImportTaskStatus = "COMPLETE"
ImportTaskStatusFailed ImportTaskStatus = "FAILED"
ImportTaskStatusDeleting ImportTaskStatus = "DELETING"
)
// Values returns all known values for ImportTaskStatus. 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 (ImportTaskStatus) Values() []ImportTaskStatus {
return []ImportTaskStatus{
"INITIALIZING",
"INITIALIZED",
"PENDING",
"COMPLETE",
"FAILED",
"DELETING",
}
}
type LogLevel string
// Enum values for LogLevel
const (
LogLevelInfo LogLevel = "INFO"
LogLevelError LogLevel = "ERROR"
LogLevelDisabled LogLevel = "DISABLED"
)
// Values returns all known values for LogLevel. 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 (LogLevel) Values() []LogLevel {
return []LogLevel{
"INFO",
"ERROR",
"DISABLED",
}
}
type MessageType string
// Enum values for MessageType
const (
MessageTypeCustomCommandIdNotify MessageType = "CUSTOM_COMMAND_ID_NOTIFY"
MessageTypeCustomCommandIdGet MessageType = "CUSTOM_COMMAND_ID_GET"
MessageTypeCustomCommandIdSet MessageType = "CUSTOM_COMMAND_ID_SET"
MessageTypeCustomCommandIdResp MessageType = "CUSTOM_COMMAND_ID_RESP"
)
// Values returns all known values for MessageType. 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 (MessageType) Values() []MessageType {
return []MessageType{
"CUSTOM_COMMAND_ID_NOTIFY",
"CUSTOM_COMMAND_ID_GET",
"CUSTOM_COMMAND_ID_SET",
"CUSTOM_COMMAND_ID_RESP",
}
}
type MulticastFrameInfo string
// Enum values for MulticastFrameInfo
const (
MulticastFrameInfoEnabled MulticastFrameInfo = "ENABLED"
MulticastFrameInfoDisabled MulticastFrameInfo = "DISABLED"
)
// Values returns all known values for MulticastFrameInfo. 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 (MulticastFrameInfo) Values() []MulticastFrameInfo {
return []MulticastFrameInfo{
"ENABLED",
"DISABLED",
}
}
type OnboardStatus string
// Enum values for OnboardStatus
const (
OnboardStatusInitialized OnboardStatus = "INITIALIZED"
OnboardStatusPending OnboardStatus = "PENDING"
OnboardStatusOnboarded OnboardStatus = "ONBOARDED"
OnboardStatusFailed OnboardStatus = "FAILED"
)
// Values returns all known values for OnboardStatus. 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 (OnboardStatus) Values() []OnboardStatus {
return []OnboardStatus{
"INITIALIZED",
"PENDING",
"ONBOARDED",
"FAILED",
}
}
type PartnerType string
// Enum values for PartnerType
const (
PartnerTypeSidewalk PartnerType = "Sidewalk"
)
// Values returns all known values for PartnerType. 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 (PartnerType) Values() []PartnerType {
return []PartnerType{
"Sidewalk",
}
}
type PositionConfigurationFec string
// Enum values for PositionConfigurationFec
const (
PositionConfigurationFecRose PositionConfigurationFec = "ROSE"
PositionConfigurationFecNone PositionConfigurationFec = "NONE"
)
// Values returns all known values for PositionConfigurationFec. 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 (PositionConfigurationFec) Values() []PositionConfigurationFec {
return []PositionConfigurationFec{
"ROSE",
"NONE",
}
}
type PositionConfigurationStatus string
// Enum values for PositionConfigurationStatus
const (
PositionConfigurationStatusEnabled PositionConfigurationStatus = "Enabled"
PositionConfigurationStatusDisabled PositionConfigurationStatus = "Disabled"
)
// Values returns all known values for PositionConfigurationStatus. 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 (PositionConfigurationStatus) Values() []PositionConfigurationStatus {
return []PositionConfigurationStatus{
"Enabled",
"Disabled",
}
}
type PositioningConfigStatus string
// Enum values for PositioningConfigStatus
const (
PositioningConfigStatusEnabled PositioningConfigStatus = "Enabled"
PositioningConfigStatusDisabled PositioningConfigStatus = "Disabled"
)
// Values returns all known values for PositioningConfigStatus. 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 (PositioningConfigStatus) Values() []PositioningConfigStatus {
return []PositioningConfigStatus{
"Enabled",
"Disabled",
}
}
type PositionResourceType string
// Enum values for PositionResourceType
const (
PositionResourceTypeWirelessDevice PositionResourceType = "WirelessDevice"
PositionResourceTypeWirelessGateway PositionResourceType = "WirelessGateway"
)
// Values returns all known values for PositionResourceType. 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 (PositionResourceType) Values() []PositionResourceType {
return []PositionResourceType{
"WirelessDevice",
"WirelessGateway",
}
}
type PositionSolverProvider string
// Enum values for PositionSolverProvider
const (
PositionSolverProviderSemtech PositionSolverProvider = "Semtech"
)
// Values returns all known values for PositionSolverProvider. 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 (PositionSolverProvider) Values() []PositionSolverProvider {
return []PositionSolverProvider{
"Semtech",
}
}
type PositionSolverType string
// Enum values for PositionSolverType
const (
PositionSolverTypeGnss PositionSolverType = "GNSS"
)
// Values returns all known values for PositionSolverType. 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 (PositionSolverType) Values() []PositionSolverType {
return []PositionSolverType{
"GNSS",
}
}
type SigningAlg string
// Enum values for SigningAlg
const (
SigningAlgEd25519 SigningAlg = "Ed25519"
SigningAlgP256r1 SigningAlg = "P256r1"
)
// Values returns all known values for SigningAlg. 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 (SigningAlg) Values() []SigningAlg {
return []SigningAlg{
"Ed25519",
"P256r1",
}
}
type SupportedRfRegion string
// Enum values for SupportedRfRegion
const (
SupportedRfRegionEu868 SupportedRfRegion = "EU868"
SupportedRfRegionUs915 SupportedRfRegion = "US915"
SupportedRfRegionAu915 SupportedRfRegion = "AU915"
SupportedRfRegionAs9231 SupportedRfRegion = "AS923-1"
SupportedRfRegionAs9232 SupportedRfRegion = "AS923-2"
SupportedRfRegionAs9233 SupportedRfRegion = "AS923-3"
SupportedRfRegionAs9234 SupportedRfRegion = "AS923-4"
SupportedRfRegionEu433 SupportedRfRegion = "EU433"
SupportedRfRegionCn470 SupportedRfRegion = "CN470"
SupportedRfRegionCn779 SupportedRfRegion = "CN779"
SupportedRfRegionRu864 SupportedRfRegion = "RU864"
SupportedRfRegionKr920 SupportedRfRegion = "KR920"
SupportedRfRegionIn865 SupportedRfRegion = "IN865"
)
// Values returns all known values for SupportedRfRegion. 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 (SupportedRfRegion) Values() []SupportedRfRegion {
return []SupportedRfRegion{
"EU868",
"US915",
"AU915",
"AS923-1",
"AS923-2",
"AS923-3",
"AS923-4",
"EU433",
"CN470",
"CN779",
"RU864",
"KR920",
"IN865",
}
}
type WirelessDeviceEvent string
// Enum values for WirelessDeviceEvent
const (
WirelessDeviceEventJoin WirelessDeviceEvent = "Join"
WirelessDeviceEventRejoin WirelessDeviceEvent = "Rejoin"
WirelessDeviceEventUplinkData WirelessDeviceEvent = "Uplink_Data"
WirelessDeviceEventDownlinkData WirelessDeviceEvent = "Downlink_Data"
WirelessDeviceEventRegistration WirelessDeviceEvent = "Registration"
)
// Values returns all known values for WirelessDeviceEvent. 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 (WirelessDeviceEvent) Values() []WirelessDeviceEvent {
return []WirelessDeviceEvent{
"Join",
"Rejoin",
"Uplink_Data",
"Downlink_Data",
"Registration",
}
}
type WirelessDeviceFrameInfo string
// Enum values for WirelessDeviceFrameInfo
const (
WirelessDeviceFrameInfoEnabled WirelessDeviceFrameInfo = "ENABLED"
WirelessDeviceFrameInfoDisabled WirelessDeviceFrameInfo = "DISABLED"
)
// Values returns all known values for WirelessDeviceFrameInfo. 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 (WirelessDeviceFrameInfo) Values() []WirelessDeviceFrameInfo {
return []WirelessDeviceFrameInfo{
"ENABLED",
"DISABLED",
}
}
type WirelessDeviceIdType string
// Enum values for WirelessDeviceIdType
const (
WirelessDeviceIdTypeWirelessDeviceId WirelessDeviceIdType = "WirelessDeviceId"
WirelessDeviceIdTypeDevEui WirelessDeviceIdType = "DevEui"
WirelessDeviceIdTypeThingName WirelessDeviceIdType = "ThingName"
WirelessDeviceIdTypeSidewalkManufacturingSn WirelessDeviceIdType = "SidewalkManufacturingSn"
)
// Values returns all known values for WirelessDeviceIdType. 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 (WirelessDeviceIdType) Values() []WirelessDeviceIdType {
return []WirelessDeviceIdType{
"WirelessDeviceId",
"DevEui",
"ThingName",
"SidewalkManufacturingSn",
}
}
type WirelessDeviceSidewalkStatus string
// Enum values for WirelessDeviceSidewalkStatus
const (
WirelessDeviceSidewalkStatusProvisioned WirelessDeviceSidewalkStatus = "PROVISIONED"
WirelessDeviceSidewalkStatusRegistered WirelessDeviceSidewalkStatus = "REGISTERED"
WirelessDeviceSidewalkStatusActivated WirelessDeviceSidewalkStatus = "ACTIVATED"
WirelessDeviceSidewalkStatusUnknown WirelessDeviceSidewalkStatus = "UNKNOWN"
)
// Values returns all known values for WirelessDeviceSidewalkStatus. 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 (WirelessDeviceSidewalkStatus) Values() []WirelessDeviceSidewalkStatus {
return []WirelessDeviceSidewalkStatus{
"PROVISIONED",
"REGISTERED",
"ACTIVATED",
"UNKNOWN",
}
}
type WirelessDeviceType string
// Enum values for WirelessDeviceType
const (
WirelessDeviceTypeSidewalk WirelessDeviceType = "Sidewalk"
WirelessDeviceTypeLoRaWAN WirelessDeviceType = "LoRaWAN"
)
// Values returns all known values for WirelessDeviceType. 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 (WirelessDeviceType) Values() []WirelessDeviceType {
return []WirelessDeviceType{
"Sidewalk",
"LoRaWAN",
}
}
type WirelessGatewayEvent string
// Enum values for WirelessGatewayEvent
const (
WirelessGatewayEventCupsRequest WirelessGatewayEvent = "CUPS_Request"
WirelessGatewayEventCertificate WirelessGatewayEvent = "Certificate"
)
// Values returns all known values for WirelessGatewayEvent. 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 (WirelessGatewayEvent) Values() []WirelessGatewayEvent {
return []WirelessGatewayEvent{
"CUPS_Request",
"Certificate",
}
}
type WirelessGatewayIdType string
// Enum values for WirelessGatewayIdType
const (
WirelessGatewayIdTypeGatewayEui WirelessGatewayIdType = "GatewayEui"
WirelessGatewayIdTypeWirelessGatewayId WirelessGatewayIdType = "WirelessGatewayId"
WirelessGatewayIdTypeThingName WirelessGatewayIdType = "ThingName"
)
// Values returns all known values for WirelessGatewayIdType. 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 (WirelessGatewayIdType) Values() []WirelessGatewayIdType {
return []WirelessGatewayIdType{
"GatewayEui",
"WirelessGatewayId",
"ThingName",
}
}
type WirelessGatewayServiceType string
// Enum values for WirelessGatewayServiceType
const (
WirelessGatewayServiceTypeCups WirelessGatewayServiceType = "CUPS"
WirelessGatewayServiceTypeLns WirelessGatewayServiceType = "LNS"
)
// Values returns all known values for WirelessGatewayServiceType. 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 (WirelessGatewayServiceType) Values() []WirelessGatewayServiceType {
return []WirelessGatewayServiceType{
"CUPS",
"LNS",
}
}
type WirelessGatewayTaskDefinitionType string
// Enum values for WirelessGatewayTaskDefinitionType
const (
WirelessGatewayTaskDefinitionTypeUpdate WirelessGatewayTaskDefinitionType = "UPDATE"
)
// Values returns all known values for WirelessGatewayTaskDefinitionType. 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 (WirelessGatewayTaskDefinitionType) Values() []WirelessGatewayTaskDefinitionType {
return []WirelessGatewayTaskDefinitionType{
"UPDATE",
}
}
type WirelessGatewayTaskStatus string
// Enum values for WirelessGatewayTaskStatus
const (
WirelessGatewayTaskStatusPending WirelessGatewayTaskStatus = "PENDING"
WirelessGatewayTaskStatusInProgress WirelessGatewayTaskStatus = "IN_PROGRESS"
WirelessGatewayTaskStatusFirstRetry WirelessGatewayTaskStatus = "FIRST_RETRY"
WirelessGatewayTaskStatusSecondRetry WirelessGatewayTaskStatus = "SECOND_RETRY"
WirelessGatewayTaskStatusCompleted WirelessGatewayTaskStatus = "COMPLETED"
WirelessGatewayTaskStatusFailed WirelessGatewayTaskStatus = "FAILED"
)
// Values returns all known values for WirelessGatewayTaskStatus. 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 (WirelessGatewayTaskStatus) Values() []WirelessGatewayTaskStatus {
return []WirelessGatewayTaskStatus{
"PENDING",
"IN_PROGRESS",
"FIRST_RETRY",
"SECOND_RETRY",
"COMPLETED",
"FAILED",
}
}
type WirelessGatewayType string
// Enum values for WirelessGatewayType
const (
WirelessGatewayTypeLoRaWAN WirelessGatewayType = "LoRaWAN"
)
// Values returns all known values for WirelessGatewayType. 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 (WirelessGatewayType) Values() []WirelessGatewayType {
return []WirelessGatewayType{
"LoRaWAN",
}
}
| 825 |
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"
)
// User does not have permission 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 }
// Adding, 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 }
// An unexpected error occurred while processing a request.
type InternalServerException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalServerException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServerException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServerException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServerException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// Resource does not exist.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
ResourceType *string
noSmithyDocumentSerde
}
func (e *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request was denied because it exceeded the allowed API request rate.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ThrottlingException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ThrottlingException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ThrottlingException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ThrottlingException"
}
return *e.ErrorCodeOverride
}
func (e *ThrottlingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request was denied because the resource can't have any more tags.
type TooManyTagsException struct {
Message *string
ErrorCodeOverride *string
ResourceName *string
noSmithyDocumentSerde
}
func (e *TooManyTagsException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TooManyTagsException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TooManyTagsException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TooManyTagsException"
}
return *e.ErrorCodeOverride
}
func (e *TooManyTagsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The input did not meet the specified constraints.
type ValidationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ValidationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationException"
}
return *e.ErrorCodeOverride
}
func (e *ValidationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 199 |
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"
)
// ABP device object for LoRaWAN specification v1.0.x
type AbpV1_0_x struct {
// The DevAddr value.
DevAddr *string
// The FCnt init value.
FCntStart *int32
// Session keys for ABP v1.0.x
SessionKeys *SessionKeysAbpV1_0_x
noSmithyDocumentSerde
}
// ABP device object for LoRaWAN specification v1.1
type AbpV1_1 struct {
// The DevAddr value.
DevAddr *string
// The FCnt init value.
FCntStart *int32
// Session keys for ABP v1.1
SessionKeys *SessionKeysAbpV1_1
noSmithyDocumentSerde
}
// The accuracy of the estimated position in meters. An empty value indicates that
// no position data is available. A value of ‘0.0’ value indicates that position
// data is available. This data corresponds to the position information that you
// specified instead of the position computed by solver.
type Accuracy struct {
// The horizontal accuracy of the estimated position, which is the difference
// between the estimated location and the actual device location.
HorizontalAccuracy *float32
// The vertical accuracy of the estimated position, which is the difference
// between the estimated altitude and actual device latitude in meters.
VerticalAccuracy *float32
noSmithyDocumentSerde
}
// LoRaWAN application configuration, which can be used to perform geolocation.
type ApplicationConfig struct {
// The name of the position data destination that describes the AWS IoT rule that
// processes the device's position data for use by AWS IoT Core for LoRaWAN.
DestinationName *string
// The Fport value.
FPort *int32
// Application type, which can be specified to obtain real-time position
// information of your LoRaWAN device.
Type ApplicationConfigType
noSmithyDocumentSerde
}
// Beaconing parameters for configuring the wireless gateways.
type Beaconing struct {
// The data rate for gateways that are sending the beacons.
DataRate *int32
// The frequency list for the gateways to send the beacons.
Frequencies []int32
noSmithyDocumentSerde
}
// CDMA local ID information, which corresponds to the local identification
// parameters of a CDMA cell.
type CdmaLocalId struct {
// CDMA channel information.
//
// This member is required.
CdmaChannel *int32
// Pseudo-noise offset, which is a characteristic of the signal from a cell on a
// radio tower.
//
// This member is required.
PnOffset *int32
noSmithyDocumentSerde
}
// CDMA object for network measurement reports.
type CdmaNmrObj struct {
// CDMA channel information.
//
// This member is required.
CdmaChannel *int32
// Pseudo-noise offset, which is a characteristic of the signal from a cell on a
// radio tower.
//
// This member is required.
PnOffset *int32
// CDMA base station ID (BSID).
BaseStationId *int32
// Transmit power level of the pilot signal, measured in dBm (decibel-milliwatts).
PilotPower *int32
noSmithyDocumentSerde
}
// CDMA (Code-division multiple access) object.
type CdmaObj struct {
// CDMA base station ID (BSID).
//
// This member is required.
BaseStationId *int32
// CDMA network ID (NID).
//
// This member is required.
NetworkId *int32
// CDMA system ID (SID).
//
// This member is required.
SystemId *int32
// CDMA base station latitude in degrees.
BaseLat *float32
// CDMA base station longitude in degrees.
BaseLng *float32
// CDMA local identification (local ID) parameters.
CdmaLocalId *CdmaLocalId
// CDMA network measurement reports.
CdmaNmr []CdmaNmrObj
// Transmit power level of the pilot signal, measured in dBm (decibel-milliwatts).
PilotPower *int32
// CDMA registration zone (RZ).
RegistrationZone *int32
noSmithyDocumentSerde
}
// The cell towers that were used to perform the measurements.
type CellTowers struct {
// CDMA object information.
Cdma []CdmaObj
// GSM object information.
Gsm []GsmObj
// LTE object information.
Lte []LteObj
// TD-SCDMA object information.
Tdscdma []TdscdmaObj
// WCDMA object information.
Wcdma []WcdmaObj
noSmithyDocumentSerde
}
// List of sidewalk certificates.
type CertificateList struct {
// The certificate chain algorithm provided by sidewalk.
//
// This member is required.
SigningAlg SigningAlg
// The value of the chosen sidewalk certificate.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// Connection status event configuration object for enabling or disabling topic.
type ConnectionStatusEventConfiguration struct {
// Connection status event configuration object for enabling or disabling LoRaWAN
// related event topics.
LoRaWAN *LoRaWANConnectionStatusEventNotificationConfigurations
// Denotes whether the wireless gateway ID connection status event topic is
// enabled or disabled.
WirelessGatewayIdEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Connection status resource type event configuration object for enabling or
// disabling topic.
type ConnectionStatusResourceTypeEventConfiguration struct {
// Connection status resource type event configuration object for enabling or
// disabling LoRaWAN related event topics.
LoRaWAN *LoRaWANConnectionStatusResourceTypeEventConfiguration
noSmithyDocumentSerde
}
// The device attestation key (DAK) information.
type DakCertificateMetadata struct {
// The certificate ID for the DAK.
//
// This member is required.
CertificateId *string
// The advertised product ID (APID) that's used for pre-production and production
// applications.
ApId *string
// The device type ID that's used for prototyping applications.
DeviceTypeId *string
// Whether factory support has been enabled.
FactorySupport *bool
// The maximum number of signatures that the DAK can sign. A value of -1 indicates
// that there's no device limit.
MaxAllowedSignature *int32
noSmithyDocumentSerde
}
// Describes a destination.
type Destinations struct {
// The Amazon Resource Name of the resource.
Arn *string
// The description of the resource.
Description *string
// The rule name or topic rule to send messages to.
Expression *string
// The type of value in Expression .
ExpressionType ExpressionType
// The name of the resource.
Name *string
// The ARN of the IAM Role that authorizes the destination.
RoleArn *string
noSmithyDocumentSerde
}
// Describes a device profile.
type DeviceProfile struct {
// The Amazon Resource Name of the resource.
Arn *string
// The ID of the device profile.
Id *string
// The name of the resource.
Name *string
noSmithyDocumentSerde
}
// Device registration state event configuration object for enabling and disabling
// relevant topics.
type DeviceRegistrationStateEventConfiguration struct {
// Device registration state event configuration object for enabling or disabling
// Sidewalk related event topics.
Sidewalk *SidewalkEventNotificationConfigurations
// Denotes whether the wireless device ID device registration state event topic is
// enabled or disabled.
WirelessDeviceIdEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Device registration state resource type event configuration object for enabling
// or disabling topic.
type DeviceRegistrationStateResourceTypeEventConfiguration struct {
// Device registration resource type state event configuration object for enabling
// or disabling Sidewalk related event topics.
Sidewalk *SidewalkResourceTypeEventConfiguration
noSmithyDocumentSerde
}
// The message in the downlink queue.
type DownlinkQueueMessage struct {
// LoRaWAN router info.
LoRaWAN *LoRaWANSendDataToDevice
// The message ID assigned by IoT Wireless to each downlink message, which helps
// identify the message.
MessageId *string
// The time at which Iot Wireless received the downlink message.
ReceivedAt *string
// The transmit mode to use for sending data to the wireless device. This can be 0
// for UM (unacknowledge mode) or 1 for AM (acknowledge mode).
TransmitMode *int32
noSmithyDocumentSerde
}
// Event configuration object for a single resource.
type EventConfigurationItem struct {
// Object of all event configurations and the status of the event topics.
Events *EventNotificationItemConfigurations
// Resource identifier opted in for event messaging.
Identifier *string
// Identifier type of the particular resource identifier for event configuration.
IdentifierType IdentifierType
// Partner type of the resource if the identifier type is PartnerAccountId.
PartnerType EventNotificationPartnerType
noSmithyDocumentSerde
}
// Object of all event configurations and the status of the event topics.
type EventNotificationItemConfigurations struct {
// Connection status event configuration for an event configuration item.
ConnectionStatus *ConnectionStatusEventConfiguration
// Device registration state event configuration for an event configuration item.
DeviceRegistrationState *DeviceRegistrationStateEventConfiguration
// Join event configuration for an event configuration item.
Join *JoinEventConfiguration
// Message delivery status event configuration for an event configuration item.
MessageDeliveryStatus *MessageDeliveryStatusEventConfiguration
// Proximity event configuration for an event configuration item.
Proximity *ProximityEventConfiguration
noSmithyDocumentSerde
}
// List of FPort assigned for different LoRaWAN application packages to use
type FPorts struct {
// Optional LoRaWAN application information, which can be used for geolocation.
Applications []ApplicationConfig
// The Fport value.
ClockSync *int32
// The Fport value.
Fuota *int32
// The Fport value.
Multicast *int32
// FPort values for the GNSS, stream, and ClockSync functions of the positioning
// information.
Positioning *Positioning
noSmithyDocumentSerde
}
// A FUOTA task.
type FuotaTask struct {
// The arn of a FUOTA task.
Arn *string
// The ID of a FUOTA task.
Id *string
// The name of a FUOTA task.
Name *string
noSmithyDocumentSerde
}
// Gateway list item object that specifies the frequency and list of gateways for
// which the downlink message should be sent.
type GatewayListItem struct {
// The frequency to use for the gateways when sending a downlink message to the
// wireless device.
//
// This member is required.
DownlinkFrequency *int32
// The ID of the wireless gateways that you want to add to the list of gateways
// when sending downlink messages.
//
// This member is required.
GatewayId *string
noSmithyDocumentSerde
}
// Global identity information.
type GlobalIdentity struct {
// GERAN (GSM EDGE Radio Access Network) cell global identifier.
//
// This member is required.
GeranCid *int32
// Location area code of the global identity.
//
// This member is required.
Lac *int32
noSmithyDocumentSerde
}
// Global navigation satellite system (GNSS) object used for positioning.
type Gnss struct {
// Payload that contains the GNSS scan result, or NAV message, in hexadecimal
// notation.
//
// This member is required.
Payload *string
// Optional assistance altitude, which is the altitude of the device at capture
// time, specified in meters above the WGS84 reference ellipsoid.
AssistAltitude *float32
// Optional assistance position information, specified using latitude and
// longitude values in degrees. The coordinates are inside the WGS84 reference
// frame.
AssistPosition []float32
// Optional parameter that gives an estimate of the time when the GNSS scan
// information is taken, in seconds GPS time (GPST). If capture time is not
// specified, the local server time is used.
CaptureTime *float32
// Optional value that gives the capture time estimate accuracy, in seconds. If
// capture time accuracy is not specified, default value of 300 is used.
CaptureTimeAccuracy *float32
// Optional parameter that forces 2D solve, which modifies the positioning
// algorithm to a 2D solution problem. When this parameter is specified, the
// assistance altitude should have an accuracy of at least 10 meters.
Use2DSolver bool
noSmithyDocumentSerde
}
// GSM local ID information, which corresponds to the local identification
// parameters of a GSM cell.
type GsmLocalId struct {
// GSM broadcast control channel.
//
// This member is required.
Bcch *int32
// GSM base station identity code (BSIC).
//
// This member is required.
Bsic *int32
noSmithyDocumentSerde
}
// GSM object for network measurement reports.
type GsmNmrObj struct {
// GSM broadcast control channel.
//
// This member is required.
Bcch *int32
// GSM base station identity code (BSIC).
//
// This member is required.
Bsic *int32
// Global identity information of the GSM object.
GlobalIdentity *GlobalIdentity
// Rx level, which is the received signal power, measured in dBm
// (decibel-milliwatts).
RxLevel *int32
noSmithyDocumentSerde
}
// GSM object.
type GsmObj struct {
// GERAN (GSM EDGE Radio Access Network) Cell Global Identifier.
//
// This member is required.
GeranCid *int32
// Location area code.
//
// This member is required.
Lac *int32
// Mobile Country Code.
//
// This member is required.
Mcc *int32
// Mobile Network Code.
//
// This member is required.
Mnc *int32
// GSM local identification (local ID) information.
GsmLocalId *GsmLocalId
// GSM object for network measurement reports.
GsmNmr []GsmNmrObj
// Timing advance value, which corresponds to the length of time a signal takes to
// reach the base station from a mobile phone.
GsmTimingAdvance *int32
// Rx level, which is the received signal power, measured in dBm
// (decibel-milliwatts).
RxLevel *int32
noSmithyDocumentSerde
}
// Information about a Sidewalk device that has been added to an import task.
type ImportedSidewalkDevice struct {
// The time at which the status information was last updated.
LastUpdateTime *time.Time
// The onboarding status of the Sidewalk device in the import task.
OnboardingStatus OnboardStatus
// The reason for the onboarding status information for the Sidewalk device.
OnboardingStatusReason *string
// The Sidewalk manufacturing serial number (SMSN) of the Sidewalk device.
SidewalkManufacturingSn *string
noSmithyDocumentSerde
}
// Information about a wireless device that has been added to an import task.
type ImportedWirelessDevice struct {
// The Sidewalk-related information about a device that has been added to an
// import task.
Sidewalk *ImportedSidewalkDevice
noSmithyDocumentSerde
}
// IP address used for resolving device location.
type Ip struct {
// IP address information.
//
// This member is required.
IpAddress *string
noSmithyDocumentSerde
}
// Join event configuration object for enabling or disabling topic.
type JoinEventConfiguration struct {
// Join event configuration object for enabling or disabling LoRaWAN related event
// topics.
LoRaWAN *LoRaWANJoinEventNotificationConfigurations
// Denotes whether the wireless device ID join event topic is enabled or disabled.
WirelessDeviceIdEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Join resource type event configuration object for enabling or disabling topic.
type JoinResourceTypeEventConfiguration struct {
// Join resource type event configuration object for enabling or disabling LoRaWAN
// related event topics.
LoRaWAN *LoRaWANJoinResourceTypeEventConfiguration
noSmithyDocumentSerde
}
// Object for LoRaWAN connection status resource type event configuration.
type LoRaWANConnectionStatusEventNotificationConfigurations struct {
// Denotes whether the gateway EUI connection status event topic is enabled or
// disabled.
GatewayEuiEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Object for LoRaWAN connection status resource type event configuration.
type LoRaWANConnectionStatusResourceTypeEventConfiguration struct {
// Denotes whether the wireless gateway connection status event topic is enabled
// or disabled.
WirelessGatewayEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// LoRaWAN object for create functions.
type LoRaWANDevice struct {
// LoRaWAN object for create APIs
AbpV1_0_x *AbpV1_0_x
// ABP device object for create APIs for v1.1
AbpV1_1 *AbpV1_1
// The DevEUI value.
DevEui *string
// The ID of the device profile for the new wireless device.
DeviceProfileId *string
// List of FPort assigned for different LoRaWAN application packages to use
FPorts *FPorts
// OTAA device object for create APIs for v1.0.x
OtaaV1_0_x *OtaaV1_0_x
// OTAA device object for v1.1 for create APIs
OtaaV1_1 *OtaaV1_1
// The ID of the service profile.
ServiceProfileId *string
noSmithyDocumentSerde
}
// LoRaWAN device metatdata.
type LoRaWANDeviceMetadata struct {
// The DataRate value.
DataRate *int32
// The DevEUI value.
DevEui *string
// The FPort value.
FPort *int32
// The device's channel frequency in Hz.
Frequency *int32
// Information about the gateways accessed by the device.
Gateways []LoRaWANGatewayMetadata
// The date and time of the metadata.
Timestamp *string
noSmithyDocumentSerde
}
// LoRaWANDeviceProfile object.
type LoRaWANDeviceProfile struct {
// The ClassBTimeout value.
ClassBTimeout *int32
// The ClassCTimeout value.
ClassCTimeout *int32
// The list of values that make up the FactoryPresetFreqs value.
FactoryPresetFreqsList []int32
// The MAC version (such as OTAA 1.1 or OTAA 1.0.3) to use with this device
// profile.
MacVersion *string
// The MaxDutyCycle value.
MaxDutyCycle *int32
// The MaxEIRP value.
MaxEirp *int32
// The PingSlotDR value.
PingSlotDr *int32
// The PingSlotFreq value.
PingSlotFreq *int32
// The PingSlotPeriod value.
PingSlotPeriod *int32
// The version of regional parameters.
RegParamsRevision *string
// The frequency band (RFRegion) value.
RfRegion *string
// The RXDataRate2 value.
RxDataRate2 *int32
// The RXDelay1 value.
RxDelay1 *int32
// The RXDROffset1 value.
RxDrOffset1 *int32
// The RXFreq2 value.
RxFreq2 *int32
// The Supports32BitFCnt value.
Supports32BitFCnt bool
// The SupportsClassB value.
SupportsClassB bool
// The SupportsClassC value.
SupportsClassC bool
// The SupportsJoin value.
SupportsJoin *bool
noSmithyDocumentSerde
}
// The LoRaWAN information used with a FUOTA task.
type LoRaWANFuotaTask struct {
// Supported RfRegions
RfRegion SupportedRfRegion
noSmithyDocumentSerde
}
// The LoRaWAN information returned from getting a FUOTA task.
type LoRaWANFuotaTaskGetInfo struct {
// The frequency band (RFRegion) value.
RfRegion *string
// Start time of a FUOTA task.
StartTime *time.Time
noSmithyDocumentSerde
}
// LoRaWANGateway object.
type LoRaWANGateway struct {
// Beaconing object information, which consists of the data rate and frequency
// parameters.
Beaconing *Beaconing
// The gateway's EUI value.
GatewayEui *string
// A list of JoinEuiRange used by LoRa gateways to filter LoRa frames.
JoinEuiFilters [][]string
// The MaxEIRP value.
MaxEirp *float32
// A list of NetId values that are used by LoRa gateways to filter the uplink
// frames.
NetIdFilters []string
// The frequency band (RFRegion) value.
RfRegion *string
// A list of integer indicating which sub bands are supported by LoRa gateway.
SubBands []int32
noSmithyDocumentSerde
}
// LoRaWANGatewayCurrentVersion object.
type LoRaWANGatewayCurrentVersion struct {
// The version of the gateways that should receive the update.
CurrentVersion *LoRaWANGatewayVersion
noSmithyDocumentSerde
}
// LoRaWAN gateway metatdata.
type LoRaWANGatewayMetadata struct {
// The gateway's EUI value.
GatewayEui *string
// The RSSI value.
Rssi *float64
// The SNR value.
Snr *float64
noSmithyDocumentSerde
}
// LoRaWANGatewayVersion object.
type LoRaWANGatewayVersion struct {
// The model number of the wireless gateway.
Model *string
// The version of the wireless gateway firmware.
PackageVersion *string
// The basic station version of the wireless gateway.
Station *string
noSmithyDocumentSerde
}
// LoRaWANGetServiceProfileInfo object.
type LoRaWANGetServiceProfileInfo struct {
// The AddGWMetaData value.
AddGwMetadata bool
// The ChannelMask value.
ChannelMask *string
// The DevStatusReqFreq value.
DevStatusReqFreq *int32
// The DLBucketSize value.
DlBucketSize *int32
// The DLRate value.
DlRate *int32
// The DLRatePolicy value.
DlRatePolicy *string
// The DRMax value.
DrMax int32
// The DRMin value.
DrMin int32
// The HRAllowed value that describes whether handover roaming is allowed.
HrAllowed bool
// The MinGwDiversity value.
MinGwDiversity *int32
// The NwkGeoLoc value.
NwkGeoLoc bool
// The PRAllowed value that describes whether passive roaming is allowed.
PrAllowed bool
// The RAAllowed value that describes whether roaming activation is allowed.
RaAllowed bool
// The ReportDevStatusBattery value.
ReportDevStatusBattery bool
// The ReportDevStatusMargin value.
ReportDevStatusMargin bool
// The TargetPER value.
TargetPer int32
// The ULBucketSize value.
UlBucketSize *int32
// The ULRate value.
UlRate *int32
// The ULRatePolicy value.
UlRatePolicy *string
noSmithyDocumentSerde
}
// Object for LoRaWAN join resource type event configuration.
type LoRaWANJoinEventNotificationConfigurations struct {
// Denotes whether the Dev EUI join event topic is enabled or disabled.
DevEuiEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Object for LoRaWAN join resource type event configuration.
type LoRaWANJoinResourceTypeEventConfiguration struct {
// Denotes whether the wireless device join event topic is enabled or disabled.
WirelessDeviceEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// LoRaWAN object for list functions.
type LoRaWANListDevice struct {
// The DevEUI value.
DevEui *string
noSmithyDocumentSerde
}
// The LoRaWAN information that is to be used with the multicast group.
type LoRaWANMulticast struct {
// DlClass for LoRaWAM, valid values are ClassB and ClassC.
DlClass DlClass
// Supported RfRegions
RfRegion SupportedRfRegion
noSmithyDocumentSerde
}
// The LoRaWAN information that is to be returned from getting multicast group
// information.
type LoRaWANMulticastGet struct {
// DlClass for LoRaWAM, valid values are ClassB and ClassC.
DlClass DlClass
// Number of devices that are associated to the multicast group.
NumberOfDevicesInGroup *int32
// Number of devices that are requested to be associated with the multicast group.
NumberOfDevicesRequested *int32
// Supported RfRegions
RfRegion SupportedRfRegion
noSmithyDocumentSerde
}
// The metadata information of the LoRaWAN multicast group.
type LoRaWANMulticastMetadata struct {
// The Fport value.
FPort *int32
noSmithyDocumentSerde
}
// The LoRaWAN information used with the multicast session.
type LoRaWANMulticastSession struct {
// Downlink data rate.
DlDr *int32
// Downlink frequency.
DlFreq *int32
// The PingSlotPeriod value.
PingSlotPeriod *int32
// Timestamp of when the multicast group session is to start.
SessionStartTime *time.Time
// How long before a multicast group session is to timeout.
SessionTimeout *int32
noSmithyDocumentSerde
}
// LoRaWAN router info.
type LoRaWANSendDataToDevice struct {
// The Fport value.
FPort *int32
// Choose the gateways that you want to use for the downlink data traffic when the
// wireless device is running in class B or class C mode.
ParticipatingGateways *ParticipatingGateways
noSmithyDocumentSerde
}
// LoRaWANServiceProfile object.
type LoRaWANServiceProfile struct {
// The AddGWMetaData value.
AddGwMetadata bool
// The DrMax value.
DrMax *int32
// The DrMin value.
DrMin *int32
// The PRAllowed value that describes whether passive roaming is allowed.
PrAllowed bool
// The RAAllowed value that describes whether roaming activation is allowed.
RaAllowed bool
noSmithyDocumentSerde
}
// The LoRaWAN information used to start a FUOTA task.
type LoRaWANStartFuotaTask struct {
// Start time of a FUOTA task.
StartTime *time.Time
noSmithyDocumentSerde
}
// LoRaWAN object for update functions.
type LoRaWANUpdateDevice struct {
// ABP device object for update APIs for v1.0.x
AbpV1_0_x *UpdateAbpV1_0_x
// ABP device object for update APIs for v1.1
AbpV1_1 *UpdateAbpV1_1
// The ID of the device profile for the wireless device.
DeviceProfileId *string
// FPorts object for the positioning information of the device.
FPorts *UpdateFPorts
// The ID of the service profile.
ServiceProfileId *string
noSmithyDocumentSerde
}
// LoRaWANUpdateGatewayTaskCreate object.
type LoRaWANUpdateGatewayTaskCreate struct {
// The version of the gateways that should receive the update.
CurrentVersion *LoRaWANGatewayVersion
// The CRC of the signature private key to check.
SigKeyCrc *int64
// The signature used to verify the update firmware.
UpdateSignature *string
// The firmware version to update the gateway to.
UpdateVersion *LoRaWANGatewayVersion
noSmithyDocumentSerde
}
// LoRaWANUpdateGatewayTaskEntry object.
type LoRaWANUpdateGatewayTaskEntry struct {
// The version of the gateways that should receive the update.
CurrentVersion *LoRaWANGatewayVersion
// The firmware version to update the gateway to.
UpdateVersion *LoRaWANGatewayVersion
noSmithyDocumentSerde
}
// LTE local identification (local ID) information.
type LteLocalId struct {
// Evolved universal terrestrial radio access (E-UTRA) absolute radio frequency
// channel number (FCN).
//
// This member is required.
Earfcn *int32
// Physical cell ID.
//
// This member is required.
Pci *int32
noSmithyDocumentSerde
}
// LTE object for network measurement reports.
type LteNmrObj struct {
// E-UTRA (Evolved universal terrestrial Radio Access) absolute radio frequency
// channel Number (EARFCN).
//
// This member is required.
Earfcn *int32
// E-UTRAN (Evolved Universal Terrestrial Radio Access Network) cell global
// identifier (EUTRANCID).
//
// This member is required.
EutranCid *int32
// Physical cell ID.
//
// This member is required.
Pci *int32
// Signal power of the reference signal received, measured in dBm
// (decibel-milliwatts).
Rsrp *int32
// Signal quality of the reference Signal received, measured in decibels (dB).
Rsrq *float32
noSmithyDocumentSerde
}
// LTE object.
type LteObj struct {
// E-UTRAN (Evolved Universal Terrestrial Radio Access Network) Cell Global
// Identifier.
//
// This member is required.
EutranCid *int32
// Mobile Country Code.
//
// This member is required.
Mcc *int32
// Mobile Network Code.
//
// This member is required.
Mnc *int32
// LTE local identification (local ID) information.
LteLocalId *LteLocalId
// LTE object for network measurement reports.
LteNmr []LteNmrObj
// LTE timing advance.
LteTimingAdvance *int32
// Parameter that determines whether the LTE object is capable of supporting NR
// (new radio).
NrCapable bool
// Signal power of the reference signal received, measured in dBm
// (decibel-milliwatts).
Rsrp *int32
// Signal quality of the reference Signal received, measured in decibels (dB).
Rsrq *float32
// LTE tracking area code.
Tac *int32
noSmithyDocumentSerde
}
// Message delivery status event configuration object for enabling and disabling
// relevant topics.
type MessageDeliveryStatusEventConfiguration struct {
// SidewalkEventNotificationConfigurations object, which is the event
// configuration object for Sidewalk-related event topics.
Sidewalk *SidewalkEventNotificationConfigurations
// Denotes whether the wireless device ID message delivery status event topic is
// enabled or disabled.
WirelessDeviceIdEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Message delivery status resource type event configuration object for enabling
// or disabling relevant topic.
type MessageDeliveryStatusResourceTypeEventConfiguration struct {
// Sidewalk resource type event configuration object for enabling or disabling
// topic.
Sidewalk *SidewalkResourceTypeEventConfiguration
noSmithyDocumentSerde
}
// A multicast group.
type MulticastGroup struct {
// The arn of the multicast group.
Arn *string
// The ID of the multicast group.
Id *string
// The name of the multicast group.
Name *string
noSmithyDocumentSerde
}
// A multicast group that is associated with a FUOTA task.
type MulticastGroupByFuotaTask struct {
// The ID of the multicast group.
Id *string
noSmithyDocumentSerde
}
// Wireless metadata that is to be sent to multicast group.
type MulticastWirelessMetadata struct {
// The metadata information of the LoRaWAN multicast group.
LoRaWAN *LoRaWANMulticastMetadata
noSmithyDocumentSerde
}
// Network analyzer configurations.
type NetworkAnalyzerConfigurations struct {
// The Amazon Resource Name of the new resource.
Arn *string
// Name of the network analyzer configuration.
Name *string
noSmithyDocumentSerde
}
// OTAA device object for v1.0.x
type OtaaV1_0_x struct {
// The AppEUI value.
AppEui *string
// The AppKey value.
AppKey *string
// The GenAppKey value.
GenAppKey *string
noSmithyDocumentSerde
}
// OTAA device object for v1.1
type OtaaV1_1 struct {
// The AppKey value.
AppKey *string
// The JoinEUI value.
JoinEui *string
// The NwkKey value.
NwkKey *string
noSmithyDocumentSerde
}
// Specify the list of gateways to which you want to send downlink data traffic
// when the wireless device is running in class B or class C mode.
type ParticipatingGateways struct {
// Indicates whether to send the downlink message in sequential mode or concurrent
// mode, or to use only the chosen gateways from the previous uplink message
// transmission.
//
// This member is required.
DownlinkMode DownlinkMode
// The list of gateways that you want to use for sending the downlink data traffic.
//
// This member is required.
GatewayList []GatewayListItem
// The duration of time for which AWS IoT Core for LoRaWAN will wait before
// transmitting the payload to the next gateway.
//
// This member is required.
TransmissionInterval *int32
noSmithyDocumentSerde
}
// The wrapper for a position configuration.
type PositionConfigurationItem struct {
// The position data destination that describes the AWS IoT rule that processes
// the device's position data for use by AWS IoT Core for LoRaWAN.
Destination *string
// Resource identifier for the position configuration.
ResourceIdentifier *string
// Resource type of the resource for the position configuration.
ResourceType PositionResourceType
// The details of the positioning solver object used to compute the location.
Solvers *PositionSolverDetails
noSmithyDocumentSerde
}
// The FPorts for the position information.
type Positioning struct {
// The Fport value.
ClockSync *int32
// The Fport value.
Gnss *int32
// The Fport value.
Stream *int32
noSmithyDocumentSerde
}
// The wrapper for position solver configurations.
type PositionSolverConfigurations struct {
// The Semtech GNSS solver configuration object.
SemtechGnss *SemtechGnssConfiguration
noSmithyDocumentSerde
}
// The wrapper for position solver details.
type PositionSolverDetails struct {
// The Semtech GNSS solver object details.
SemtechGnss *SemtechGnssDetail
noSmithyDocumentSerde
}
// Proximity event configuration object for enabling and disabling relevant topics.
type ProximityEventConfiguration struct {
// Proximity event configuration object for enabling or disabling Sidewalk related
// event topics.
Sidewalk *SidewalkEventNotificationConfigurations
// Denotes whether the wireless device ID proximity event topic is enabled or
// disabled.
WirelessDeviceIdEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Proximity resource type event configuration object for enabling or disabling
// topic.
type ProximityResourceTypeEventConfiguration struct {
// Proximity resource type event configuration object for enabling and disabling
// wireless device topic.
Sidewalk *SidewalkResourceTypeEventConfiguration
noSmithyDocumentSerde
}
// Information about the Semtech GNSS solver configuration.
type SemtechGnssConfiguration struct {
// Whether forward error correction is enabled.
//
// This member is required.
Fec PositionConfigurationFec
// The status indicating whether the solver is enabled.
//
// This member is required.
Status PositionConfigurationStatus
noSmithyDocumentSerde
}
// Details of the Semtech GNSS solver object.
type SemtechGnssDetail struct {
// Whether forward error correction is enabled.
Fec PositionConfigurationFec
// The vendor of the solver object.
Provider PositionSolverProvider
// The status indicating whether the solver is enabled.
Status PositionConfigurationStatus
// The type of positioning solver used.
Type PositionSolverType
noSmithyDocumentSerde
}
// Information about a service profile.
type ServiceProfile struct {
// The Amazon Resource Name of the resource.
Arn *string
// The ID of the service profile.
Id *string
// The name of the resource.
Name *string
noSmithyDocumentSerde
}
// Session keys for ABP v1.1
type SessionKeysAbpV1_0_x struct {
// The AppSKey value.
AppSKey *string
// The NwkSKey value.
NwkSKey *string
noSmithyDocumentSerde
}
// Session keys for ABP v1.1
type SessionKeysAbpV1_1 struct {
// The AppSKey value.
AppSKey *string
// The FNwkSIntKey value.
FNwkSIntKey *string
// The NwkSEncKey value.
NwkSEncKey *string
// The SNwkSIntKey value.
SNwkSIntKey *string
noSmithyDocumentSerde
}
// Information about a Sidewalk account.
type SidewalkAccountInfo struct {
// The Sidewalk Amazon ID.
AmazonId *string
// The Sidewalk application server private key.
AppServerPrivateKey *string
noSmithyDocumentSerde
}
// Information about a Sidewalk account.
type SidewalkAccountInfoWithFingerprint struct {
// The Sidewalk Amazon ID.
AmazonId *string
// The Amazon Resource Name of the resource.
Arn *string
// The fingerprint of the Sidewalk application server private key.
Fingerprint *string
noSmithyDocumentSerde
}
// Sidewalk object for creating a device profile.
type SidewalkCreateDeviceProfile struct {
noSmithyDocumentSerde
}
// Sidewalk object for creating a wireless device.
type SidewalkCreateWirelessDevice struct {
// The ID of the Sidewalk device profile.
DeviceProfileId *string
noSmithyDocumentSerde
}
// Sidewalk device object.
type SidewalkDevice struct {
// The Sidewalk Amazon ID.
AmazonId *string
// The ID of the Sidewalk device profile.
CertificateId *string
// The sidewalk device certificates for Ed25519 and P256r1.
DeviceCertificates []CertificateList
// The ID of the Sidewalk device profile.
DeviceProfileId *string
// The Sidewalk device private keys that will be used for onboarding the device.
PrivateKeys []CertificateList
// The sidewalk device identification.
SidewalkId *string
// The Sidewalk manufacturing series number.
SidewalkManufacturingSn *string
// The Sidewalk device status, such as provisioned or registered.
Status WirelessDeviceSidewalkStatus
noSmithyDocumentSerde
}
// MetaData for Sidewalk device.
type SidewalkDeviceMetadata struct {
// Sidewalk device battery level.
BatteryLevel BatteryLevel
// Device state defines the device status of sidewalk device.
DeviceState DeviceState
// Sidewalk device status notification.
Event Event
// The RSSI value.
Rssi *int32
noSmithyDocumentSerde
}
// SidewalkEventNotificationConfigurations object, which is the event
// configuration object for Sidewalk-related event topics.
type SidewalkEventNotificationConfigurations struct {
// Denotes whether the Amazon ID event topic is enabled or disabled.
AmazonIdEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Gets information about a Sidewalk device profile.
type SidewalkGetDeviceProfile struct {
// The Sidewalk application server public key.
ApplicationServerPublicKey *string
// The DAK certificate information of the Sidewalk device profile.
DakCertificateMetadata []DakCertificateMetadata
// Gets information about the certification status of a Sidewalk device profile.
QualificationStatus *bool
noSmithyDocumentSerde
}
// Sidewalk-related information for devices in an import task that are being
// onboarded.
type SidewalkGetStartImportInfo struct {
// List of Sidewalk devices that are added to the import task.
DeviceCreationFileList []string
// The IAM role that allows AWS IoT Wireless to access the CSV file in the S3
// bucket.
Role *string
noSmithyDocumentSerde
}
// Sidewalk object used by list functions.
type SidewalkListDevice struct {
// The Sidewalk Amazon ID.
AmazonId *string
// The sidewalk device certificates for Ed25519 and P256r1.
DeviceCertificates []CertificateList
// Sidewalk object used by list functions.
DeviceProfileId *string
// The sidewalk device identification.
SidewalkId *string
// The Sidewalk manufacturing series number.
SidewalkManufacturingSn *string
// The status of the Sidewalk devices, such as provisioned or registered.
Status WirelessDeviceSidewalkStatus
noSmithyDocumentSerde
}
// Sidewalk resource type event configuration object for enabling or disabling
// topic.
type SidewalkResourceTypeEventConfiguration struct {
// Denotes whether the wireless device join event topic is enabled or disabled.
WirelessDeviceEventTopic EventNotificationTopicStatus
noSmithyDocumentSerde
}
// Information about a Sidewalk router.
type SidewalkSendDataToDevice struct {
// The duration of time in seconds to retry sending the ACK.
AckModeRetryDurationSecs *int32
// Sidewalk device message type. Default value is CUSTOM_COMMAND_ID_NOTIFY .
MessageType MessageType
// The sequence number.
Seq *int32
noSmithyDocumentSerde
}
// Information about an import task created for an individual Sidewalk device.
type SidewalkSingleStartImportInfo struct {
// The Sidewalk manufacturing serial number (SMSN) of the device added to the
// import task.
SidewalkManufacturingSn *string
noSmithyDocumentSerde
}
// Information about an import task created for bulk provisioning.
type SidewalkStartImportInfo struct {
// The CSV file contained in an S3 bucket that's used for adding devices to an
// import task.
DeviceCreationFile *string
// The IAM role that allows AWS IoT Wireless to access the CSV file in the S3
// bucket.
Role *string
noSmithyDocumentSerde
}
// Sidewalk update.
type SidewalkUpdateAccount struct {
// The new Sidewalk application server private key.
AppServerPrivateKey *string
noSmithyDocumentSerde
}
// Sidewalk object information for updating an import task.
type SidewalkUpdateImportInfo struct {
// The CSV file contained in an S3 bucket that's used for appending devices to an
// existing import task.
DeviceCreationFile *string
noSmithyDocumentSerde
}
// A simple label consisting of a customer-defined key-value pair
type Tag struct {
// The tag's key value.
//
// This member is required.
Key *string
// The tag's value.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// TD-SCDMA local identification (local Id) information.
type TdscdmaLocalId struct {
// Cell parameters for TD-SCDMA.
//
// This member is required.
CellParams *int32
// TD-SCDMA UTRA (Universal Terrestrial Radio Access Network) absolute RF channel
// number (UARFCN).
//
// This member is required.
Uarfcn *int32
noSmithyDocumentSerde
}
// TD-SCDMA object for network measurement reports.
type TdscdmaNmrObj struct {
// Cell parameters for TD-SCDMA network measurement reports object.
//
// This member is required.
CellParams *int32
// TD-SCDMA UTRA (Universal Terrestrial Radio Access Network) absolute RF channel
// number.
//
// This member is required.
Uarfcn *int32
// Path loss, or path attenuation, is the reduction in power density of an
// electromagnetic wave as it propagates through space.
PathLoss *int32
// Code power of the received signal, measured in decibel-milliwatts (dBm).
Rscp *int32
// UTRAN (UMTS Terrestrial Radio Access Network) cell global identifier.
UtranCid *int32
noSmithyDocumentSerde
}
// TD-SCDMA object.
type TdscdmaObj struct {
// Mobile Country Code.
//
// This member is required.
Mcc *int32
// Mobile Network Code.
//
// This member is required.
Mnc *int32
// UTRAN (UMTS Terrestrial Radio Access Network) Cell Global Identifier.
//
// This member is required.
UtranCid *int32
// Location Area Code.
Lac *int32
// Path loss, or path attenuation, is the reduction in power density of an
// electromagnetic wave as it propagates through space.
PathLoss *int32
// Signal power of the received signal (Received Signal Code Power), measured in
// decibel-milliwatts (dBm).
Rscp *int32
// TD-SCDMA local identification (local ID) information.
TdscdmaLocalId *TdscdmaLocalId
// TD-SCDMA object for network measurement reports.
TdscdmaNmr []TdscdmaNmrObj
// TD-SCDMA Timing advance.
TdscdmaTimingAdvance *int32
noSmithyDocumentSerde
}
// Trace content for your wireless gateway and wireless device resources.
type TraceContent struct {
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
LogLevel LogLevel
// FrameInfo of your multicast group resources for the trace content. Use
// FrameInfo to debug the multicast communication between your LoRaWAN end devices
// and the network server.
MulticastFrameInfo MulticastFrameInfo
// FrameInfo of your wireless device resources for the trace content. Use
// FrameInfo to debug the communication between your LoRaWAN end devices and the
// network server.
WirelessDeviceFrameInfo WirelessDeviceFrameInfo
noSmithyDocumentSerde
}
// ABP device object for LoRaWAN specification v1.0.x
type UpdateAbpV1_0_x struct {
// The FCnt init value.
FCntStart *int32
noSmithyDocumentSerde
}
// ABP device object for LoRaWAN specification v1.1
type UpdateAbpV1_1 struct {
// The FCnt init value.
FCntStart *int32
noSmithyDocumentSerde
}
// Object for updating the FPorts information.
type UpdateFPorts struct {
// LoRaWAN application, which can be used for geolocation by activating
// positioning.
Applications []ApplicationConfig
// Positioning FPorts for the ClockSync, Stream, and GNSS functions.
Positioning *Positioning
noSmithyDocumentSerde
}
// UpdateWirelessGatewayTaskCreate object.
type UpdateWirelessGatewayTaskCreate struct {
// The properties that relate to the LoRaWAN wireless gateway.
LoRaWAN *LoRaWANUpdateGatewayTaskCreate
// The IAM role used to read data from the S3 bucket.
UpdateDataRole *string
// The link to the S3 bucket.
UpdateDataSource *string
noSmithyDocumentSerde
}
// UpdateWirelessGatewayTaskEntry object.
type UpdateWirelessGatewayTaskEntry struct {
// The Amazon Resource Name of the resource.
Arn *string
// The ID of the new wireless gateway task entry.
Id *string
// The properties that relate to the LoRaWAN wireless gateway.
LoRaWAN *LoRaWANUpdateGatewayTaskEntry
noSmithyDocumentSerde
}
// WCDMA local identification (local ID) information.
type WcdmaLocalId struct {
// Primary Scrambling Code.
//
// This member is required.
Psc *int32
// WCDMA UTRA Absolute RF Channel Number downlink.
//
// This member is required.
Uarfcndl *int32
noSmithyDocumentSerde
}
// Network Measurement Reports.
type WcdmaNmrObj struct {
// Primary Scrambling Code.
//
// This member is required.
Psc *int32
// WCDMA UTRA Absolute RF Channel Number downlink.
//
// This member is required.
Uarfcndl *int32
// UTRAN (UMTS Terrestrial Radio Access Network) Cell Global Identifier.
//
// This member is required.
UtranCid *int32
// Path loss, or path attenuation, is the reduction in power density of an
// electromagnetic wave as it propagates through space.
PathLoss *int32
// Received Signal Code Power (signal power) (dBm)
Rscp *int32
noSmithyDocumentSerde
}
// WCDMA.
type WcdmaObj struct {
// Mobile Country Code.
//
// This member is required.
Mcc *int32
// Mobile Network Code.
//
// This member is required.
Mnc *int32
// UTRAN (UMTS Terrestrial Radio Access Network) Cell Global Identifier.
//
// This member is required.
UtranCid *int32
// Location Area Code.
Lac *int32
// Path loss, or path attenuation, is the reduction in power density of an
// electromagnetic wave as it propagates through space.
PathLoss *int32
// Received Signal Code Power (signal power) (dBm).
Rscp *int32
// WCDMA local ID information.
WcdmaLocalId *WcdmaLocalId
// WCDMA object for network measurement reports.
WcdmaNmr []WcdmaNmrObj
noSmithyDocumentSerde
}
// Wi-Fi access point.
type WiFiAccessPoint struct {
// Wi-Fi MAC Address.
//
// This member is required.
MacAddress *string
// Received signal strength (dBm) of the WLAN measurement data.
//
// This member is required.
Rss *int32
noSmithyDocumentSerde
}
// The log options for a wireless device event and can be used to set log levels
// for a specific wireless device event. For a LoRaWAN device, possible events for
// a log messsage are: Join , Rejoin , Downlink_Data , and Uplink_Data . For a
// Sidewalk device, possible events for a log message are Registration ,
// Downlink_Data , and Uplink_Data .
type WirelessDeviceEventLogOption struct {
// The event for a log message, if the log message is tied to a wireless device.
//
// This member is required.
Event WirelessDeviceEvent
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
//
// This member is required.
LogLevel LogLevel
noSmithyDocumentSerde
}
// Information about an import task for wireless devices.
type WirelessDeviceImportTask struct {
// The ARN (Amazon Resource Name) of the wireless device import task.
Arn *string
// The time at which the import task was created.
CreationTime *time.Time
// The name of the Sidewalk destination that that describes the IoT rule to route
// messages from the device in the import task that will be onboarded to AWS IoT
// Wireless
DestinationName *string
// The summary information of count of wireless devices in an import task that
// failed to onboarded to the import task.
FailedImportedDeviceCount *int64
// The ID of the wireless device import task.
Id *string
// The summary information of count of wireless devices that are waiting for the
// control log to be added to an import task.
InitializedImportedDeviceCount *int64
// The summary information of count of wireless devices in an import task that
// have been onboarded to the import task.
OnboardedImportedDeviceCount *int64
// The summary information of count of wireless devices in an import task that are
// waiting in the queue to be onboarded.
PendingImportedDeviceCount *int64
// The Sidewalk-related information of the wireless device import task.
Sidewalk *SidewalkGetStartImportInfo
// The status information of the wireless device import task.
Status ImportTaskStatus
// The reason that provides additional information about the import task status.
StatusReason *string
noSmithyDocumentSerde
}
// The log options for wireless devices and can be used to set log levels for a
// specific type of wireless device.
type WirelessDeviceLogOption struct {
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
//
// This member is required.
LogLevel LogLevel
// The wireless device type.
//
// This member is required.
Type WirelessDeviceType
// The list of wireless device event log options.
Events []WirelessDeviceEventLogOption
noSmithyDocumentSerde
}
// Information about a wireless device's operation.
type WirelessDeviceStatistics struct {
// The Amazon Resource Name of the resource.
Arn *string
// The name of the destination to which the device is assigned.
DestinationName *string
// The status of a wireless device in a FUOTA task.
FuotaDeviceStatus FuotaDeviceStatus
// The ID of the wireless device reporting the data.
Id *string
// The date and time when the most recent uplink was received. Theis value is only
// valid for 3 months.
LastUplinkReceivedAt *string
// LoRaWAN device info.
LoRaWAN *LoRaWANListDevice
// Id of the multicast group.
McGroupId *int32
// The status of the wireless device in the multicast group.
MulticastDeviceStatus *string
// The name of the resource.
Name *string
// The Sidewalk account credentials.
Sidewalk *SidewalkListDevice
// The wireless device type.
Type WirelessDeviceType
noSmithyDocumentSerde
}
// The log options for a wireless gateway event and can be used to set log levels
// for a specific wireless gateway event. For a LoRaWAN gateway, possible events
// for a log message are CUPS_Request and Certificate .
type WirelessGatewayEventLogOption struct {
// The event for a log message, if the log message is tied to a wireless gateway.
//
// This member is required.
Event WirelessGatewayEvent
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
//
// This member is required.
LogLevel LogLevel
noSmithyDocumentSerde
}
// The log options for wireless gateways and can be used to set log levels for a
// specific type of wireless gateway.
type WirelessGatewayLogOption struct {
// The log level for a log message. The log levels can be disabled, or set to ERROR
// to display less verbose logs containing only error information, or to INFO for
// more detailed logs.
//
// This member is required.
LogLevel LogLevel
// The wireless gateway type.
//
// This member is required.
Type WirelessGatewayType
// The list of wireless gateway event log options.
Events []WirelessGatewayEventLogOption
noSmithyDocumentSerde
}
// Information about a wireless gateway's operation.
type WirelessGatewayStatistics struct {
// The Amazon Resource Name of the resource.
Arn *string
// The description of the resource.
Description *string
// The ID of the wireless gateway reporting the data.
Id *string
// The date and time when the most recent uplink was received. This value is only
// valid for 3 months.
LastUplinkReceivedAt *string
// LoRaWAN gateway info.
LoRaWAN *LoRaWANGateway
// The name of the resource.
Name *string
noSmithyDocumentSerde
}
// WirelessMetadata object.
type WirelessMetadata struct {
// LoRaWAN device info.
LoRaWAN *LoRaWANSendDataToDevice
// The Sidewalk account credentials.
Sidewalk *SidewalkSendDataToDevice
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 2,181 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "ivs"
const ServiceAPIVersion = "2020-07-14"
// Client provides the API client to make operations call for Amazon Interactive
// Video Service.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "ivs", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 435 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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 ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Performs GetChannel on multiple ARNs simultaneously.
func (c *Client) BatchGetChannel(ctx context.Context, params *BatchGetChannelInput, optFns ...func(*Options)) (*BatchGetChannelOutput, error) {
if params == nil {
params = &BatchGetChannelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchGetChannel", params, optFns, c.addOperationBatchGetChannelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchGetChannelOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchGetChannelInput struct {
// Array of ARNs, one per channel.
//
// This member is required.
Arns []string
noSmithyDocumentSerde
}
type BatchGetChannelOutput struct {
//
Channels []types.Channel
// Each error object is related to a specific ARN in the request.
Errors []types.BatchError
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchGetChannelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchGetChannel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchGetChannel{}, 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 = addOpBatchGetChannelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchGetChannel(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_opBatchGetChannel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "BatchGetChannel",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Performs GetStreamKey on multiple ARNs simultaneously.
func (c *Client) BatchGetStreamKey(ctx context.Context, params *BatchGetStreamKeyInput, optFns ...func(*Options)) (*BatchGetStreamKeyOutput, error) {
if params == nil {
params = &BatchGetStreamKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchGetStreamKey", params, optFns, c.addOperationBatchGetStreamKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchGetStreamKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchGetStreamKeyInput struct {
// Array of ARNs, one per stream key.
//
// This member is required.
Arns []string
noSmithyDocumentSerde
}
type BatchGetStreamKeyOutput struct {
//
Errors []types.BatchError
//
StreamKeys []types.StreamKey
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchGetStreamKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchGetStreamKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchGetStreamKey{}, 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 = addOpBatchGetStreamKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchGetStreamKey(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_opBatchGetStreamKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "BatchGetStreamKey",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Performs StartViewerSessionRevocation on multiple channel ARN and viewer ID
// pairs simultaneously.
func (c *Client) BatchStartViewerSessionRevocation(ctx context.Context, params *BatchStartViewerSessionRevocationInput, optFns ...func(*Options)) (*BatchStartViewerSessionRevocationOutput, error) {
if params == nil {
params = &BatchStartViewerSessionRevocationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchStartViewerSessionRevocation", params, optFns, c.addOperationBatchStartViewerSessionRevocationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchStartViewerSessionRevocationOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchStartViewerSessionRevocationInput struct {
// Array of viewer sessions, one per channel-ARN and viewer-ID pair.
//
// This member is required.
ViewerSessions []types.BatchStartViewerSessionRevocationViewerSession
noSmithyDocumentSerde
}
type BatchStartViewerSessionRevocationOutput struct {
// Each error object is related to a specific channelArn and viewerId pair in the
// request.
Errors []types.BatchStartViewerSessionRevocationError
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchStartViewerSessionRevocationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchStartViewerSessionRevocation{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchStartViewerSessionRevocation{}, 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 = addOpBatchStartViewerSessionRevocationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchStartViewerSessionRevocation(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_opBatchStartViewerSessionRevocation(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "BatchStartViewerSessionRevocation",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new channel and an associated stream key to start streaming.
func (c *Client) CreateChannel(ctx context.Context, params *CreateChannelInput, optFns ...func(*Options)) (*CreateChannelOutput, error) {
if params == nil {
params = &CreateChannelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateChannel", params, optFns, c.addOperationCreateChannelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateChannelOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateChannelInput struct {
// Whether the channel is private (enabled for playback authorization). Default:
// false .
Authorized bool
// Whether the channel allows insecure RTMP ingest. Default: false .
InsecureIngest bool
// Channel latency mode. Use NORMAL to broadcast and deliver live video up to Full
// HD. Use LOW for near-real-time interaction with viewers. (Note: In the Amazon
// IVS console, LOW and NORMAL correspond to Ultra-low and Standard,
// respectively.) Default: LOW .
LatencyMode types.ChannelLatencyMode
// Channel name.
Name *string
// Optional transcode preset for the channel. This is selectable only for
// ADVANCED_HD and ADVANCED_SD channel types. For those channel types, the default
// preset is HIGHER_BANDWIDTH_DELIVERY . For other channel types ( BASIC and
// STANDARD ), preset is the empty string ( "" ).
Preset types.TranscodePreset
// Recording-configuration ARN. Default: "" (empty string, recording is disabled).
RecordingConfigurationArn *string
// Array of 1-50 maps, each of the form string:string (key:value) . See Tagging
// Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// for more information, including restrictions that apply to tags and "Tag naming
// limits and requirements"; Amazon IVS has no service-specific constraints beyond
// what is documented there.
Tags map[string]string
// Channel type, which determines the allowable resolution and bitrate. If you
// exceed the allowable input resolution or bitrate, the stream probably will
// disconnect immediately. Some types generate multiple qualities (renditions) from
// the original input; this automatically gives viewers the best experience for
// their devices and network conditions. Some types provide transcoded video;
// transcoding allows higher playback quality across a range of download speeds.
// Default: STANDARD . Valid values:
// - BASIC : Video is transmuxed: Amazon IVS delivers the original input quality
// to viewers. The viewer’s video-quality choice is limited to the original input.
// Input resolution can be up to 1080p and bitrate can be up to 1.5 Mbps for 480p
// and up to 3.5 Mbps for resolutions between 480p and 1080p. Original audio is
// passed through.
// - STANDARD : Video is transcoded: multiple qualities are generated from the
// original input, to automatically give viewers the best experience for their
// devices and network conditions. Transcoding allows higher playback quality
// across a range of download speeds. Resolution can be up to 1080p and bitrate can
// be up to 8.5 Mbps. Audio is transcoded only for renditions 360p and below; above
// that, audio is passed through. This is the default when you create a channel.
// - ADVANCED_SD : Video is transcoded; multiple qualities are generated from the
// original input, to automatically give viewers the best experience for their
// devices and network conditions. Input resolution can be up to 1080p and bitrate
// can be up to 8.5 Mbps; output is capped at SD quality (480p). You can select an
// optional transcode preset (see below). Audio for all renditions is transcoded,
// and an audio-only rendition is available.
// - ADVANCED_HD : Video is transcoded; multiple qualities are generated from the
// original input, to automatically give viewers the best experience for their
// devices and network conditions. Input resolution can be up to 1080p and bitrate
// can be up to 8.5 Mbps; output is capped at HD quality (720p). You can select an
// optional transcode preset (see below). Audio for all renditions is transcoded,
// and an audio-only rendition is available.
// Optional transcode presets (available for the ADVANCED types) allow you to
// trade off available download bandwidth and video quality, to optimize the
// viewing experience. There are two presets:
// - Constrained bandwidth delivery uses a lower bitrate for each quality level.
// Use it if you have low download bandwidth and/or simple video content (e.g.,
// talking heads)
// - Higher bandwidth delivery uses a higher bitrate for each quality level. Use
// it if you have high download bandwidth and/or complex video content (e.g.,
// flashes and quick scene changes).
Type types.ChannelType
noSmithyDocumentSerde
}
type CreateChannelOutput struct {
//
Channel *types.Channel
//
StreamKey *types.StreamKey
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateChannelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateChannel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateChannel{}, 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_opCreateChannel(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_opCreateChannel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "CreateChannel",
}
}
| 193 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new recording configuration, used to enable recording to Amazon S3.
// Known issue: In the us-east-1 region, if you use the Amazon Web Services CLI to
// create a recording configuration, it returns success even if the S3 bucket is in
// a different region. In this case, the state of the recording configuration is
// CREATE_FAILED (instead of ACTIVE ). (In other regions, the CLI correctly returns
// failure if the bucket is in a different region.) Workaround: Ensure that your S3
// bucket is in the same region as the recording configuration. If you create a
// recording configuration in a different region as your S3 bucket, delete that
// recording configuration and create a new one with an S3 bucket from the correct
// region.
func (c *Client) CreateRecordingConfiguration(ctx context.Context, params *CreateRecordingConfigurationInput, optFns ...func(*Options)) (*CreateRecordingConfigurationOutput, error) {
if params == nil {
params = &CreateRecordingConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateRecordingConfiguration", params, optFns, c.addOperationCreateRecordingConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateRecordingConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateRecordingConfigurationInput struct {
// A complex type that contains a destination configuration for where recorded
// video will be stored.
//
// This member is required.
DestinationConfiguration *types.DestinationConfiguration
// Recording-configuration name. The value does not need to be unique.
Name *string
// If a broadcast disconnects and then reconnects within the specified interval,
// the multiple streams will be considered a single broadcast and merged together.
// Default: 0.
RecordingReconnectWindowSeconds int32
// Array of 1-50 maps, each of the form string:string (key:value) . See Tagging
// Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// for more information, including restrictions that apply to tags and "Tag naming
// limits and requirements"; Amazon IVS has no service-specific constraints beyond
// what is documented there.
Tags map[string]string
// A complex type that allows you to enable/disable the recording of thumbnails
// for a live session and modify the interval at which thumbnails are generated for
// the live session.
ThumbnailConfiguration *types.ThumbnailConfiguration
noSmithyDocumentSerde
}
type CreateRecordingConfigurationOutput struct {
//
RecordingConfiguration *types.RecordingConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateRecordingConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateRecordingConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateRecordingConfiguration{}, 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 = addOpCreateRecordingConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateRecordingConfiguration(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_opCreateRecordingConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "CreateRecordingConfiguration",
}
}
| 155 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a stream key, used to initiate a stream, for the specified channel ARN.
// Note that CreateChannel creates a stream key. If you subsequently use
// CreateStreamKey on the same channel, it will fail because a stream key already
// exists and there is a limit of 1 stream key per channel. To reset the stream key
// on a channel, use DeleteStreamKey and then CreateStreamKey.
func (c *Client) CreateStreamKey(ctx context.Context, params *CreateStreamKeyInput, optFns ...func(*Options)) (*CreateStreamKeyOutput, error) {
if params == nil {
params = &CreateStreamKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStreamKey", params, optFns, c.addOperationCreateStreamKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStreamKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStreamKeyInput struct {
// ARN of the channel for which to create the stream key.
//
// This member is required.
ChannelArn *string
// Array of 1-50 maps, each of the form string:string (key:value) . See Tagging
// Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// for more information, including restrictions that apply to tags and "Tag naming
// limits and requirements"; Amazon IVS has no service-specific constraints beyond
// what is documented there.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateStreamKeyOutput struct {
// Stream key used to authenticate an RTMPS stream for ingestion.
StreamKey *types.StreamKey
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStreamKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateStreamKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateStreamKey{}, 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 = addOpCreateStreamKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStreamKey(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_opCreateStreamKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "CreateStreamKey",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified channel and its associated stream keys. If you try to
// delete a live channel, you will get an error (409 ConflictException). To delete
// a channel that is live, call StopStream , wait for the Amazon EventBridge
// "Stream End" event (to verify that the stream's state is no longer Live), then
// call DeleteChannel. (See Using EventBridge with Amazon IVS (https://docs.aws.amazon.com/ivs/latest/userguide/eventbridge.html)
// .)
func (c *Client) DeleteChannel(ctx context.Context, params *DeleteChannelInput, optFns ...func(*Options)) (*DeleteChannelOutput, error) {
if params == nil {
params = &DeleteChannelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteChannel", params, optFns, c.addOperationDeleteChannelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteChannelOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteChannelInput struct {
// ARN of the channel to be deleted.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type DeleteChannelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteChannelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteChannel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteChannel{}, 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 = addOpDeleteChannelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteChannel(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_opDeleteChannel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "DeleteChannel",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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 specified authorization key pair. This invalidates future viewer
// tokens generated using the key pair’s privateKey . For more information, see
// Setting Up Private Channels (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
// in the Amazon IVS User Guide.
func (c *Client) DeletePlaybackKeyPair(ctx context.Context, params *DeletePlaybackKeyPairInput, optFns ...func(*Options)) (*DeletePlaybackKeyPairOutput, error) {
if params == nil {
params = &DeletePlaybackKeyPairInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeletePlaybackKeyPair", params, optFns, c.addOperationDeletePlaybackKeyPairMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeletePlaybackKeyPairOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeletePlaybackKeyPairInput struct {
// ARN of the key pair to be deleted.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type DeletePlaybackKeyPairOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeletePlaybackKeyPairMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeletePlaybackKeyPair{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeletePlaybackKeyPair{}, 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 = addOpDeletePlaybackKeyPairValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeletePlaybackKeyPair(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_opDeletePlaybackKeyPair(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "DeletePlaybackKeyPair",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the recording configuration for the specified ARN. If you try to delete
// a recording configuration that is associated with a channel, you will get an
// error (409 ConflictException). To avoid this, for all channels that reference
// the recording configuration, first use UpdateChannel to set the
// recordingConfigurationArn field to an empty string, then use
// DeleteRecordingConfiguration.
func (c *Client) DeleteRecordingConfiguration(ctx context.Context, params *DeleteRecordingConfigurationInput, optFns ...func(*Options)) (*DeleteRecordingConfigurationOutput, error) {
if params == nil {
params = &DeleteRecordingConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteRecordingConfiguration", params, optFns, c.addOperationDeleteRecordingConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteRecordingConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteRecordingConfigurationInput struct {
// ARN of the recording configuration to be deleted.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type DeleteRecordingConfigurationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteRecordingConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteRecordingConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteRecordingConfiguration{}, 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 = addOpDeleteRecordingConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteRecordingConfiguration(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_opDeleteRecordingConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "DeleteRecordingConfiguration",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the stream key for the specified ARN, so it can no longer be used to
// stream.
func (c *Client) DeleteStreamKey(ctx context.Context, params *DeleteStreamKeyInput, optFns ...func(*Options)) (*DeleteStreamKeyOutput, error) {
if params == nil {
params = &DeleteStreamKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStreamKey", params, optFns, c.addOperationDeleteStreamKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStreamKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStreamKeyInput struct {
// ARN of the stream key to be deleted.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type DeleteStreamKeyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStreamKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteStreamKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteStreamKey{}, 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 = addOpDeleteStreamKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStreamKey(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_opDeleteStreamKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "DeleteStreamKey",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the channel configuration for the specified channel ARN. See also
// BatchGetChannel .
func (c *Client) GetChannel(ctx context.Context, params *GetChannelInput, optFns ...func(*Options)) (*GetChannelOutput, error) {
if params == nil {
params = &GetChannelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetChannel", params, optFns, c.addOperationGetChannelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetChannelOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetChannelInput struct {
// ARN of the channel for which the configuration is to be retrieved.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetChannelOutput struct {
//
Channel *types.Channel
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetChannelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetChannel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetChannel{}, 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 = addOpGetChannelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetChannel(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_opGetChannel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "GetChannel",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets a specified playback authorization key pair and returns the arn and
// fingerprint . The privateKey held by the caller can be used to generate viewer
// authorization tokens, to grant viewers access to private channels. For more
// information, see Setting Up Private Channels (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
// in the Amazon IVS User Guide.
func (c *Client) GetPlaybackKeyPair(ctx context.Context, params *GetPlaybackKeyPairInput, optFns ...func(*Options)) (*GetPlaybackKeyPairOutput, error) {
if params == nil {
params = &GetPlaybackKeyPairInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPlaybackKeyPair", params, optFns, c.addOperationGetPlaybackKeyPairMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPlaybackKeyPairOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetPlaybackKeyPairInput struct {
// ARN of the key pair to be returned.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetPlaybackKeyPairOutput struct {
//
KeyPair *types.PlaybackKeyPair
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPlaybackKeyPairMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetPlaybackKeyPair{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetPlaybackKeyPair{}, 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 = addOpGetPlaybackKeyPairValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPlaybackKeyPair(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_opGetPlaybackKeyPair(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "GetPlaybackKeyPair",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the recording configuration for the specified ARN.
func (c *Client) GetRecordingConfiguration(ctx context.Context, params *GetRecordingConfigurationInput, optFns ...func(*Options)) (*GetRecordingConfigurationOutput, error) {
if params == nil {
params = &GetRecordingConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRecordingConfiguration", params, optFns, c.addOperationGetRecordingConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRecordingConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRecordingConfigurationInput struct {
// ARN of the recording configuration to be retrieved.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetRecordingConfigurationOutput struct {
//
RecordingConfiguration *types.RecordingConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRecordingConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRecordingConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRecordingConfiguration{}, 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 = addOpGetRecordingConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRecordingConfiguration(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_opGetRecordingConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "GetRecordingConfiguration",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about the active (live) stream on a specified channel.
func (c *Client) GetStream(ctx context.Context, params *GetStreamInput, optFns ...func(*Options)) (*GetStreamOutput, error) {
if params == nil {
params = &GetStreamInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetStream", params, optFns, c.addOperationGetStreamMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetStreamOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetStreamInput struct {
// Channel ARN for stream to be accessed.
//
// This member is required.
ChannelArn *string
noSmithyDocumentSerde
}
type GetStreamOutput struct {
//
Stream *types.Stream
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetStreamMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetStream{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetStream{}, 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 = addOpGetStreamValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetStream(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_opGetStream(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "GetStream",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets stream-key information for a specified ARN.
func (c *Client) GetStreamKey(ctx context.Context, params *GetStreamKeyInput, optFns ...func(*Options)) (*GetStreamKeyOutput, error) {
if params == nil {
params = &GetStreamKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetStreamKey", params, optFns, c.addOperationGetStreamKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetStreamKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetStreamKeyInput struct {
// ARN for the stream key to be retrieved.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetStreamKeyOutput struct {
//
StreamKey *types.StreamKey
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetStreamKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetStreamKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetStreamKey{}, 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 = addOpGetStreamKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetStreamKey(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_opGetStreamKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "GetStreamKey",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets metadata on a specified stream.
func (c *Client) GetStreamSession(ctx context.Context, params *GetStreamSessionInput, optFns ...func(*Options)) (*GetStreamSessionOutput, error) {
if params == nil {
params = &GetStreamSessionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetStreamSession", params, optFns, c.addOperationGetStreamSessionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetStreamSessionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetStreamSessionInput struct {
// ARN of the channel resource
//
// This member is required.
ChannelArn *string
// Unique identifier for a live or previously live stream in the specified
// channel. If no streamId is provided, this returns the most recent stream
// session for the channel, if it exists.
StreamId *string
noSmithyDocumentSerde
}
type GetStreamSessionOutput struct {
// List of stream details.
StreamSession *types.StreamSession
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetStreamSessionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetStreamSession{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetStreamSession{}, 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 = addOpGetStreamSessionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetStreamSession(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_opGetStreamSession(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "GetStreamSession",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Imports the public portion of a new key pair and returns its arn and fingerprint
// . The privateKey can then be used to generate viewer authorization tokens, to
// grant viewers access to private channels. For more information, see Setting Up
// Private Channels (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
// in the Amazon IVS User Guide.
func (c *Client) ImportPlaybackKeyPair(ctx context.Context, params *ImportPlaybackKeyPairInput, optFns ...func(*Options)) (*ImportPlaybackKeyPairOutput, error) {
if params == nil {
params = &ImportPlaybackKeyPairInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ImportPlaybackKeyPair", params, optFns, c.addOperationImportPlaybackKeyPairMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ImportPlaybackKeyPairOutput)
out.ResultMetadata = metadata
return out, nil
}
type ImportPlaybackKeyPairInput struct {
// The public portion of a customer-generated key pair.
//
// This member is required.
PublicKeyMaterial *string
// Playback-key-pair name. The value does not need to be unique.
Name *string
// Any tags provided with the request are added to the playback key pair tags. See
// Tagging Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// for more information, including restrictions that apply to tags and "Tag naming
// limits and requirements"; Amazon IVS has no service-specific constraints beyond
// what is documented there.
Tags map[string]string
noSmithyDocumentSerde
}
type ImportPlaybackKeyPairOutput struct {
//
KeyPair *types.PlaybackKeyPair
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationImportPlaybackKeyPairMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpImportPlaybackKeyPair{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpImportPlaybackKeyPair{}, 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 = addOpImportPlaybackKeyPairValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opImportPlaybackKeyPair(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_opImportPlaybackKeyPair(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "ImportPlaybackKeyPair",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets summary information about all channels in your account, in the Amazon Web
// Services region where the API request is processed. This list can be filtered to
// match a specified name or recording-configuration ARN. Filters are mutually
// exclusive and cannot be used together. If you try to use both filters, you will
// get an error (409 ConflictException).
func (c *Client) ListChannels(ctx context.Context, params *ListChannelsInput, optFns ...func(*Options)) (*ListChannelsOutput, error) {
if params == nil {
params = &ListChannelsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListChannels", params, optFns, c.addOperationListChannelsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListChannelsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListChannelsInput struct {
// Filters the channel list to match the specified name.
FilterByName *string
// Filters the channel list to match the specified recording-configuration ARN.
FilterByRecordingConfigurationArn *string
// Maximum number of channels to return. Default: 100.
MaxResults int32
// The first channel to retrieve. This is used for pagination; see the nextToken
// response field.
NextToken *string
noSmithyDocumentSerde
}
type ListChannelsOutput struct {
// List of the matching channels.
//
// This member is required.
Channels []types.ChannelSummary
// If there are more channels than maxResults , use nextToken in the request to
// get the next set.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListChannelsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListChannels{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListChannels{}, 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_opListChannels(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
}
// ListChannelsAPIClient is a client that implements the ListChannels operation.
type ListChannelsAPIClient interface {
ListChannels(context.Context, *ListChannelsInput, ...func(*Options)) (*ListChannelsOutput, error)
}
var _ ListChannelsAPIClient = (*Client)(nil)
// ListChannelsPaginatorOptions is the paginator options for ListChannels
type ListChannelsPaginatorOptions struct {
// Maximum number of channels to return. Default: 100.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListChannelsPaginator is a paginator for ListChannels
type ListChannelsPaginator struct {
options ListChannelsPaginatorOptions
client ListChannelsAPIClient
params *ListChannelsInput
nextToken *string
firstPage bool
}
// NewListChannelsPaginator returns a new ListChannelsPaginator
func NewListChannelsPaginator(client ListChannelsAPIClient, params *ListChannelsInput, optFns ...func(*ListChannelsPaginatorOptions)) *ListChannelsPaginator {
if params == nil {
params = &ListChannelsInput{}
}
options := ListChannelsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListChannelsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListChannelsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListChannels page.
func (p *ListChannelsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListChannelsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListChannels(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_opListChannels(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "ListChannels",
}
}
| 226 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets summary information about playback key pairs. For more information, see
// Setting Up Private Channels (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
// in the Amazon IVS User Guide.
func (c *Client) ListPlaybackKeyPairs(ctx context.Context, params *ListPlaybackKeyPairsInput, optFns ...func(*Options)) (*ListPlaybackKeyPairsOutput, error) {
if params == nil {
params = &ListPlaybackKeyPairsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListPlaybackKeyPairs", params, optFns, c.addOperationListPlaybackKeyPairsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListPlaybackKeyPairsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListPlaybackKeyPairsInput struct {
// Maximum number of key pairs to return. Default: your service quota or 100,
// whichever is smaller.
MaxResults int32
// The first key pair to retrieve. This is used for pagination; see the nextToken
// response field.
NextToken *string
noSmithyDocumentSerde
}
type ListPlaybackKeyPairsOutput struct {
// List of key pairs.
//
// This member is required.
KeyPairs []types.PlaybackKeyPairSummary
// If there are more key pairs than maxResults , use nextToken in the request to
// get the next set.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListPlaybackKeyPairsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListPlaybackKeyPairs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListPlaybackKeyPairs{}, 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_opListPlaybackKeyPairs(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
}
// ListPlaybackKeyPairsAPIClient is a client that implements the
// ListPlaybackKeyPairs operation.
type ListPlaybackKeyPairsAPIClient interface {
ListPlaybackKeyPairs(context.Context, *ListPlaybackKeyPairsInput, ...func(*Options)) (*ListPlaybackKeyPairsOutput, error)
}
var _ ListPlaybackKeyPairsAPIClient = (*Client)(nil)
// ListPlaybackKeyPairsPaginatorOptions is the paginator options for
// ListPlaybackKeyPairs
type ListPlaybackKeyPairsPaginatorOptions struct {
// Maximum number of key pairs to return. Default: your service quota or 100,
// whichever is smaller.
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
}
// ListPlaybackKeyPairsPaginator is a paginator for ListPlaybackKeyPairs
type ListPlaybackKeyPairsPaginator struct {
options ListPlaybackKeyPairsPaginatorOptions
client ListPlaybackKeyPairsAPIClient
params *ListPlaybackKeyPairsInput
nextToken *string
firstPage bool
}
// NewListPlaybackKeyPairsPaginator returns a new ListPlaybackKeyPairsPaginator
func NewListPlaybackKeyPairsPaginator(client ListPlaybackKeyPairsAPIClient, params *ListPlaybackKeyPairsInput, optFns ...func(*ListPlaybackKeyPairsPaginatorOptions)) *ListPlaybackKeyPairsPaginator {
if params == nil {
params = &ListPlaybackKeyPairsInput{}
}
options := ListPlaybackKeyPairsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListPlaybackKeyPairsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListPlaybackKeyPairsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListPlaybackKeyPairs page.
func (p *ListPlaybackKeyPairsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPlaybackKeyPairsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListPlaybackKeyPairs(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_opListPlaybackKeyPairs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "ListPlaybackKeyPairs",
}
}
| 222 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets summary information about all recording configurations in your account, in
// the Amazon Web Services region where the API request is processed.
func (c *Client) ListRecordingConfigurations(ctx context.Context, params *ListRecordingConfigurationsInput, optFns ...func(*Options)) (*ListRecordingConfigurationsOutput, error) {
if params == nil {
params = &ListRecordingConfigurationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListRecordingConfigurations", params, optFns, c.addOperationListRecordingConfigurationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListRecordingConfigurationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListRecordingConfigurationsInput struct {
// Maximum number of recording configurations to return. Default: your service
// quota or 100, whichever is smaller.
MaxResults int32
// The first recording configuration to retrieve. This is used for pagination; see
// the nextToken response field.
NextToken *string
noSmithyDocumentSerde
}
type ListRecordingConfigurationsOutput struct {
// List of the matching recording configurations.
//
// This member is required.
RecordingConfigurations []types.RecordingConfigurationSummary
// If there are more recording configurations than maxResults , use nextToken in
// the request to get the next set.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListRecordingConfigurationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListRecordingConfigurations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListRecordingConfigurations{}, 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_opListRecordingConfigurations(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
}
// ListRecordingConfigurationsAPIClient is a client that implements the
// ListRecordingConfigurations operation.
type ListRecordingConfigurationsAPIClient interface {
ListRecordingConfigurations(context.Context, *ListRecordingConfigurationsInput, ...func(*Options)) (*ListRecordingConfigurationsOutput, error)
}
var _ ListRecordingConfigurationsAPIClient = (*Client)(nil)
// ListRecordingConfigurationsPaginatorOptions is the paginator options for
// ListRecordingConfigurations
type ListRecordingConfigurationsPaginatorOptions struct {
// Maximum number of recording configurations to return. Default: your service
// quota or 100, whichever is smaller.
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
}
// ListRecordingConfigurationsPaginator is a paginator for
// ListRecordingConfigurations
type ListRecordingConfigurationsPaginator struct {
options ListRecordingConfigurationsPaginatorOptions
client ListRecordingConfigurationsAPIClient
params *ListRecordingConfigurationsInput
nextToken *string
firstPage bool
}
// NewListRecordingConfigurationsPaginator returns a new
// ListRecordingConfigurationsPaginator
func NewListRecordingConfigurationsPaginator(client ListRecordingConfigurationsAPIClient, params *ListRecordingConfigurationsInput, optFns ...func(*ListRecordingConfigurationsPaginatorOptions)) *ListRecordingConfigurationsPaginator {
if params == nil {
params = &ListRecordingConfigurationsInput{}
}
options := ListRecordingConfigurationsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListRecordingConfigurationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListRecordingConfigurationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListRecordingConfigurations page.
func (p *ListRecordingConfigurationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRecordingConfigurationsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListRecordingConfigurations(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_opListRecordingConfigurations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "ListRecordingConfigurations",
}
}
| 223 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ivs
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/ivs/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets summary information about stream keys for the specified channel.
func (c *Client) ListStreamKeys(ctx context.Context, params *ListStreamKeysInput, optFns ...func(*Options)) (*ListStreamKeysOutput, error) {
if params == nil {
params = &ListStreamKeysInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListStreamKeys", params, optFns, c.addOperationListStreamKeysMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListStreamKeysOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListStreamKeysInput struct {
// Channel ARN used to filter the list.
//
// This member is required.
ChannelArn *string
// Maximum number of streamKeys to return. Default: 1.
MaxResults int32
// The first stream key to retrieve. This is used for pagination; see the nextToken
// response field.
NextToken *string
noSmithyDocumentSerde
}
type ListStreamKeysOutput struct {
// List of stream keys.
//
// This member is required.
StreamKeys []types.StreamKeySummary
// If there are more stream keys than maxResults , use nextToken in the request to
// get the next set.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListStreamKeysMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListStreamKeys{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListStreamKeys{}, 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 = addOpListStreamKeysValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListStreamKeys(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
}
// ListStreamKeysAPIClient is a client that implements the ListStreamKeys
// operation.
type ListStreamKeysAPIClient interface {
ListStreamKeys(context.Context, *ListStreamKeysInput, ...func(*Options)) (*ListStreamKeysOutput, error)
}
var _ ListStreamKeysAPIClient = (*Client)(nil)
// ListStreamKeysPaginatorOptions is the paginator options for ListStreamKeys
type ListStreamKeysPaginatorOptions struct {
// Maximum number of streamKeys to return. Default: 1.
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
}
// ListStreamKeysPaginator is a paginator for ListStreamKeys
type ListStreamKeysPaginator struct {
options ListStreamKeysPaginatorOptions
client ListStreamKeysAPIClient
params *ListStreamKeysInput
nextToken *string
firstPage bool
}
// NewListStreamKeysPaginator returns a new ListStreamKeysPaginator
func NewListStreamKeysPaginator(client ListStreamKeysAPIClient, params *ListStreamKeysInput, optFns ...func(*ListStreamKeysPaginatorOptions)) *ListStreamKeysPaginator {
if params == nil {
params = &ListStreamKeysInput{}
}
options := ListStreamKeysPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListStreamKeysPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListStreamKeysPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListStreamKeys page.
func (p *ListStreamKeysPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListStreamKeysOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListStreamKeys(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_opListStreamKeys(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ivs",
OperationName: "ListStreamKeys",
}
}
| 225 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.