src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

serializers.go (10304B)

      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package sso
      4 
      5 import (
      6 	"context"
      7 	"fmt"
      8 	smithy "github.com/aws/smithy-go"
      9 	"github.com/aws/smithy-go/encoding/httpbinding"
     10 	"github.com/aws/smithy-go/middleware"
     11 	"github.com/aws/smithy-go/tracing"
     12 	smithyhttp "github.com/aws/smithy-go/transport/http"
     13 )
     14 
     15 type awsRestjson1_serializeOpGetRoleCredentials struct {
     16 }
     17 
     18 func (*awsRestjson1_serializeOpGetRoleCredentials) ID() string {
     19 	return "OperationSerializer"
     20 }
     21 
     22 func (m *awsRestjson1_serializeOpGetRoleCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     23 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
     24 ) {
     25 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
     26 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
     27 	defer endTimer()
     28 	defer span.End()
     29 	request, ok := in.Request.(*smithyhttp.Request)
     30 	if !ok {
     31 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
     32 	}
     33 
     34 	input, ok := in.Parameters.(*GetRoleCredentialsInput)
     35 	_ = input
     36 	if !ok {
     37 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
     38 	}
     39 
     40 	opPath, opQuery := httpbinding.SplitURI("/federation/credentials")
     41 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
     42 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
     43 	request.Method = "GET"
     44 	var restEncoder *httpbinding.Encoder
     45 	if request.URL.RawPath == "" {
     46 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
     47 	} else {
     48 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
     49 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
     50 	}
     51 
     52 	if err != nil {
     53 		return out, metadata, &smithy.SerializationError{Err: err}
     54 	}
     55 
     56 	if err := awsRestjson1_serializeOpHttpBindingsGetRoleCredentialsInput(input, restEncoder); err != nil {
     57 		return out, metadata, &smithy.SerializationError{Err: err}
     58 	}
     59 
     60 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
     61 		return out, metadata, &smithy.SerializationError{Err: err}
     62 	}
     63 	in.Request = request
     64 
     65 	endTimer()
     66 	span.End()
     67 	return next.HandleSerialize(ctx, in)
     68 }
     69 func awsRestjson1_serializeOpHttpBindingsGetRoleCredentialsInput(v *GetRoleCredentialsInput, encoder *httpbinding.Encoder) error {
     70 	if v == nil {
     71 		return fmt.Errorf("unsupported serialization of nil %T", v)
     72 	}
     73 
     74 	if v.AccessToken != nil {
     75 		locationName := "X-Amz-Sso_bearer_token"
     76 		encoder.SetHeader(locationName).String(*v.AccessToken)
     77 	}
     78 
     79 	if v.AccountId != nil {
     80 		encoder.SetQuery("account_id").String(*v.AccountId)
     81 	}
     82 
     83 	if v.RoleName != nil {
     84 		encoder.SetQuery("role_name").String(*v.RoleName)
     85 	}
     86 
     87 	return nil
     88 }
     89 
     90 type awsRestjson1_serializeOpListAccountRoles struct {
     91 }
     92 
     93 func (*awsRestjson1_serializeOpListAccountRoles) ID() string {
     94 	return "OperationSerializer"
     95 }
     96 
     97 func (m *awsRestjson1_serializeOpListAccountRoles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     98 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
     99 ) {
    100 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
    101 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
    102 	defer endTimer()
    103 	defer span.End()
    104 	request, ok := in.Request.(*smithyhttp.Request)
    105 	if !ok {
    106 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    107 	}
    108 
    109 	input, ok := in.Parameters.(*ListAccountRolesInput)
    110 	_ = input
    111 	if !ok {
    112 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    113 	}
    114 
    115 	opPath, opQuery := httpbinding.SplitURI("/assignment/roles")
    116 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    117 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    118 	request.Method = "GET"
    119 	var restEncoder *httpbinding.Encoder
    120 	if request.URL.RawPath == "" {
    121 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    122 	} else {
    123 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    124 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    125 	}
    126 
    127 	if err != nil {
    128 		return out, metadata, &smithy.SerializationError{Err: err}
    129 	}
    130 
    131 	if err := awsRestjson1_serializeOpHttpBindingsListAccountRolesInput(input, restEncoder); err != nil {
    132 		return out, metadata, &smithy.SerializationError{Err: err}
    133 	}
    134 
    135 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    136 		return out, metadata, &smithy.SerializationError{Err: err}
    137 	}
    138 	in.Request = request
    139 
    140 	endTimer()
    141 	span.End()
    142 	return next.HandleSerialize(ctx, in)
    143 }
    144 func awsRestjson1_serializeOpHttpBindingsListAccountRolesInput(v *ListAccountRolesInput, encoder *httpbinding.Encoder) error {
    145 	if v == nil {
    146 		return fmt.Errorf("unsupported serialization of nil %T", v)
    147 	}
    148 
    149 	if v.AccessToken != nil {
    150 		locationName := "X-Amz-Sso_bearer_token"
    151 		encoder.SetHeader(locationName).String(*v.AccessToken)
    152 	}
    153 
    154 	if v.AccountId != nil {
    155 		encoder.SetQuery("account_id").String(*v.AccountId)
    156 	}
    157 
    158 	if v.MaxResults != nil {
    159 		encoder.SetQuery("max_result").Integer(*v.MaxResults)
    160 	}
    161 
    162 	if v.NextToken != nil {
    163 		encoder.SetQuery("next_token").String(*v.NextToken)
    164 	}
    165 
    166 	return nil
    167 }
    168 
    169 type awsRestjson1_serializeOpListAccounts struct {
    170 }
    171 
    172 func (*awsRestjson1_serializeOpListAccounts) ID() string {
    173 	return "OperationSerializer"
    174 }
    175 
    176 func (m *awsRestjson1_serializeOpListAccounts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    177 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    178 ) {
    179 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
    180 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
    181 	defer endTimer()
    182 	defer span.End()
    183 	request, ok := in.Request.(*smithyhttp.Request)
    184 	if !ok {
    185 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    186 	}
    187 
    188 	input, ok := in.Parameters.(*ListAccountsInput)
    189 	_ = input
    190 	if !ok {
    191 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    192 	}
    193 
    194 	opPath, opQuery := httpbinding.SplitURI("/assignment/accounts")
    195 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    196 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    197 	request.Method = "GET"
    198 	var restEncoder *httpbinding.Encoder
    199 	if request.URL.RawPath == "" {
    200 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    201 	} else {
    202 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    203 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    204 	}
    205 
    206 	if err != nil {
    207 		return out, metadata, &smithy.SerializationError{Err: err}
    208 	}
    209 
    210 	if err := awsRestjson1_serializeOpHttpBindingsListAccountsInput(input, restEncoder); err != nil {
    211 		return out, metadata, &smithy.SerializationError{Err: err}
    212 	}
    213 
    214 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    215 		return out, metadata, &smithy.SerializationError{Err: err}
    216 	}
    217 	in.Request = request
    218 
    219 	endTimer()
    220 	span.End()
    221 	return next.HandleSerialize(ctx, in)
    222 }
    223 func awsRestjson1_serializeOpHttpBindingsListAccountsInput(v *ListAccountsInput, encoder *httpbinding.Encoder) error {
    224 	if v == nil {
    225 		return fmt.Errorf("unsupported serialization of nil %T", v)
    226 	}
    227 
    228 	if v.AccessToken != nil {
    229 		locationName := "X-Amz-Sso_bearer_token"
    230 		encoder.SetHeader(locationName).String(*v.AccessToken)
    231 	}
    232 
    233 	if v.MaxResults != nil {
    234 		encoder.SetQuery("max_result").Integer(*v.MaxResults)
    235 	}
    236 
    237 	if v.NextToken != nil {
    238 		encoder.SetQuery("next_token").String(*v.NextToken)
    239 	}
    240 
    241 	return nil
    242 }
    243 
    244 type awsRestjson1_serializeOpLogout struct {
    245 }
    246 
    247 func (*awsRestjson1_serializeOpLogout) ID() string {
    248 	return "OperationSerializer"
    249 }
    250 
    251 func (m *awsRestjson1_serializeOpLogout) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    252 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    253 ) {
    254 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
    255 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
    256 	defer endTimer()
    257 	defer span.End()
    258 	request, ok := in.Request.(*smithyhttp.Request)
    259 	if !ok {
    260 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    261 	}
    262 
    263 	input, ok := in.Parameters.(*LogoutInput)
    264 	_ = input
    265 	if !ok {
    266 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    267 	}
    268 
    269 	opPath, opQuery := httpbinding.SplitURI("/logout")
    270 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    271 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    272 	request.Method = "POST"
    273 	var restEncoder *httpbinding.Encoder
    274 	if request.URL.RawPath == "" {
    275 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    276 	} else {
    277 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    278 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    279 	}
    280 
    281 	if err != nil {
    282 		return out, metadata, &smithy.SerializationError{Err: err}
    283 	}
    284 
    285 	if err := awsRestjson1_serializeOpHttpBindingsLogoutInput(input, restEncoder); err != nil {
    286 		return out, metadata, &smithy.SerializationError{Err: err}
    287 	}
    288 
    289 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    290 		return out, metadata, &smithy.SerializationError{Err: err}
    291 	}
    292 	in.Request = request
    293 
    294 	endTimer()
    295 	span.End()
    296 	return next.HandleSerialize(ctx, in)
    297 }
    298 func awsRestjson1_serializeOpHttpBindingsLogoutInput(v *LogoutInput, encoder *httpbinding.Encoder) error {
    299 	if v == nil {
    300 		return fmt.Errorf("unsupported serialization of nil %T", v)
    301 	}
    302 
    303 	if v.AccessToken != nil {
    304 		locationName := "X-Amz-Sso_bearer_token"
    305 		encoder.SetHeader(locationName).String(*v.AccessToken)
    306 	}
    307 
    308 	return nil
    309 }