serializers.go raw
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 }
310