serializers.go (236738B)
1 // Code generated by smithy-go-codegen DO NOT EDIT. 2 3 package route53 4 5 import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/route53/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyxml "github.com/aws/smithy-go/encoding/xml" 13 "github.com/aws/smithy-go/middleware" 14 "github.com/aws/smithy-go/tracing" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16 ) 17 18 type awsRestxml_serializeOpActivateKeySigningKey struct { 19 } 20 21 func (*awsRestxml_serializeOpActivateKeySigningKey) ID() string { 22 return "OperationSerializer" 23 } 24 25 func (m *awsRestxml_serializeOpActivateKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27 ) { 28 _, span := tracing.StartSpan(ctx, "OperationSerializer") 29 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 30 defer endTimer() 31 defer span.End() 32 request, ok := in.Request.(*smithyhttp.Request) 33 if !ok { 34 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 35 } 36 37 input, ok := in.Parameters.(*ActivateKeySigningKeyInput) 38 _ = input 39 if !ok { 40 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 41 } 42 43 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/activate") 44 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 45 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 46 request.Method = "POST" 47 var restEncoder *httpbinding.Encoder 48 if request.URL.RawPath == "" { 49 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 50 } else { 51 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 52 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 53 } 54 55 if err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if err := awsRestxml_serializeOpHttpBindingsActivateKeySigningKeyInput(input, restEncoder); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 in.Request = request 67 68 endTimer() 69 span.End() 70 return next.HandleSerialize(ctx, in) 71 } 72 func awsRestxml_serializeOpHttpBindingsActivateKeySigningKeyInput(v *ActivateKeySigningKeyInput, encoder *httpbinding.Encoder) error { 73 if v == nil { 74 return fmt.Errorf("unsupported serialization of nil %T", v) 75 } 76 77 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 78 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 79 } 80 if v.HostedZoneId != nil { 81 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 82 return err 83 } 84 } 85 86 if v.Name == nil || len(*v.Name) == 0 { 87 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 88 } 89 if v.Name != nil { 90 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 91 return err 92 } 93 } 94 95 return nil 96 } 97 98 type awsRestxml_serializeOpAssociateVPCWithHostedZone struct { 99 } 100 101 func (*awsRestxml_serializeOpAssociateVPCWithHostedZone) ID() string { 102 return "OperationSerializer" 103 } 104 105 func (m *awsRestxml_serializeOpAssociateVPCWithHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 106 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 107 ) { 108 _, span := tracing.StartSpan(ctx, "OperationSerializer") 109 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 110 defer endTimer() 111 defer span.End() 112 request, ok := in.Request.(*smithyhttp.Request) 113 if !ok { 114 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 115 } 116 117 input, ok := in.Parameters.(*AssociateVPCWithHostedZoneInput) 118 _ = input 119 if !ok { 120 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 121 } 122 123 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/associatevpc") 124 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 125 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 126 request.Method = "POST" 127 var restEncoder *httpbinding.Encoder 128 if request.URL.RawPath == "" { 129 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 130 } else { 131 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 132 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 133 } 134 135 if err != nil { 136 return out, metadata, &smithy.SerializationError{Err: err} 137 } 138 139 if err := awsRestxml_serializeOpHttpBindingsAssociateVPCWithHostedZoneInput(input, restEncoder); err != nil { 140 return out, metadata, &smithy.SerializationError{Err: err} 141 } 142 143 restEncoder.SetHeader("Content-Type").String("application/xml") 144 145 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 146 rootAttr := []smithyxml.Attr{} 147 root := smithyxml.StartElement{ 148 Name: smithyxml.Name{ 149 Local: "AssociateVPCWithHostedZoneRequest", 150 }, 151 Attr: rootAttr, 152 } 153 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 154 if err := awsRestxml_serializeOpDocumentAssociateVPCWithHostedZoneInput(input, xmlEncoder.RootElement(root)); err != nil { 155 return out, metadata, &smithy.SerializationError{Err: err} 156 } 157 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 158 return out, metadata, &smithy.SerializationError{Err: err} 159 } 160 161 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 162 return out, metadata, &smithy.SerializationError{Err: err} 163 } 164 in.Request = request 165 166 endTimer() 167 span.End() 168 return next.HandleSerialize(ctx, in) 169 } 170 func awsRestxml_serializeOpHttpBindingsAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput, encoder *httpbinding.Encoder) error { 171 if v == nil { 172 return fmt.Errorf("unsupported serialization of nil %T", v) 173 } 174 175 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 176 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 177 } 178 if v.HostedZoneId != nil { 179 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 180 return err 181 } 182 } 183 184 return nil 185 } 186 187 func awsRestxml_serializeOpDocumentAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput, value smithyxml.Value) error { 188 defer value.Close() 189 if v.Comment != nil { 190 rootAttr := []smithyxml.Attr{} 191 root := smithyxml.StartElement{ 192 Name: smithyxml.Name{ 193 Local: "Comment", 194 }, 195 Attr: rootAttr, 196 } 197 el := value.MemberElement(root) 198 el.String(*v.Comment) 199 } 200 if v.VPC != nil { 201 rootAttr := []smithyxml.Attr{} 202 root := smithyxml.StartElement{ 203 Name: smithyxml.Name{ 204 Local: "VPC", 205 }, 206 Attr: rootAttr, 207 } 208 el := value.MemberElement(root) 209 if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil { 210 return err 211 } 212 } 213 return nil 214 } 215 216 type awsRestxml_serializeOpChangeCidrCollection struct { 217 } 218 219 func (*awsRestxml_serializeOpChangeCidrCollection) ID() string { 220 return "OperationSerializer" 221 } 222 223 func (m *awsRestxml_serializeOpChangeCidrCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 224 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 225 ) { 226 _, span := tracing.StartSpan(ctx, "OperationSerializer") 227 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 228 defer endTimer() 229 defer span.End() 230 request, ok := in.Request.(*smithyhttp.Request) 231 if !ok { 232 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 233 } 234 235 input, ok := in.Parameters.(*ChangeCidrCollectionInput) 236 _ = input 237 if !ok { 238 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 239 } 240 241 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{Id}") 242 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 243 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 244 request.Method = "POST" 245 var restEncoder *httpbinding.Encoder 246 if request.URL.RawPath == "" { 247 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 248 } else { 249 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 250 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 251 } 252 253 if err != nil { 254 return out, metadata, &smithy.SerializationError{Err: err} 255 } 256 257 if err := awsRestxml_serializeOpHttpBindingsChangeCidrCollectionInput(input, restEncoder); err != nil { 258 return out, metadata, &smithy.SerializationError{Err: err} 259 } 260 261 restEncoder.SetHeader("Content-Type").String("application/xml") 262 263 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 264 rootAttr := []smithyxml.Attr{} 265 root := smithyxml.StartElement{ 266 Name: smithyxml.Name{ 267 Local: "ChangeCidrCollectionRequest", 268 }, 269 Attr: rootAttr, 270 } 271 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 272 if err := awsRestxml_serializeOpDocumentChangeCidrCollectionInput(input, xmlEncoder.RootElement(root)); err != nil { 273 return out, metadata, &smithy.SerializationError{Err: err} 274 } 275 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 276 return out, metadata, &smithy.SerializationError{Err: err} 277 } 278 279 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 280 return out, metadata, &smithy.SerializationError{Err: err} 281 } 282 in.Request = request 283 284 endTimer() 285 span.End() 286 return next.HandleSerialize(ctx, in) 287 } 288 func awsRestxml_serializeOpHttpBindingsChangeCidrCollectionInput(v *ChangeCidrCollectionInput, encoder *httpbinding.Encoder) error { 289 if v == nil { 290 return fmt.Errorf("unsupported serialization of nil %T", v) 291 } 292 293 if v.Id == nil || len(*v.Id) == 0 { 294 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 295 } 296 if v.Id != nil { 297 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 298 return err 299 } 300 } 301 302 return nil 303 } 304 305 func awsRestxml_serializeOpDocumentChangeCidrCollectionInput(v *ChangeCidrCollectionInput, value smithyxml.Value) error { 306 defer value.Close() 307 if v.Changes != nil { 308 rootAttr := []smithyxml.Attr{} 309 root := smithyxml.StartElement{ 310 Name: smithyxml.Name{ 311 Local: "Changes", 312 }, 313 Attr: rootAttr, 314 } 315 el := value.MemberElement(root) 316 if err := awsRestxml_serializeDocumentCidrCollectionChanges(v.Changes, el); err != nil { 317 return err 318 } 319 } 320 if v.CollectionVersion != nil { 321 rootAttr := []smithyxml.Attr{} 322 root := smithyxml.StartElement{ 323 Name: smithyxml.Name{ 324 Local: "CollectionVersion", 325 }, 326 Attr: rootAttr, 327 } 328 el := value.MemberElement(root) 329 el.Long(*v.CollectionVersion) 330 } 331 return nil 332 } 333 334 type awsRestxml_serializeOpChangeResourceRecordSets struct { 335 } 336 337 func (*awsRestxml_serializeOpChangeResourceRecordSets) ID() string { 338 return "OperationSerializer" 339 } 340 341 func (m *awsRestxml_serializeOpChangeResourceRecordSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 342 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 343 ) { 344 _, span := tracing.StartSpan(ctx, "OperationSerializer") 345 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 346 defer endTimer() 347 defer span.End() 348 request, ok := in.Request.(*smithyhttp.Request) 349 if !ok { 350 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 351 } 352 353 input, ok := in.Parameters.(*ChangeResourceRecordSetsInput) 354 _ = input 355 if !ok { 356 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 357 } 358 359 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/rrset") 360 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 361 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 362 request.Method = "POST" 363 var restEncoder *httpbinding.Encoder 364 if request.URL.RawPath == "" { 365 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 366 } else { 367 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 368 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 369 } 370 371 if err != nil { 372 return out, metadata, &smithy.SerializationError{Err: err} 373 } 374 375 if err := awsRestxml_serializeOpHttpBindingsChangeResourceRecordSetsInput(input, restEncoder); err != nil { 376 return out, metadata, &smithy.SerializationError{Err: err} 377 } 378 379 restEncoder.SetHeader("Content-Type").String("application/xml") 380 381 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 382 rootAttr := []smithyxml.Attr{} 383 root := smithyxml.StartElement{ 384 Name: smithyxml.Name{ 385 Local: "ChangeResourceRecordSetsRequest", 386 }, 387 Attr: rootAttr, 388 } 389 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 390 if err := awsRestxml_serializeOpDocumentChangeResourceRecordSetsInput(input, xmlEncoder.RootElement(root)); err != nil { 391 return out, metadata, &smithy.SerializationError{Err: err} 392 } 393 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 394 return out, metadata, &smithy.SerializationError{Err: err} 395 } 396 397 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 398 return out, metadata, &smithy.SerializationError{Err: err} 399 } 400 in.Request = request 401 402 endTimer() 403 span.End() 404 return next.HandleSerialize(ctx, in) 405 } 406 func awsRestxml_serializeOpHttpBindingsChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput, encoder *httpbinding.Encoder) error { 407 if v == nil { 408 return fmt.Errorf("unsupported serialization of nil %T", v) 409 } 410 411 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 412 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 413 } 414 if v.HostedZoneId != nil { 415 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 416 return err 417 } 418 } 419 420 return nil 421 } 422 423 func awsRestxml_serializeOpDocumentChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput, value smithyxml.Value) error { 424 defer value.Close() 425 if v.ChangeBatch != nil { 426 rootAttr := []smithyxml.Attr{} 427 root := smithyxml.StartElement{ 428 Name: smithyxml.Name{ 429 Local: "ChangeBatch", 430 }, 431 Attr: rootAttr, 432 } 433 el := value.MemberElement(root) 434 if err := awsRestxml_serializeDocumentChangeBatch(v.ChangeBatch, el); err != nil { 435 return err 436 } 437 } 438 return nil 439 } 440 441 type awsRestxml_serializeOpChangeTagsForResource struct { 442 } 443 444 func (*awsRestxml_serializeOpChangeTagsForResource) ID() string { 445 return "OperationSerializer" 446 } 447 448 func (m *awsRestxml_serializeOpChangeTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 449 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 450 ) { 451 _, span := tracing.StartSpan(ctx, "OperationSerializer") 452 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 453 defer endTimer() 454 defer span.End() 455 request, ok := in.Request.(*smithyhttp.Request) 456 if !ok { 457 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 458 } 459 460 input, ok := in.Parameters.(*ChangeTagsForResourceInput) 461 _ = input 462 if !ok { 463 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 464 } 465 466 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/tags/{ResourceType}/{ResourceId}") 467 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 468 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 469 request.Method = "POST" 470 var restEncoder *httpbinding.Encoder 471 if request.URL.RawPath == "" { 472 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 473 } else { 474 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 475 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 476 } 477 478 if err != nil { 479 return out, metadata, &smithy.SerializationError{Err: err} 480 } 481 482 if err := awsRestxml_serializeOpHttpBindingsChangeTagsForResourceInput(input, restEncoder); err != nil { 483 return out, metadata, &smithy.SerializationError{Err: err} 484 } 485 486 restEncoder.SetHeader("Content-Type").String("application/xml") 487 488 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 489 rootAttr := []smithyxml.Attr{} 490 root := smithyxml.StartElement{ 491 Name: smithyxml.Name{ 492 Local: "ChangeTagsForResourceRequest", 493 }, 494 Attr: rootAttr, 495 } 496 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 497 if err := awsRestxml_serializeOpDocumentChangeTagsForResourceInput(input, xmlEncoder.RootElement(root)); err != nil { 498 return out, metadata, &smithy.SerializationError{Err: err} 499 } 500 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 501 return out, metadata, &smithy.SerializationError{Err: err} 502 } 503 504 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 505 return out, metadata, &smithy.SerializationError{Err: err} 506 } 507 in.Request = request 508 509 endTimer() 510 span.End() 511 return next.HandleSerialize(ctx, in) 512 } 513 func awsRestxml_serializeOpHttpBindingsChangeTagsForResourceInput(v *ChangeTagsForResourceInput, encoder *httpbinding.Encoder) error { 514 if v == nil { 515 return fmt.Errorf("unsupported serialization of nil %T", v) 516 } 517 518 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 519 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 520 } 521 if v.ResourceId != nil { 522 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 523 return err 524 } 525 } 526 527 if len(v.ResourceType) == 0 { 528 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceType must not be empty")} 529 } 530 if len(v.ResourceType) > 0 { 531 if err := encoder.SetURI("ResourceType").String(string(v.ResourceType)); err != nil { 532 return err 533 } 534 } 535 536 return nil 537 } 538 539 func awsRestxml_serializeOpDocumentChangeTagsForResourceInput(v *ChangeTagsForResourceInput, value smithyxml.Value) error { 540 defer value.Close() 541 if v.AddTags != nil { 542 rootAttr := []smithyxml.Attr{} 543 root := smithyxml.StartElement{ 544 Name: smithyxml.Name{ 545 Local: "AddTags", 546 }, 547 Attr: rootAttr, 548 } 549 el := value.MemberElement(root) 550 if err := awsRestxml_serializeDocumentTagList(v.AddTags, el); err != nil { 551 return err 552 } 553 } 554 if v.RemoveTagKeys != nil { 555 rootAttr := []smithyxml.Attr{} 556 root := smithyxml.StartElement{ 557 Name: smithyxml.Name{ 558 Local: "RemoveTagKeys", 559 }, 560 Attr: rootAttr, 561 } 562 el := value.MemberElement(root) 563 if err := awsRestxml_serializeDocumentTagKeyList(v.RemoveTagKeys, el); err != nil { 564 return err 565 } 566 } 567 return nil 568 } 569 570 type awsRestxml_serializeOpCreateCidrCollection struct { 571 } 572 573 func (*awsRestxml_serializeOpCreateCidrCollection) ID() string { 574 return "OperationSerializer" 575 } 576 577 func (m *awsRestxml_serializeOpCreateCidrCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 578 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 579 ) { 580 _, span := tracing.StartSpan(ctx, "OperationSerializer") 581 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 582 defer endTimer() 583 defer span.End() 584 request, ok := in.Request.(*smithyhttp.Request) 585 if !ok { 586 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 587 } 588 589 input, ok := in.Parameters.(*CreateCidrCollectionInput) 590 _ = input 591 if !ok { 592 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 593 } 594 595 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection") 596 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 597 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 598 request.Method = "POST" 599 var restEncoder *httpbinding.Encoder 600 if request.URL.RawPath == "" { 601 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 602 } else { 603 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 604 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 605 } 606 607 if err != nil { 608 return out, metadata, &smithy.SerializationError{Err: err} 609 } 610 611 restEncoder.SetHeader("Content-Type").String("application/xml") 612 613 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 614 rootAttr := []smithyxml.Attr{} 615 root := smithyxml.StartElement{ 616 Name: smithyxml.Name{ 617 Local: "CreateCidrCollectionRequest", 618 }, 619 Attr: rootAttr, 620 } 621 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 622 if err := awsRestxml_serializeOpDocumentCreateCidrCollectionInput(input, xmlEncoder.RootElement(root)); err != nil { 623 return out, metadata, &smithy.SerializationError{Err: err} 624 } 625 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 626 return out, metadata, &smithy.SerializationError{Err: err} 627 } 628 629 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 630 return out, metadata, &smithy.SerializationError{Err: err} 631 } 632 in.Request = request 633 634 endTimer() 635 span.End() 636 return next.HandleSerialize(ctx, in) 637 } 638 func awsRestxml_serializeOpHttpBindingsCreateCidrCollectionInput(v *CreateCidrCollectionInput, encoder *httpbinding.Encoder) error { 639 if v == nil { 640 return fmt.Errorf("unsupported serialization of nil %T", v) 641 } 642 643 return nil 644 } 645 646 func awsRestxml_serializeOpDocumentCreateCidrCollectionInput(v *CreateCidrCollectionInput, value smithyxml.Value) error { 647 defer value.Close() 648 if v.CallerReference != nil { 649 rootAttr := []smithyxml.Attr{} 650 root := smithyxml.StartElement{ 651 Name: smithyxml.Name{ 652 Local: "CallerReference", 653 }, 654 Attr: rootAttr, 655 } 656 el := value.MemberElement(root) 657 el.String(*v.CallerReference) 658 } 659 if v.Name != nil { 660 rootAttr := []smithyxml.Attr{} 661 root := smithyxml.StartElement{ 662 Name: smithyxml.Name{ 663 Local: "Name", 664 }, 665 Attr: rootAttr, 666 } 667 el := value.MemberElement(root) 668 el.String(*v.Name) 669 } 670 return nil 671 } 672 673 type awsRestxml_serializeOpCreateHealthCheck struct { 674 } 675 676 func (*awsRestxml_serializeOpCreateHealthCheck) ID() string { 677 return "OperationSerializer" 678 } 679 680 func (m *awsRestxml_serializeOpCreateHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 681 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 682 ) { 683 _, span := tracing.StartSpan(ctx, "OperationSerializer") 684 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 685 defer endTimer() 686 defer span.End() 687 request, ok := in.Request.(*smithyhttp.Request) 688 if !ok { 689 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 690 } 691 692 input, ok := in.Parameters.(*CreateHealthCheckInput) 693 _ = input 694 if !ok { 695 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 696 } 697 698 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck") 699 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 700 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 701 request.Method = "POST" 702 var restEncoder *httpbinding.Encoder 703 if request.URL.RawPath == "" { 704 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 705 } else { 706 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 707 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 708 } 709 710 if err != nil { 711 return out, metadata, &smithy.SerializationError{Err: err} 712 } 713 714 restEncoder.SetHeader("Content-Type").String("application/xml") 715 716 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 717 rootAttr := []smithyxml.Attr{} 718 root := smithyxml.StartElement{ 719 Name: smithyxml.Name{ 720 Local: "CreateHealthCheckRequest", 721 }, 722 Attr: rootAttr, 723 } 724 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 725 if err := awsRestxml_serializeOpDocumentCreateHealthCheckInput(input, xmlEncoder.RootElement(root)); err != nil { 726 return out, metadata, &smithy.SerializationError{Err: err} 727 } 728 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 729 return out, metadata, &smithy.SerializationError{Err: err} 730 } 731 732 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 733 return out, metadata, &smithy.SerializationError{Err: err} 734 } 735 in.Request = request 736 737 endTimer() 738 span.End() 739 return next.HandleSerialize(ctx, in) 740 } 741 func awsRestxml_serializeOpHttpBindingsCreateHealthCheckInput(v *CreateHealthCheckInput, encoder *httpbinding.Encoder) error { 742 if v == nil { 743 return fmt.Errorf("unsupported serialization of nil %T", v) 744 } 745 746 return nil 747 } 748 749 func awsRestxml_serializeOpDocumentCreateHealthCheckInput(v *CreateHealthCheckInput, value smithyxml.Value) error { 750 defer value.Close() 751 if v.CallerReference != nil { 752 rootAttr := []smithyxml.Attr{} 753 root := smithyxml.StartElement{ 754 Name: smithyxml.Name{ 755 Local: "CallerReference", 756 }, 757 Attr: rootAttr, 758 } 759 el := value.MemberElement(root) 760 el.String(*v.CallerReference) 761 } 762 if v.HealthCheckConfig != nil { 763 rootAttr := []smithyxml.Attr{} 764 root := smithyxml.StartElement{ 765 Name: smithyxml.Name{ 766 Local: "HealthCheckConfig", 767 }, 768 Attr: rootAttr, 769 } 770 el := value.MemberElement(root) 771 if err := awsRestxml_serializeDocumentHealthCheckConfig(v.HealthCheckConfig, el); err != nil { 772 return err 773 } 774 } 775 return nil 776 } 777 778 type awsRestxml_serializeOpCreateHostedZone struct { 779 } 780 781 func (*awsRestxml_serializeOpCreateHostedZone) ID() string { 782 return "OperationSerializer" 783 } 784 785 func (m *awsRestxml_serializeOpCreateHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 786 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 787 ) { 788 _, span := tracing.StartSpan(ctx, "OperationSerializer") 789 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 790 defer endTimer() 791 defer span.End() 792 request, ok := in.Request.(*smithyhttp.Request) 793 if !ok { 794 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 795 } 796 797 input, ok := in.Parameters.(*CreateHostedZoneInput) 798 _ = input 799 if !ok { 800 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 801 } 802 803 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone") 804 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 805 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 806 request.Method = "POST" 807 var restEncoder *httpbinding.Encoder 808 if request.URL.RawPath == "" { 809 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 810 } else { 811 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 812 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 813 } 814 815 if err != nil { 816 return out, metadata, &smithy.SerializationError{Err: err} 817 } 818 819 restEncoder.SetHeader("Content-Type").String("application/xml") 820 821 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 822 rootAttr := []smithyxml.Attr{} 823 root := smithyxml.StartElement{ 824 Name: smithyxml.Name{ 825 Local: "CreateHostedZoneRequest", 826 }, 827 Attr: rootAttr, 828 } 829 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 830 if err := awsRestxml_serializeOpDocumentCreateHostedZoneInput(input, xmlEncoder.RootElement(root)); err != nil { 831 return out, metadata, &smithy.SerializationError{Err: err} 832 } 833 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 834 return out, metadata, &smithy.SerializationError{Err: err} 835 } 836 837 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 838 return out, metadata, &smithy.SerializationError{Err: err} 839 } 840 in.Request = request 841 842 endTimer() 843 span.End() 844 return next.HandleSerialize(ctx, in) 845 } 846 func awsRestxml_serializeOpHttpBindingsCreateHostedZoneInput(v *CreateHostedZoneInput, encoder *httpbinding.Encoder) error { 847 if v == nil { 848 return fmt.Errorf("unsupported serialization of nil %T", v) 849 } 850 851 return nil 852 } 853 854 func awsRestxml_serializeOpDocumentCreateHostedZoneInput(v *CreateHostedZoneInput, value smithyxml.Value) error { 855 defer value.Close() 856 if v.CallerReference != nil { 857 rootAttr := []smithyxml.Attr{} 858 root := smithyxml.StartElement{ 859 Name: smithyxml.Name{ 860 Local: "CallerReference", 861 }, 862 Attr: rootAttr, 863 } 864 el := value.MemberElement(root) 865 el.String(*v.CallerReference) 866 } 867 if v.DelegationSetId != nil { 868 rootAttr := []smithyxml.Attr{} 869 root := smithyxml.StartElement{ 870 Name: smithyxml.Name{ 871 Local: "DelegationSetId", 872 }, 873 Attr: rootAttr, 874 } 875 el := value.MemberElement(root) 876 el.String(*v.DelegationSetId) 877 } 878 if v.HostedZoneConfig != nil { 879 rootAttr := []smithyxml.Attr{} 880 root := smithyxml.StartElement{ 881 Name: smithyxml.Name{ 882 Local: "HostedZoneConfig", 883 }, 884 Attr: rootAttr, 885 } 886 el := value.MemberElement(root) 887 if err := awsRestxml_serializeDocumentHostedZoneConfig(v.HostedZoneConfig, el); err != nil { 888 return err 889 } 890 } 891 if v.Name != nil { 892 rootAttr := []smithyxml.Attr{} 893 root := smithyxml.StartElement{ 894 Name: smithyxml.Name{ 895 Local: "Name", 896 }, 897 Attr: rootAttr, 898 } 899 el := value.MemberElement(root) 900 el.String(*v.Name) 901 } 902 if v.VPC != nil { 903 rootAttr := []smithyxml.Attr{} 904 root := smithyxml.StartElement{ 905 Name: smithyxml.Name{ 906 Local: "VPC", 907 }, 908 Attr: rootAttr, 909 } 910 el := value.MemberElement(root) 911 if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil { 912 return err 913 } 914 } 915 return nil 916 } 917 918 type awsRestxml_serializeOpCreateKeySigningKey struct { 919 } 920 921 func (*awsRestxml_serializeOpCreateKeySigningKey) ID() string { 922 return "OperationSerializer" 923 } 924 925 func (m *awsRestxml_serializeOpCreateKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 926 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 927 ) { 928 _, span := tracing.StartSpan(ctx, "OperationSerializer") 929 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 930 defer endTimer() 931 defer span.End() 932 request, ok := in.Request.(*smithyhttp.Request) 933 if !ok { 934 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 935 } 936 937 input, ok := in.Parameters.(*CreateKeySigningKeyInput) 938 _ = input 939 if !ok { 940 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 941 } 942 943 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey") 944 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 945 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 946 request.Method = "POST" 947 var restEncoder *httpbinding.Encoder 948 if request.URL.RawPath == "" { 949 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 950 } else { 951 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 952 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 953 } 954 955 if err != nil { 956 return out, metadata, &smithy.SerializationError{Err: err} 957 } 958 959 restEncoder.SetHeader("Content-Type").String("application/xml") 960 961 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 962 rootAttr := []smithyxml.Attr{} 963 root := smithyxml.StartElement{ 964 Name: smithyxml.Name{ 965 Local: "CreateKeySigningKeyRequest", 966 }, 967 Attr: rootAttr, 968 } 969 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 970 if err := awsRestxml_serializeOpDocumentCreateKeySigningKeyInput(input, xmlEncoder.RootElement(root)); err != nil { 971 return out, metadata, &smithy.SerializationError{Err: err} 972 } 973 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 974 return out, metadata, &smithy.SerializationError{Err: err} 975 } 976 977 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 978 return out, metadata, &smithy.SerializationError{Err: err} 979 } 980 in.Request = request 981 982 endTimer() 983 span.End() 984 return next.HandleSerialize(ctx, in) 985 } 986 func awsRestxml_serializeOpHttpBindingsCreateKeySigningKeyInput(v *CreateKeySigningKeyInput, encoder *httpbinding.Encoder) error { 987 if v == nil { 988 return fmt.Errorf("unsupported serialization of nil %T", v) 989 } 990 991 return nil 992 } 993 994 func awsRestxml_serializeOpDocumentCreateKeySigningKeyInput(v *CreateKeySigningKeyInput, value smithyxml.Value) error { 995 defer value.Close() 996 if v.CallerReference != nil { 997 rootAttr := []smithyxml.Attr{} 998 root := smithyxml.StartElement{ 999 Name: smithyxml.Name{ 1000 Local: "CallerReference", 1001 }, 1002 Attr: rootAttr, 1003 } 1004 el := value.MemberElement(root) 1005 el.String(*v.CallerReference) 1006 } 1007 if v.HostedZoneId != nil { 1008 rootAttr := []smithyxml.Attr{} 1009 root := smithyxml.StartElement{ 1010 Name: smithyxml.Name{ 1011 Local: "HostedZoneId", 1012 }, 1013 Attr: rootAttr, 1014 } 1015 el := value.MemberElement(root) 1016 el.String(*v.HostedZoneId) 1017 } 1018 if v.KeyManagementServiceArn != nil { 1019 rootAttr := []smithyxml.Attr{} 1020 root := smithyxml.StartElement{ 1021 Name: smithyxml.Name{ 1022 Local: "KeyManagementServiceArn", 1023 }, 1024 Attr: rootAttr, 1025 } 1026 el := value.MemberElement(root) 1027 el.String(*v.KeyManagementServiceArn) 1028 } 1029 if v.Name != nil { 1030 rootAttr := []smithyxml.Attr{} 1031 root := smithyxml.StartElement{ 1032 Name: smithyxml.Name{ 1033 Local: "Name", 1034 }, 1035 Attr: rootAttr, 1036 } 1037 el := value.MemberElement(root) 1038 el.String(*v.Name) 1039 } 1040 if v.Status != nil { 1041 rootAttr := []smithyxml.Attr{} 1042 root := smithyxml.StartElement{ 1043 Name: smithyxml.Name{ 1044 Local: "Status", 1045 }, 1046 Attr: rootAttr, 1047 } 1048 el := value.MemberElement(root) 1049 el.String(*v.Status) 1050 } 1051 return nil 1052 } 1053 1054 type awsRestxml_serializeOpCreateQueryLoggingConfig struct { 1055 } 1056 1057 func (*awsRestxml_serializeOpCreateQueryLoggingConfig) ID() string { 1058 return "OperationSerializer" 1059 } 1060 1061 func (m *awsRestxml_serializeOpCreateQueryLoggingConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1062 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1063 ) { 1064 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1065 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1066 defer endTimer() 1067 defer span.End() 1068 request, ok := in.Request.(*smithyhttp.Request) 1069 if !ok { 1070 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1071 } 1072 1073 input, ok := in.Parameters.(*CreateQueryLoggingConfigInput) 1074 _ = input 1075 if !ok { 1076 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1077 } 1078 1079 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig") 1080 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1081 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1082 request.Method = "POST" 1083 var restEncoder *httpbinding.Encoder 1084 if request.URL.RawPath == "" { 1085 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1086 } else { 1087 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1088 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1089 } 1090 1091 if err != nil { 1092 return out, metadata, &smithy.SerializationError{Err: err} 1093 } 1094 1095 restEncoder.SetHeader("Content-Type").String("application/xml") 1096 1097 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 1098 rootAttr := []smithyxml.Attr{} 1099 root := smithyxml.StartElement{ 1100 Name: smithyxml.Name{ 1101 Local: "CreateQueryLoggingConfigRequest", 1102 }, 1103 Attr: rootAttr, 1104 } 1105 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 1106 if err := awsRestxml_serializeOpDocumentCreateQueryLoggingConfigInput(input, xmlEncoder.RootElement(root)); err != nil { 1107 return out, metadata, &smithy.SerializationError{Err: err} 1108 } 1109 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 1110 return out, metadata, &smithy.SerializationError{Err: err} 1111 } 1112 1113 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1114 return out, metadata, &smithy.SerializationError{Err: err} 1115 } 1116 in.Request = request 1117 1118 endTimer() 1119 span.End() 1120 return next.HandleSerialize(ctx, in) 1121 } 1122 func awsRestxml_serializeOpHttpBindingsCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput, encoder *httpbinding.Encoder) error { 1123 if v == nil { 1124 return fmt.Errorf("unsupported serialization of nil %T", v) 1125 } 1126 1127 return nil 1128 } 1129 1130 func awsRestxml_serializeOpDocumentCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput, value smithyxml.Value) error { 1131 defer value.Close() 1132 if v.CloudWatchLogsLogGroupArn != nil { 1133 rootAttr := []smithyxml.Attr{} 1134 root := smithyxml.StartElement{ 1135 Name: smithyxml.Name{ 1136 Local: "CloudWatchLogsLogGroupArn", 1137 }, 1138 Attr: rootAttr, 1139 } 1140 el := value.MemberElement(root) 1141 el.String(*v.CloudWatchLogsLogGroupArn) 1142 } 1143 if v.HostedZoneId != nil { 1144 rootAttr := []smithyxml.Attr{} 1145 root := smithyxml.StartElement{ 1146 Name: smithyxml.Name{ 1147 Local: "HostedZoneId", 1148 }, 1149 Attr: rootAttr, 1150 } 1151 el := value.MemberElement(root) 1152 el.String(*v.HostedZoneId) 1153 } 1154 return nil 1155 } 1156 1157 type awsRestxml_serializeOpCreateReusableDelegationSet struct { 1158 } 1159 1160 func (*awsRestxml_serializeOpCreateReusableDelegationSet) ID() string { 1161 return "OperationSerializer" 1162 } 1163 1164 func (m *awsRestxml_serializeOpCreateReusableDelegationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1165 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1166 ) { 1167 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1168 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1169 defer endTimer() 1170 defer span.End() 1171 request, ok := in.Request.(*smithyhttp.Request) 1172 if !ok { 1173 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1174 } 1175 1176 input, ok := in.Parameters.(*CreateReusableDelegationSetInput) 1177 _ = input 1178 if !ok { 1179 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1180 } 1181 1182 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset") 1183 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1184 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1185 request.Method = "POST" 1186 var restEncoder *httpbinding.Encoder 1187 if request.URL.RawPath == "" { 1188 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1189 } else { 1190 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1191 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1192 } 1193 1194 if err != nil { 1195 return out, metadata, &smithy.SerializationError{Err: err} 1196 } 1197 1198 restEncoder.SetHeader("Content-Type").String("application/xml") 1199 1200 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 1201 rootAttr := []smithyxml.Attr{} 1202 root := smithyxml.StartElement{ 1203 Name: smithyxml.Name{ 1204 Local: "CreateReusableDelegationSetRequest", 1205 }, 1206 Attr: rootAttr, 1207 } 1208 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 1209 if err := awsRestxml_serializeOpDocumentCreateReusableDelegationSetInput(input, xmlEncoder.RootElement(root)); err != nil { 1210 return out, metadata, &smithy.SerializationError{Err: err} 1211 } 1212 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 1213 return out, metadata, &smithy.SerializationError{Err: err} 1214 } 1215 1216 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1217 return out, metadata, &smithy.SerializationError{Err: err} 1218 } 1219 in.Request = request 1220 1221 endTimer() 1222 span.End() 1223 return next.HandleSerialize(ctx, in) 1224 } 1225 func awsRestxml_serializeOpHttpBindingsCreateReusableDelegationSetInput(v *CreateReusableDelegationSetInput, encoder *httpbinding.Encoder) error { 1226 if v == nil { 1227 return fmt.Errorf("unsupported serialization of nil %T", v) 1228 } 1229 1230 return nil 1231 } 1232 1233 func awsRestxml_serializeOpDocumentCreateReusableDelegationSetInput(v *CreateReusableDelegationSetInput, value smithyxml.Value) error { 1234 defer value.Close() 1235 if v.CallerReference != nil { 1236 rootAttr := []smithyxml.Attr{} 1237 root := smithyxml.StartElement{ 1238 Name: smithyxml.Name{ 1239 Local: "CallerReference", 1240 }, 1241 Attr: rootAttr, 1242 } 1243 el := value.MemberElement(root) 1244 el.String(*v.CallerReference) 1245 } 1246 if v.HostedZoneId != nil { 1247 rootAttr := []smithyxml.Attr{} 1248 root := smithyxml.StartElement{ 1249 Name: smithyxml.Name{ 1250 Local: "HostedZoneId", 1251 }, 1252 Attr: rootAttr, 1253 } 1254 el := value.MemberElement(root) 1255 el.String(*v.HostedZoneId) 1256 } 1257 return nil 1258 } 1259 1260 type awsRestxml_serializeOpCreateTrafficPolicy struct { 1261 } 1262 1263 func (*awsRestxml_serializeOpCreateTrafficPolicy) ID() string { 1264 return "OperationSerializer" 1265 } 1266 1267 func (m *awsRestxml_serializeOpCreateTrafficPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1268 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1269 ) { 1270 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1271 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1272 defer endTimer() 1273 defer span.End() 1274 request, ok := in.Request.(*smithyhttp.Request) 1275 if !ok { 1276 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1277 } 1278 1279 input, ok := in.Parameters.(*CreateTrafficPolicyInput) 1280 _ = input 1281 if !ok { 1282 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1283 } 1284 1285 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy") 1286 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1287 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1288 request.Method = "POST" 1289 var restEncoder *httpbinding.Encoder 1290 if request.URL.RawPath == "" { 1291 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1292 } else { 1293 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1294 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1295 } 1296 1297 if err != nil { 1298 return out, metadata, &smithy.SerializationError{Err: err} 1299 } 1300 1301 restEncoder.SetHeader("Content-Type").String("application/xml") 1302 1303 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 1304 rootAttr := []smithyxml.Attr{} 1305 root := smithyxml.StartElement{ 1306 Name: smithyxml.Name{ 1307 Local: "CreateTrafficPolicyRequest", 1308 }, 1309 Attr: rootAttr, 1310 } 1311 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 1312 if err := awsRestxml_serializeOpDocumentCreateTrafficPolicyInput(input, xmlEncoder.RootElement(root)); err != nil { 1313 return out, metadata, &smithy.SerializationError{Err: err} 1314 } 1315 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 1316 return out, metadata, &smithy.SerializationError{Err: err} 1317 } 1318 1319 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1320 return out, metadata, &smithy.SerializationError{Err: err} 1321 } 1322 in.Request = request 1323 1324 endTimer() 1325 span.End() 1326 return next.HandleSerialize(ctx, in) 1327 } 1328 func awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyInput(v *CreateTrafficPolicyInput, encoder *httpbinding.Encoder) error { 1329 if v == nil { 1330 return fmt.Errorf("unsupported serialization of nil %T", v) 1331 } 1332 1333 return nil 1334 } 1335 1336 func awsRestxml_serializeOpDocumentCreateTrafficPolicyInput(v *CreateTrafficPolicyInput, value smithyxml.Value) error { 1337 defer value.Close() 1338 if v.Comment != nil { 1339 rootAttr := []smithyxml.Attr{} 1340 root := smithyxml.StartElement{ 1341 Name: smithyxml.Name{ 1342 Local: "Comment", 1343 }, 1344 Attr: rootAttr, 1345 } 1346 el := value.MemberElement(root) 1347 el.String(*v.Comment) 1348 } 1349 if v.Document != nil { 1350 rootAttr := []smithyxml.Attr{} 1351 root := smithyxml.StartElement{ 1352 Name: smithyxml.Name{ 1353 Local: "Document", 1354 }, 1355 Attr: rootAttr, 1356 } 1357 el := value.MemberElement(root) 1358 el.String(*v.Document) 1359 } 1360 if v.Name != nil { 1361 rootAttr := []smithyxml.Attr{} 1362 root := smithyxml.StartElement{ 1363 Name: smithyxml.Name{ 1364 Local: "Name", 1365 }, 1366 Attr: rootAttr, 1367 } 1368 el := value.MemberElement(root) 1369 el.String(*v.Name) 1370 } 1371 return nil 1372 } 1373 1374 type awsRestxml_serializeOpCreateTrafficPolicyInstance struct { 1375 } 1376 1377 func (*awsRestxml_serializeOpCreateTrafficPolicyInstance) ID() string { 1378 return "OperationSerializer" 1379 } 1380 1381 func (m *awsRestxml_serializeOpCreateTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1382 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1383 ) { 1384 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1385 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1386 defer endTimer() 1387 defer span.End() 1388 request, ok := in.Request.(*smithyhttp.Request) 1389 if !ok { 1390 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1391 } 1392 1393 input, ok := in.Parameters.(*CreateTrafficPolicyInstanceInput) 1394 _ = input 1395 if !ok { 1396 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1397 } 1398 1399 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance") 1400 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1401 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1402 request.Method = "POST" 1403 var restEncoder *httpbinding.Encoder 1404 if request.URL.RawPath == "" { 1405 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1406 } else { 1407 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1408 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1409 } 1410 1411 if err != nil { 1412 return out, metadata, &smithy.SerializationError{Err: err} 1413 } 1414 1415 restEncoder.SetHeader("Content-Type").String("application/xml") 1416 1417 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 1418 rootAttr := []smithyxml.Attr{} 1419 root := smithyxml.StartElement{ 1420 Name: smithyxml.Name{ 1421 Local: "CreateTrafficPolicyInstanceRequest", 1422 }, 1423 Attr: rootAttr, 1424 } 1425 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 1426 if err := awsRestxml_serializeOpDocumentCreateTrafficPolicyInstanceInput(input, xmlEncoder.RootElement(root)); err != nil { 1427 return out, metadata, &smithy.SerializationError{Err: err} 1428 } 1429 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 1430 return out, metadata, &smithy.SerializationError{Err: err} 1431 } 1432 1433 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1434 return out, metadata, &smithy.SerializationError{Err: err} 1435 } 1436 in.Request = request 1437 1438 endTimer() 1439 span.End() 1440 return next.HandleSerialize(ctx, in) 1441 } 1442 func awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error { 1443 if v == nil { 1444 return fmt.Errorf("unsupported serialization of nil %T", v) 1445 } 1446 1447 return nil 1448 } 1449 1450 func awsRestxml_serializeOpDocumentCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput, value smithyxml.Value) error { 1451 defer value.Close() 1452 if v.HostedZoneId != nil { 1453 rootAttr := []smithyxml.Attr{} 1454 root := smithyxml.StartElement{ 1455 Name: smithyxml.Name{ 1456 Local: "HostedZoneId", 1457 }, 1458 Attr: rootAttr, 1459 } 1460 el := value.MemberElement(root) 1461 el.String(*v.HostedZoneId) 1462 } 1463 if v.Name != nil { 1464 rootAttr := []smithyxml.Attr{} 1465 root := smithyxml.StartElement{ 1466 Name: smithyxml.Name{ 1467 Local: "Name", 1468 }, 1469 Attr: rootAttr, 1470 } 1471 el := value.MemberElement(root) 1472 el.String(*v.Name) 1473 } 1474 if v.TrafficPolicyId != nil { 1475 rootAttr := []smithyxml.Attr{} 1476 root := smithyxml.StartElement{ 1477 Name: smithyxml.Name{ 1478 Local: "TrafficPolicyId", 1479 }, 1480 Attr: rootAttr, 1481 } 1482 el := value.MemberElement(root) 1483 el.String(*v.TrafficPolicyId) 1484 } 1485 if v.TrafficPolicyVersion != nil { 1486 rootAttr := []smithyxml.Attr{} 1487 root := smithyxml.StartElement{ 1488 Name: smithyxml.Name{ 1489 Local: "TrafficPolicyVersion", 1490 }, 1491 Attr: rootAttr, 1492 } 1493 el := value.MemberElement(root) 1494 el.Integer(*v.TrafficPolicyVersion) 1495 } 1496 if v.TTL != nil { 1497 rootAttr := []smithyxml.Attr{} 1498 root := smithyxml.StartElement{ 1499 Name: smithyxml.Name{ 1500 Local: "TTL", 1501 }, 1502 Attr: rootAttr, 1503 } 1504 el := value.MemberElement(root) 1505 el.Long(*v.TTL) 1506 } 1507 return nil 1508 } 1509 1510 type awsRestxml_serializeOpCreateTrafficPolicyVersion struct { 1511 } 1512 1513 func (*awsRestxml_serializeOpCreateTrafficPolicyVersion) ID() string { 1514 return "OperationSerializer" 1515 } 1516 1517 func (m *awsRestxml_serializeOpCreateTrafficPolicyVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1518 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1519 ) { 1520 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1521 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1522 defer endTimer() 1523 defer span.End() 1524 request, ok := in.Request.(*smithyhttp.Request) 1525 if !ok { 1526 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1527 } 1528 1529 input, ok := in.Parameters.(*CreateTrafficPolicyVersionInput) 1530 _ = input 1531 if !ok { 1532 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1533 } 1534 1535 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}") 1536 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1537 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1538 request.Method = "POST" 1539 var restEncoder *httpbinding.Encoder 1540 if request.URL.RawPath == "" { 1541 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1542 } else { 1543 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1544 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1545 } 1546 1547 if err != nil { 1548 return out, metadata, &smithy.SerializationError{Err: err} 1549 } 1550 1551 if err := awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyVersionInput(input, restEncoder); err != nil { 1552 return out, metadata, &smithy.SerializationError{Err: err} 1553 } 1554 1555 restEncoder.SetHeader("Content-Type").String("application/xml") 1556 1557 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 1558 rootAttr := []smithyxml.Attr{} 1559 root := smithyxml.StartElement{ 1560 Name: smithyxml.Name{ 1561 Local: "CreateTrafficPolicyVersionRequest", 1562 }, 1563 Attr: rootAttr, 1564 } 1565 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 1566 if err := awsRestxml_serializeOpDocumentCreateTrafficPolicyVersionInput(input, xmlEncoder.RootElement(root)); err != nil { 1567 return out, metadata, &smithy.SerializationError{Err: err} 1568 } 1569 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 1570 return out, metadata, &smithy.SerializationError{Err: err} 1571 } 1572 1573 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1574 return out, metadata, &smithy.SerializationError{Err: err} 1575 } 1576 in.Request = request 1577 1578 endTimer() 1579 span.End() 1580 return next.HandleSerialize(ctx, in) 1581 } 1582 func awsRestxml_serializeOpHttpBindingsCreateTrafficPolicyVersionInput(v *CreateTrafficPolicyVersionInput, encoder *httpbinding.Encoder) error { 1583 if v == nil { 1584 return fmt.Errorf("unsupported serialization of nil %T", v) 1585 } 1586 1587 if v.Id == nil || len(*v.Id) == 0 { 1588 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 1589 } 1590 if v.Id != nil { 1591 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 1592 return err 1593 } 1594 } 1595 1596 return nil 1597 } 1598 1599 func awsRestxml_serializeOpDocumentCreateTrafficPolicyVersionInput(v *CreateTrafficPolicyVersionInput, value smithyxml.Value) error { 1600 defer value.Close() 1601 if v.Comment != nil { 1602 rootAttr := []smithyxml.Attr{} 1603 root := smithyxml.StartElement{ 1604 Name: smithyxml.Name{ 1605 Local: "Comment", 1606 }, 1607 Attr: rootAttr, 1608 } 1609 el := value.MemberElement(root) 1610 el.String(*v.Comment) 1611 } 1612 if v.Document != nil { 1613 rootAttr := []smithyxml.Attr{} 1614 root := smithyxml.StartElement{ 1615 Name: smithyxml.Name{ 1616 Local: "Document", 1617 }, 1618 Attr: rootAttr, 1619 } 1620 el := value.MemberElement(root) 1621 el.String(*v.Document) 1622 } 1623 return nil 1624 } 1625 1626 type awsRestxml_serializeOpCreateVPCAssociationAuthorization struct { 1627 } 1628 1629 func (*awsRestxml_serializeOpCreateVPCAssociationAuthorization) ID() string { 1630 return "OperationSerializer" 1631 } 1632 1633 func (m *awsRestxml_serializeOpCreateVPCAssociationAuthorization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1634 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1635 ) { 1636 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1637 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1638 defer endTimer() 1639 defer span.End() 1640 request, ok := in.Request.(*smithyhttp.Request) 1641 if !ok { 1642 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1643 } 1644 1645 input, ok := in.Parameters.(*CreateVPCAssociationAuthorizationInput) 1646 _ = input 1647 if !ok { 1648 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1649 } 1650 1651 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation") 1652 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1653 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1654 request.Method = "POST" 1655 var restEncoder *httpbinding.Encoder 1656 if request.URL.RawPath == "" { 1657 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1658 } else { 1659 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1660 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1661 } 1662 1663 if err != nil { 1664 return out, metadata, &smithy.SerializationError{Err: err} 1665 } 1666 1667 if err := awsRestxml_serializeOpHttpBindingsCreateVPCAssociationAuthorizationInput(input, restEncoder); err != nil { 1668 return out, metadata, &smithy.SerializationError{Err: err} 1669 } 1670 1671 restEncoder.SetHeader("Content-Type").String("application/xml") 1672 1673 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 1674 rootAttr := []smithyxml.Attr{} 1675 root := smithyxml.StartElement{ 1676 Name: smithyxml.Name{ 1677 Local: "CreateVPCAssociationAuthorizationRequest", 1678 }, 1679 Attr: rootAttr, 1680 } 1681 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 1682 if err := awsRestxml_serializeOpDocumentCreateVPCAssociationAuthorizationInput(input, xmlEncoder.RootElement(root)); err != nil { 1683 return out, metadata, &smithy.SerializationError{Err: err} 1684 } 1685 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 1686 return out, metadata, &smithy.SerializationError{Err: err} 1687 } 1688 1689 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1690 return out, metadata, &smithy.SerializationError{Err: err} 1691 } 1692 in.Request = request 1693 1694 endTimer() 1695 span.End() 1696 return next.HandleSerialize(ctx, in) 1697 } 1698 func awsRestxml_serializeOpHttpBindingsCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput, encoder *httpbinding.Encoder) error { 1699 if v == nil { 1700 return fmt.Errorf("unsupported serialization of nil %T", v) 1701 } 1702 1703 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 1704 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 1705 } 1706 if v.HostedZoneId != nil { 1707 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 1708 return err 1709 } 1710 } 1711 1712 return nil 1713 } 1714 1715 func awsRestxml_serializeOpDocumentCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput, value smithyxml.Value) error { 1716 defer value.Close() 1717 if v.VPC != nil { 1718 rootAttr := []smithyxml.Attr{} 1719 root := smithyxml.StartElement{ 1720 Name: smithyxml.Name{ 1721 Local: "VPC", 1722 }, 1723 Attr: rootAttr, 1724 } 1725 el := value.MemberElement(root) 1726 if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil { 1727 return err 1728 } 1729 } 1730 return nil 1731 } 1732 1733 type awsRestxml_serializeOpDeactivateKeySigningKey struct { 1734 } 1735 1736 func (*awsRestxml_serializeOpDeactivateKeySigningKey) ID() string { 1737 return "OperationSerializer" 1738 } 1739 1740 func (m *awsRestxml_serializeOpDeactivateKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1741 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1742 ) { 1743 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1744 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1745 defer endTimer() 1746 defer span.End() 1747 request, ok := in.Request.(*smithyhttp.Request) 1748 if !ok { 1749 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1750 } 1751 1752 input, ok := in.Parameters.(*DeactivateKeySigningKeyInput) 1753 _ = input 1754 if !ok { 1755 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1756 } 1757 1758 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/deactivate") 1759 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1760 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1761 request.Method = "POST" 1762 var restEncoder *httpbinding.Encoder 1763 if request.URL.RawPath == "" { 1764 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1765 } else { 1766 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1767 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1768 } 1769 1770 if err != nil { 1771 return out, metadata, &smithy.SerializationError{Err: err} 1772 } 1773 1774 if err := awsRestxml_serializeOpHttpBindingsDeactivateKeySigningKeyInput(input, restEncoder); err != nil { 1775 return out, metadata, &smithy.SerializationError{Err: err} 1776 } 1777 1778 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1779 return out, metadata, &smithy.SerializationError{Err: err} 1780 } 1781 in.Request = request 1782 1783 endTimer() 1784 span.End() 1785 return next.HandleSerialize(ctx, in) 1786 } 1787 func awsRestxml_serializeOpHttpBindingsDeactivateKeySigningKeyInput(v *DeactivateKeySigningKeyInput, encoder *httpbinding.Encoder) error { 1788 if v == nil { 1789 return fmt.Errorf("unsupported serialization of nil %T", v) 1790 } 1791 1792 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 1793 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 1794 } 1795 if v.HostedZoneId != nil { 1796 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 1797 return err 1798 } 1799 } 1800 1801 if v.Name == nil || len(*v.Name) == 0 { 1802 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1803 } 1804 if v.Name != nil { 1805 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1806 return err 1807 } 1808 } 1809 1810 return nil 1811 } 1812 1813 type awsRestxml_serializeOpDeleteCidrCollection struct { 1814 } 1815 1816 func (*awsRestxml_serializeOpDeleteCidrCollection) ID() string { 1817 return "OperationSerializer" 1818 } 1819 1820 func (m *awsRestxml_serializeOpDeleteCidrCollection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1821 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1822 ) { 1823 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1824 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1825 defer endTimer() 1826 defer span.End() 1827 request, ok := in.Request.(*smithyhttp.Request) 1828 if !ok { 1829 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1830 } 1831 1832 input, ok := in.Parameters.(*DeleteCidrCollectionInput) 1833 _ = input 1834 if !ok { 1835 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1836 } 1837 1838 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{Id}") 1839 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1840 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1841 request.Method = "DELETE" 1842 var restEncoder *httpbinding.Encoder 1843 if request.URL.RawPath == "" { 1844 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1845 } else { 1846 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1847 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1848 } 1849 1850 if err != nil { 1851 return out, metadata, &smithy.SerializationError{Err: err} 1852 } 1853 1854 if err := awsRestxml_serializeOpHttpBindingsDeleteCidrCollectionInput(input, restEncoder); err != nil { 1855 return out, metadata, &smithy.SerializationError{Err: err} 1856 } 1857 1858 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1859 return out, metadata, &smithy.SerializationError{Err: err} 1860 } 1861 in.Request = request 1862 1863 endTimer() 1864 span.End() 1865 return next.HandleSerialize(ctx, in) 1866 } 1867 func awsRestxml_serializeOpHttpBindingsDeleteCidrCollectionInput(v *DeleteCidrCollectionInput, encoder *httpbinding.Encoder) error { 1868 if v == nil { 1869 return fmt.Errorf("unsupported serialization of nil %T", v) 1870 } 1871 1872 if v.Id == nil || len(*v.Id) == 0 { 1873 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 1874 } 1875 if v.Id != nil { 1876 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 1877 return err 1878 } 1879 } 1880 1881 return nil 1882 } 1883 1884 type awsRestxml_serializeOpDeleteHealthCheck struct { 1885 } 1886 1887 func (*awsRestxml_serializeOpDeleteHealthCheck) ID() string { 1888 return "OperationSerializer" 1889 } 1890 1891 func (m *awsRestxml_serializeOpDeleteHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1892 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1893 ) { 1894 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1895 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1896 defer endTimer() 1897 defer span.End() 1898 request, ok := in.Request.(*smithyhttp.Request) 1899 if !ok { 1900 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1901 } 1902 1903 input, ok := in.Parameters.(*DeleteHealthCheckInput) 1904 _ = input 1905 if !ok { 1906 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1907 } 1908 1909 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}") 1910 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1911 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1912 request.Method = "DELETE" 1913 var restEncoder *httpbinding.Encoder 1914 if request.URL.RawPath == "" { 1915 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1916 } else { 1917 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1918 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1919 } 1920 1921 if err != nil { 1922 return out, metadata, &smithy.SerializationError{Err: err} 1923 } 1924 1925 if err := awsRestxml_serializeOpHttpBindingsDeleteHealthCheckInput(input, restEncoder); err != nil { 1926 return out, metadata, &smithy.SerializationError{Err: err} 1927 } 1928 1929 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1930 return out, metadata, &smithy.SerializationError{Err: err} 1931 } 1932 in.Request = request 1933 1934 endTimer() 1935 span.End() 1936 return next.HandleSerialize(ctx, in) 1937 } 1938 func awsRestxml_serializeOpHttpBindingsDeleteHealthCheckInput(v *DeleteHealthCheckInput, encoder *httpbinding.Encoder) error { 1939 if v == nil { 1940 return fmt.Errorf("unsupported serialization of nil %T", v) 1941 } 1942 1943 if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 { 1944 return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")} 1945 } 1946 if v.HealthCheckId != nil { 1947 if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil { 1948 return err 1949 } 1950 } 1951 1952 return nil 1953 } 1954 1955 type awsRestxml_serializeOpDeleteHostedZone struct { 1956 } 1957 1958 func (*awsRestxml_serializeOpDeleteHostedZone) ID() string { 1959 return "OperationSerializer" 1960 } 1961 1962 func (m *awsRestxml_serializeOpDeleteHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1963 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1964 ) { 1965 _, span := tracing.StartSpan(ctx, "OperationSerializer") 1966 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 1967 defer endTimer() 1968 defer span.End() 1969 request, ok := in.Request.(*smithyhttp.Request) 1970 if !ok { 1971 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1972 } 1973 1974 input, ok := in.Parameters.(*DeleteHostedZoneInput) 1975 _ = input 1976 if !ok { 1977 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1978 } 1979 1980 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{Id}") 1981 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1982 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1983 request.Method = "DELETE" 1984 var restEncoder *httpbinding.Encoder 1985 if request.URL.RawPath == "" { 1986 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1987 } else { 1988 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 1989 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 1990 } 1991 1992 if err != nil { 1993 return out, metadata, &smithy.SerializationError{Err: err} 1994 } 1995 1996 if err := awsRestxml_serializeOpHttpBindingsDeleteHostedZoneInput(input, restEncoder); err != nil { 1997 return out, metadata, &smithy.SerializationError{Err: err} 1998 } 1999 2000 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2001 return out, metadata, &smithy.SerializationError{Err: err} 2002 } 2003 in.Request = request 2004 2005 endTimer() 2006 span.End() 2007 return next.HandleSerialize(ctx, in) 2008 } 2009 func awsRestxml_serializeOpHttpBindingsDeleteHostedZoneInput(v *DeleteHostedZoneInput, encoder *httpbinding.Encoder) error { 2010 if v == nil { 2011 return fmt.Errorf("unsupported serialization of nil %T", v) 2012 } 2013 2014 if v.Id == nil || len(*v.Id) == 0 { 2015 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 2016 } 2017 if v.Id != nil { 2018 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 2019 return err 2020 } 2021 } 2022 2023 return nil 2024 } 2025 2026 type awsRestxml_serializeOpDeleteKeySigningKey struct { 2027 } 2028 2029 func (*awsRestxml_serializeOpDeleteKeySigningKey) ID() string { 2030 return "OperationSerializer" 2031 } 2032 2033 func (m *awsRestxml_serializeOpDeleteKeySigningKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2034 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2035 ) { 2036 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2037 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2038 defer endTimer() 2039 defer span.End() 2040 request, ok := in.Request.(*smithyhttp.Request) 2041 if !ok { 2042 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2043 } 2044 2045 input, ok := in.Parameters.(*DeleteKeySigningKeyInput) 2046 _ = input 2047 if !ok { 2048 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2049 } 2050 2051 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/keysigningkey/{HostedZoneId}/{Name}") 2052 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2053 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2054 request.Method = "DELETE" 2055 var restEncoder *httpbinding.Encoder 2056 if request.URL.RawPath == "" { 2057 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2058 } else { 2059 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2060 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2061 } 2062 2063 if err != nil { 2064 return out, metadata, &smithy.SerializationError{Err: err} 2065 } 2066 2067 if err := awsRestxml_serializeOpHttpBindingsDeleteKeySigningKeyInput(input, restEncoder); err != nil { 2068 return out, metadata, &smithy.SerializationError{Err: err} 2069 } 2070 2071 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2072 return out, metadata, &smithy.SerializationError{Err: err} 2073 } 2074 in.Request = request 2075 2076 endTimer() 2077 span.End() 2078 return next.HandleSerialize(ctx, in) 2079 } 2080 func awsRestxml_serializeOpHttpBindingsDeleteKeySigningKeyInput(v *DeleteKeySigningKeyInput, encoder *httpbinding.Encoder) error { 2081 if v == nil { 2082 return fmt.Errorf("unsupported serialization of nil %T", v) 2083 } 2084 2085 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 2086 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 2087 } 2088 if v.HostedZoneId != nil { 2089 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 2090 return err 2091 } 2092 } 2093 2094 if v.Name == nil || len(*v.Name) == 0 { 2095 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2096 } 2097 if v.Name != nil { 2098 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2099 return err 2100 } 2101 } 2102 2103 return nil 2104 } 2105 2106 type awsRestxml_serializeOpDeleteQueryLoggingConfig struct { 2107 } 2108 2109 func (*awsRestxml_serializeOpDeleteQueryLoggingConfig) ID() string { 2110 return "OperationSerializer" 2111 } 2112 2113 func (m *awsRestxml_serializeOpDeleteQueryLoggingConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2114 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2115 ) { 2116 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2117 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2118 defer endTimer() 2119 defer span.End() 2120 request, ok := in.Request.(*smithyhttp.Request) 2121 if !ok { 2122 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2123 } 2124 2125 input, ok := in.Parameters.(*DeleteQueryLoggingConfigInput) 2126 _ = input 2127 if !ok { 2128 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2129 } 2130 2131 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig/{Id}") 2132 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2133 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2134 request.Method = "DELETE" 2135 var restEncoder *httpbinding.Encoder 2136 if request.URL.RawPath == "" { 2137 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2138 } else { 2139 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2140 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2141 } 2142 2143 if err != nil { 2144 return out, metadata, &smithy.SerializationError{Err: err} 2145 } 2146 2147 if err := awsRestxml_serializeOpHttpBindingsDeleteQueryLoggingConfigInput(input, restEncoder); err != nil { 2148 return out, metadata, &smithy.SerializationError{Err: err} 2149 } 2150 2151 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2152 return out, metadata, &smithy.SerializationError{Err: err} 2153 } 2154 in.Request = request 2155 2156 endTimer() 2157 span.End() 2158 return next.HandleSerialize(ctx, in) 2159 } 2160 func awsRestxml_serializeOpHttpBindingsDeleteQueryLoggingConfigInput(v *DeleteQueryLoggingConfigInput, encoder *httpbinding.Encoder) error { 2161 if v == nil { 2162 return fmt.Errorf("unsupported serialization of nil %T", v) 2163 } 2164 2165 if v.Id == nil || len(*v.Id) == 0 { 2166 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 2167 } 2168 if v.Id != nil { 2169 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 2170 return err 2171 } 2172 } 2173 2174 return nil 2175 } 2176 2177 type awsRestxml_serializeOpDeleteReusableDelegationSet struct { 2178 } 2179 2180 func (*awsRestxml_serializeOpDeleteReusableDelegationSet) ID() string { 2181 return "OperationSerializer" 2182 } 2183 2184 func (m *awsRestxml_serializeOpDeleteReusableDelegationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2185 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2186 ) { 2187 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2188 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2189 defer endTimer() 2190 defer span.End() 2191 request, ok := in.Request.(*smithyhttp.Request) 2192 if !ok { 2193 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2194 } 2195 2196 input, ok := in.Parameters.(*DeleteReusableDelegationSetInput) 2197 _ = input 2198 if !ok { 2199 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2200 } 2201 2202 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset/{Id}") 2203 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2204 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2205 request.Method = "DELETE" 2206 var restEncoder *httpbinding.Encoder 2207 if request.URL.RawPath == "" { 2208 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2209 } else { 2210 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2211 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2212 } 2213 2214 if err != nil { 2215 return out, metadata, &smithy.SerializationError{Err: err} 2216 } 2217 2218 if err := awsRestxml_serializeOpHttpBindingsDeleteReusableDelegationSetInput(input, restEncoder); err != nil { 2219 return out, metadata, &smithy.SerializationError{Err: err} 2220 } 2221 2222 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2223 return out, metadata, &smithy.SerializationError{Err: err} 2224 } 2225 in.Request = request 2226 2227 endTimer() 2228 span.End() 2229 return next.HandleSerialize(ctx, in) 2230 } 2231 func awsRestxml_serializeOpHttpBindingsDeleteReusableDelegationSetInput(v *DeleteReusableDelegationSetInput, encoder *httpbinding.Encoder) error { 2232 if v == nil { 2233 return fmt.Errorf("unsupported serialization of nil %T", v) 2234 } 2235 2236 if v.Id == nil || len(*v.Id) == 0 { 2237 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 2238 } 2239 if v.Id != nil { 2240 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 2241 return err 2242 } 2243 } 2244 2245 return nil 2246 } 2247 2248 type awsRestxml_serializeOpDeleteTrafficPolicy struct { 2249 } 2250 2251 func (*awsRestxml_serializeOpDeleteTrafficPolicy) ID() string { 2252 return "OperationSerializer" 2253 } 2254 2255 func (m *awsRestxml_serializeOpDeleteTrafficPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2256 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2257 ) { 2258 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2259 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2260 defer endTimer() 2261 defer span.End() 2262 request, ok := in.Request.(*smithyhttp.Request) 2263 if !ok { 2264 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2265 } 2266 2267 input, ok := in.Parameters.(*DeleteTrafficPolicyInput) 2268 _ = input 2269 if !ok { 2270 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2271 } 2272 2273 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}/{Version}") 2274 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2275 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2276 request.Method = "DELETE" 2277 var restEncoder *httpbinding.Encoder 2278 if request.URL.RawPath == "" { 2279 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2280 } else { 2281 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2282 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2283 } 2284 2285 if err != nil { 2286 return out, metadata, &smithy.SerializationError{Err: err} 2287 } 2288 2289 if err := awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInput(input, restEncoder); err != nil { 2290 return out, metadata, &smithy.SerializationError{Err: err} 2291 } 2292 2293 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2294 return out, metadata, &smithy.SerializationError{Err: err} 2295 } 2296 in.Request = request 2297 2298 endTimer() 2299 span.End() 2300 return next.HandleSerialize(ctx, in) 2301 } 2302 func awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInput(v *DeleteTrafficPolicyInput, encoder *httpbinding.Encoder) error { 2303 if v == nil { 2304 return fmt.Errorf("unsupported serialization of nil %T", v) 2305 } 2306 2307 if v.Id == nil || len(*v.Id) == 0 { 2308 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 2309 } 2310 if v.Id != nil { 2311 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 2312 return err 2313 } 2314 } 2315 2316 if v.Version == nil { 2317 return &smithy.SerializationError{Err: fmt.Errorf("input member Version must not be empty")} 2318 } 2319 if v.Version != nil { 2320 if err := encoder.SetURI("Version").Integer(*v.Version); err != nil { 2321 return err 2322 } 2323 } 2324 2325 return nil 2326 } 2327 2328 type awsRestxml_serializeOpDeleteTrafficPolicyInstance struct { 2329 } 2330 2331 func (*awsRestxml_serializeOpDeleteTrafficPolicyInstance) ID() string { 2332 return "OperationSerializer" 2333 } 2334 2335 func (m *awsRestxml_serializeOpDeleteTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2336 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2337 ) { 2338 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2339 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2340 defer endTimer() 2341 defer span.End() 2342 request, ok := in.Request.(*smithyhttp.Request) 2343 if !ok { 2344 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2345 } 2346 2347 input, ok := in.Parameters.(*DeleteTrafficPolicyInstanceInput) 2348 _ = input 2349 if !ok { 2350 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2351 } 2352 2353 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance/{Id}") 2354 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2355 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2356 request.Method = "DELETE" 2357 var restEncoder *httpbinding.Encoder 2358 if request.URL.RawPath == "" { 2359 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2360 } else { 2361 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2362 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2363 } 2364 2365 if err != nil { 2366 return out, metadata, &smithy.SerializationError{Err: err} 2367 } 2368 2369 if err := awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInstanceInput(input, restEncoder); err != nil { 2370 return out, metadata, &smithy.SerializationError{Err: err} 2371 } 2372 2373 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2374 return out, metadata, &smithy.SerializationError{Err: err} 2375 } 2376 in.Request = request 2377 2378 endTimer() 2379 span.End() 2380 return next.HandleSerialize(ctx, in) 2381 } 2382 func awsRestxml_serializeOpHttpBindingsDeleteTrafficPolicyInstanceInput(v *DeleteTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error { 2383 if v == nil { 2384 return fmt.Errorf("unsupported serialization of nil %T", v) 2385 } 2386 2387 if v.Id == nil || len(*v.Id) == 0 { 2388 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 2389 } 2390 if v.Id != nil { 2391 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 2392 return err 2393 } 2394 } 2395 2396 return nil 2397 } 2398 2399 type awsRestxml_serializeOpDeleteVPCAssociationAuthorization struct { 2400 } 2401 2402 func (*awsRestxml_serializeOpDeleteVPCAssociationAuthorization) ID() string { 2403 return "OperationSerializer" 2404 } 2405 2406 func (m *awsRestxml_serializeOpDeleteVPCAssociationAuthorization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2407 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2408 ) { 2409 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2410 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2411 defer endTimer() 2412 defer span.End() 2413 request, ok := in.Request.(*smithyhttp.Request) 2414 if !ok { 2415 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2416 } 2417 2418 input, ok := in.Parameters.(*DeleteVPCAssociationAuthorizationInput) 2419 _ = input 2420 if !ok { 2421 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2422 } 2423 2424 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/deauthorizevpcassociation") 2425 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2426 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2427 request.Method = "POST" 2428 var restEncoder *httpbinding.Encoder 2429 if request.URL.RawPath == "" { 2430 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2431 } else { 2432 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2433 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2434 } 2435 2436 if err != nil { 2437 return out, metadata, &smithy.SerializationError{Err: err} 2438 } 2439 2440 if err := awsRestxml_serializeOpHttpBindingsDeleteVPCAssociationAuthorizationInput(input, restEncoder); err != nil { 2441 return out, metadata, &smithy.SerializationError{Err: err} 2442 } 2443 2444 restEncoder.SetHeader("Content-Type").String("application/xml") 2445 2446 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2447 rootAttr := []smithyxml.Attr{} 2448 root := smithyxml.StartElement{ 2449 Name: smithyxml.Name{ 2450 Local: "DeleteVPCAssociationAuthorizationRequest", 2451 }, 2452 Attr: rootAttr, 2453 } 2454 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 2455 if err := awsRestxml_serializeOpDocumentDeleteVPCAssociationAuthorizationInput(input, xmlEncoder.RootElement(root)); err != nil { 2456 return out, metadata, &smithy.SerializationError{Err: err} 2457 } 2458 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2459 return out, metadata, &smithy.SerializationError{Err: err} 2460 } 2461 2462 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2463 return out, metadata, &smithy.SerializationError{Err: err} 2464 } 2465 in.Request = request 2466 2467 endTimer() 2468 span.End() 2469 return next.HandleSerialize(ctx, in) 2470 } 2471 func awsRestxml_serializeOpHttpBindingsDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput, encoder *httpbinding.Encoder) error { 2472 if v == nil { 2473 return fmt.Errorf("unsupported serialization of nil %T", v) 2474 } 2475 2476 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 2477 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 2478 } 2479 if v.HostedZoneId != nil { 2480 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 2481 return err 2482 } 2483 } 2484 2485 return nil 2486 } 2487 2488 func awsRestxml_serializeOpDocumentDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput, value smithyxml.Value) error { 2489 defer value.Close() 2490 if v.VPC != nil { 2491 rootAttr := []smithyxml.Attr{} 2492 root := smithyxml.StartElement{ 2493 Name: smithyxml.Name{ 2494 Local: "VPC", 2495 }, 2496 Attr: rootAttr, 2497 } 2498 el := value.MemberElement(root) 2499 if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil { 2500 return err 2501 } 2502 } 2503 return nil 2504 } 2505 2506 type awsRestxml_serializeOpDisableHostedZoneDNSSEC struct { 2507 } 2508 2509 func (*awsRestxml_serializeOpDisableHostedZoneDNSSEC) ID() string { 2510 return "OperationSerializer" 2511 } 2512 2513 func (m *awsRestxml_serializeOpDisableHostedZoneDNSSEC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2514 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2515 ) { 2516 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2517 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2518 defer endTimer() 2519 defer span.End() 2520 request, ok := in.Request.(*smithyhttp.Request) 2521 if !ok { 2522 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2523 } 2524 2525 input, ok := in.Parameters.(*DisableHostedZoneDNSSECInput) 2526 _ = input 2527 if !ok { 2528 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2529 } 2530 2531 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/disable-dnssec") 2532 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2533 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2534 request.Method = "POST" 2535 var restEncoder *httpbinding.Encoder 2536 if request.URL.RawPath == "" { 2537 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2538 } else { 2539 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2540 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2541 } 2542 2543 if err != nil { 2544 return out, metadata, &smithy.SerializationError{Err: err} 2545 } 2546 2547 if err := awsRestxml_serializeOpHttpBindingsDisableHostedZoneDNSSECInput(input, restEncoder); err != nil { 2548 return out, metadata, &smithy.SerializationError{Err: err} 2549 } 2550 2551 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2552 return out, metadata, &smithy.SerializationError{Err: err} 2553 } 2554 in.Request = request 2555 2556 endTimer() 2557 span.End() 2558 return next.HandleSerialize(ctx, in) 2559 } 2560 func awsRestxml_serializeOpHttpBindingsDisableHostedZoneDNSSECInput(v *DisableHostedZoneDNSSECInput, encoder *httpbinding.Encoder) error { 2561 if v == nil { 2562 return fmt.Errorf("unsupported serialization of nil %T", v) 2563 } 2564 2565 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 2566 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 2567 } 2568 if v.HostedZoneId != nil { 2569 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 2570 return err 2571 } 2572 } 2573 2574 return nil 2575 } 2576 2577 type awsRestxml_serializeOpDisassociateVPCFromHostedZone struct { 2578 } 2579 2580 func (*awsRestxml_serializeOpDisassociateVPCFromHostedZone) ID() string { 2581 return "OperationSerializer" 2582 } 2583 2584 func (m *awsRestxml_serializeOpDisassociateVPCFromHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2585 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2586 ) { 2587 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2588 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2589 defer endTimer() 2590 defer span.End() 2591 request, ok := in.Request.(*smithyhttp.Request) 2592 if !ok { 2593 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2594 } 2595 2596 input, ok := in.Parameters.(*DisassociateVPCFromHostedZoneInput) 2597 _ = input 2598 if !ok { 2599 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2600 } 2601 2602 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/disassociatevpc") 2603 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2604 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2605 request.Method = "POST" 2606 var restEncoder *httpbinding.Encoder 2607 if request.URL.RawPath == "" { 2608 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2609 } else { 2610 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2611 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2612 } 2613 2614 if err != nil { 2615 return out, metadata, &smithy.SerializationError{Err: err} 2616 } 2617 2618 if err := awsRestxml_serializeOpHttpBindingsDisassociateVPCFromHostedZoneInput(input, restEncoder); err != nil { 2619 return out, metadata, &smithy.SerializationError{Err: err} 2620 } 2621 2622 restEncoder.SetHeader("Content-Type").String("application/xml") 2623 2624 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 2625 rootAttr := []smithyxml.Attr{} 2626 root := smithyxml.StartElement{ 2627 Name: smithyxml.Name{ 2628 Local: "DisassociateVPCFromHostedZoneRequest", 2629 }, 2630 Attr: rootAttr, 2631 } 2632 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 2633 if err := awsRestxml_serializeOpDocumentDisassociateVPCFromHostedZoneInput(input, xmlEncoder.RootElement(root)); err != nil { 2634 return out, metadata, &smithy.SerializationError{Err: err} 2635 } 2636 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 2637 return out, metadata, &smithy.SerializationError{Err: err} 2638 } 2639 2640 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2641 return out, metadata, &smithy.SerializationError{Err: err} 2642 } 2643 in.Request = request 2644 2645 endTimer() 2646 span.End() 2647 return next.HandleSerialize(ctx, in) 2648 } 2649 func awsRestxml_serializeOpHttpBindingsDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput, encoder *httpbinding.Encoder) error { 2650 if v == nil { 2651 return fmt.Errorf("unsupported serialization of nil %T", v) 2652 } 2653 2654 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 2655 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 2656 } 2657 if v.HostedZoneId != nil { 2658 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 2659 return err 2660 } 2661 } 2662 2663 return nil 2664 } 2665 2666 func awsRestxml_serializeOpDocumentDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput, value smithyxml.Value) error { 2667 defer value.Close() 2668 if v.Comment != nil { 2669 rootAttr := []smithyxml.Attr{} 2670 root := smithyxml.StartElement{ 2671 Name: smithyxml.Name{ 2672 Local: "Comment", 2673 }, 2674 Attr: rootAttr, 2675 } 2676 el := value.MemberElement(root) 2677 el.String(*v.Comment) 2678 } 2679 if v.VPC != nil { 2680 rootAttr := []smithyxml.Attr{} 2681 root := smithyxml.StartElement{ 2682 Name: smithyxml.Name{ 2683 Local: "VPC", 2684 }, 2685 Attr: rootAttr, 2686 } 2687 el := value.MemberElement(root) 2688 if err := awsRestxml_serializeDocumentVPC(v.VPC, el); err != nil { 2689 return err 2690 } 2691 } 2692 return nil 2693 } 2694 2695 type awsRestxml_serializeOpEnableHostedZoneDNSSEC struct { 2696 } 2697 2698 func (*awsRestxml_serializeOpEnableHostedZoneDNSSEC) ID() string { 2699 return "OperationSerializer" 2700 } 2701 2702 func (m *awsRestxml_serializeOpEnableHostedZoneDNSSEC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2703 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2704 ) { 2705 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2706 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2707 defer endTimer() 2708 defer span.End() 2709 request, ok := in.Request.(*smithyhttp.Request) 2710 if !ok { 2711 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2712 } 2713 2714 input, ok := in.Parameters.(*EnableHostedZoneDNSSECInput) 2715 _ = input 2716 if !ok { 2717 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2718 } 2719 2720 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/enable-dnssec") 2721 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2722 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2723 request.Method = "POST" 2724 var restEncoder *httpbinding.Encoder 2725 if request.URL.RawPath == "" { 2726 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2727 } else { 2728 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2729 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2730 } 2731 2732 if err != nil { 2733 return out, metadata, &smithy.SerializationError{Err: err} 2734 } 2735 2736 if err := awsRestxml_serializeOpHttpBindingsEnableHostedZoneDNSSECInput(input, restEncoder); err != nil { 2737 return out, metadata, &smithy.SerializationError{Err: err} 2738 } 2739 2740 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2741 return out, metadata, &smithy.SerializationError{Err: err} 2742 } 2743 in.Request = request 2744 2745 endTimer() 2746 span.End() 2747 return next.HandleSerialize(ctx, in) 2748 } 2749 func awsRestxml_serializeOpHttpBindingsEnableHostedZoneDNSSECInput(v *EnableHostedZoneDNSSECInput, encoder *httpbinding.Encoder) error { 2750 if v == nil { 2751 return fmt.Errorf("unsupported serialization of nil %T", v) 2752 } 2753 2754 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 2755 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 2756 } 2757 if v.HostedZoneId != nil { 2758 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 2759 return err 2760 } 2761 } 2762 2763 return nil 2764 } 2765 2766 type awsRestxml_serializeOpGetAccountLimit struct { 2767 } 2768 2769 func (*awsRestxml_serializeOpGetAccountLimit) ID() string { 2770 return "OperationSerializer" 2771 } 2772 2773 func (m *awsRestxml_serializeOpGetAccountLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2774 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2775 ) { 2776 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2777 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2778 defer endTimer() 2779 defer span.End() 2780 request, ok := in.Request.(*smithyhttp.Request) 2781 if !ok { 2782 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2783 } 2784 2785 input, ok := in.Parameters.(*GetAccountLimitInput) 2786 _ = input 2787 if !ok { 2788 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2789 } 2790 2791 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/accountlimit/{Type}") 2792 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2793 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2794 request.Method = "GET" 2795 var restEncoder *httpbinding.Encoder 2796 if request.URL.RawPath == "" { 2797 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2798 } else { 2799 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2800 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2801 } 2802 2803 if err != nil { 2804 return out, metadata, &smithy.SerializationError{Err: err} 2805 } 2806 2807 if err := awsRestxml_serializeOpHttpBindingsGetAccountLimitInput(input, restEncoder); err != nil { 2808 return out, metadata, &smithy.SerializationError{Err: err} 2809 } 2810 2811 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2812 return out, metadata, &smithy.SerializationError{Err: err} 2813 } 2814 in.Request = request 2815 2816 endTimer() 2817 span.End() 2818 return next.HandleSerialize(ctx, in) 2819 } 2820 func awsRestxml_serializeOpHttpBindingsGetAccountLimitInput(v *GetAccountLimitInput, encoder *httpbinding.Encoder) error { 2821 if v == nil { 2822 return fmt.Errorf("unsupported serialization of nil %T", v) 2823 } 2824 2825 if len(v.Type) == 0 { 2826 return &smithy.SerializationError{Err: fmt.Errorf("input member Type must not be empty")} 2827 } 2828 if len(v.Type) > 0 { 2829 if err := encoder.SetURI("Type").String(string(v.Type)); err != nil { 2830 return err 2831 } 2832 } 2833 2834 return nil 2835 } 2836 2837 type awsRestxml_serializeOpGetChange struct { 2838 } 2839 2840 func (*awsRestxml_serializeOpGetChange) ID() string { 2841 return "OperationSerializer" 2842 } 2843 2844 func (m *awsRestxml_serializeOpGetChange) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2845 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2846 ) { 2847 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2848 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2849 defer endTimer() 2850 defer span.End() 2851 request, ok := in.Request.(*smithyhttp.Request) 2852 if !ok { 2853 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2854 } 2855 2856 input, ok := in.Parameters.(*GetChangeInput) 2857 _ = input 2858 if !ok { 2859 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2860 } 2861 2862 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/change/{Id}") 2863 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2864 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2865 request.Method = "GET" 2866 var restEncoder *httpbinding.Encoder 2867 if request.URL.RawPath == "" { 2868 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2869 } else { 2870 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2871 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2872 } 2873 2874 if err != nil { 2875 return out, metadata, &smithy.SerializationError{Err: err} 2876 } 2877 2878 if err := awsRestxml_serializeOpHttpBindingsGetChangeInput(input, restEncoder); err != nil { 2879 return out, metadata, &smithy.SerializationError{Err: err} 2880 } 2881 2882 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2883 return out, metadata, &smithy.SerializationError{Err: err} 2884 } 2885 in.Request = request 2886 2887 endTimer() 2888 span.End() 2889 return next.HandleSerialize(ctx, in) 2890 } 2891 func awsRestxml_serializeOpHttpBindingsGetChangeInput(v *GetChangeInput, encoder *httpbinding.Encoder) error { 2892 if v == nil { 2893 return fmt.Errorf("unsupported serialization of nil %T", v) 2894 } 2895 2896 if v.Id == nil || len(*v.Id) == 0 { 2897 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 2898 } 2899 if v.Id != nil { 2900 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 2901 return err 2902 } 2903 } 2904 2905 return nil 2906 } 2907 2908 type awsRestxml_serializeOpGetCheckerIpRanges struct { 2909 } 2910 2911 func (*awsRestxml_serializeOpGetCheckerIpRanges) ID() string { 2912 return "OperationSerializer" 2913 } 2914 2915 func (m *awsRestxml_serializeOpGetCheckerIpRanges) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2916 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2917 ) { 2918 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2919 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2920 defer endTimer() 2921 defer span.End() 2922 request, ok := in.Request.(*smithyhttp.Request) 2923 if !ok { 2924 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2925 } 2926 2927 input, ok := in.Parameters.(*GetCheckerIpRangesInput) 2928 _ = input 2929 if !ok { 2930 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2931 } 2932 2933 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/checkeripranges") 2934 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2935 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2936 request.Method = "GET" 2937 var restEncoder *httpbinding.Encoder 2938 if request.URL.RawPath == "" { 2939 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2940 } else { 2941 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 2942 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 2943 } 2944 2945 if err != nil { 2946 return out, metadata, &smithy.SerializationError{Err: err} 2947 } 2948 2949 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2950 return out, metadata, &smithy.SerializationError{Err: err} 2951 } 2952 in.Request = request 2953 2954 endTimer() 2955 span.End() 2956 return next.HandleSerialize(ctx, in) 2957 } 2958 func awsRestxml_serializeOpHttpBindingsGetCheckerIpRangesInput(v *GetCheckerIpRangesInput, encoder *httpbinding.Encoder) error { 2959 if v == nil { 2960 return fmt.Errorf("unsupported serialization of nil %T", v) 2961 } 2962 2963 return nil 2964 } 2965 2966 type awsRestxml_serializeOpGetDNSSEC struct { 2967 } 2968 2969 func (*awsRestxml_serializeOpGetDNSSEC) ID() string { 2970 return "OperationSerializer" 2971 } 2972 2973 func (m *awsRestxml_serializeOpGetDNSSEC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2974 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2975 ) { 2976 _, span := tracing.StartSpan(ctx, "OperationSerializer") 2977 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 2978 defer endTimer() 2979 defer span.End() 2980 request, ok := in.Request.(*smithyhttp.Request) 2981 if !ok { 2982 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2983 } 2984 2985 input, ok := in.Parameters.(*GetDNSSECInput) 2986 _ = input 2987 if !ok { 2988 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2989 } 2990 2991 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/dnssec") 2992 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2993 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2994 request.Method = "GET" 2995 var restEncoder *httpbinding.Encoder 2996 if request.URL.RawPath == "" { 2997 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2998 } else { 2999 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3000 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3001 } 3002 3003 if err != nil { 3004 return out, metadata, &smithy.SerializationError{Err: err} 3005 } 3006 3007 if err := awsRestxml_serializeOpHttpBindingsGetDNSSECInput(input, restEncoder); err != nil { 3008 return out, metadata, &smithy.SerializationError{Err: err} 3009 } 3010 3011 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3012 return out, metadata, &smithy.SerializationError{Err: err} 3013 } 3014 in.Request = request 3015 3016 endTimer() 3017 span.End() 3018 return next.HandleSerialize(ctx, in) 3019 } 3020 func awsRestxml_serializeOpHttpBindingsGetDNSSECInput(v *GetDNSSECInput, encoder *httpbinding.Encoder) error { 3021 if v == nil { 3022 return fmt.Errorf("unsupported serialization of nil %T", v) 3023 } 3024 3025 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 3026 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 3027 } 3028 if v.HostedZoneId != nil { 3029 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 3030 return err 3031 } 3032 } 3033 3034 return nil 3035 } 3036 3037 type awsRestxml_serializeOpGetGeoLocation struct { 3038 } 3039 3040 func (*awsRestxml_serializeOpGetGeoLocation) ID() string { 3041 return "OperationSerializer" 3042 } 3043 3044 func (m *awsRestxml_serializeOpGetGeoLocation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3045 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3046 ) { 3047 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3048 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3049 defer endTimer() 3050 defer span.End() 3051 request, ok := in.Request.(*smithyhttp.Request) 3052 if !ok { 3053 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3054 } 3055 3056 input, ok := in.Parameters.(*GetGeoLocationInput) 3057 _ = input 3058 if !ok { 3059 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3060 } 3061 3062 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/geolocation") 3063 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3064 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3065 request.Method = "GET" 3066 var restEncoder *httpbinding.Encoder 3067 if request.URL.RawPath == "" { 3068 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3069 } else { 3070 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3071 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3072 } 3073 3074 if err != nil { 3075 return out, metadata, &smithy.SerializationError{Err: err} 3076 } 3077 3078 if err := awsRestxml_serializeOpHttpBindingsGetGeoLocationInput(input, restEncoder); err != nil { 3079 return out, metadata, &smithy.SerializationError{Err: err} 3080 } 3081 3082 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3083 return out, metadata, &smithy.SerializationError{Err: err} 3084 } 3085 in.Request = request 3086 3087 endTimer() 3088 span.End() 3089 return next.HandleSerialize(ctx, in) 3090 } 3091 func awsRestxml_serializeOpHttpBindingsGetGeoLocationInput(v *GetGeoLocationInput, encoder *httpbinding.Encoder) error { 3092 if v == nil { 3093 return fmt.Errorf("unsupported serialization of nil %T", v) 3094 } 3095 3096 if v.ContinentCode != nil { 3097 encoder.SetQuery("continentcode").String(*v.ContinentCode) 3098 } 3099 3100 if v.CountryCode != nil { 3101 encoder.SetQuery("countrycode").String(*v.CountryCode) 3102 } 3103 3104 if v.SubdivisionCode != nil { 3105 encoder.SetQuery("subdivisioncode").String(*v.SubdivisionCode) 3106 } 3107 3108 return nil 3109 } 3110 3111 type awsRestxml_serializeOpGetHealthCheck struct { 3112 } 3113 3114 func (*awsRestxml_serializeOpGetHealthCheck) ID() string { 3115 return "OperationSerializer" 3116 } 3117 3118 func (m *awsRestxml_serializeOpGetHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3119 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3120 ) { 3121 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3122 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3123 defer endTimer() 3124 defer span.End() 3125 request, ok := in.Request.(*smithyhttp.Request) 3126 if !ok { 3127 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3128 } 3129 3130 input, ok := in.Parameters.(*GetHealthCheckInput) 3131 _ = input 3132 if !ok { 3133 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3134 } 3135 3136 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}") 3137 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3138 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3139 request.Method = "GET" 3140 var restEncoder *httpbinding.Encoder 3141 if request.URL.RawPath == "" { 3142 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3143 } else { 3144 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3145 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3146 } 3147 3148 if err != nil { 3149 return out, metadata, &smithy.SerializationError{Err: err} 3150 } 3151 3152 if err := awsRestxml_serializeOpHttpBindingsGetHealthCheckInput(input, restEncoder); err != nil { 3153 return out, metadata, &smithy.SerializationError{Err: err} 3154 } 3155 3156 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3157 return out, metadata, &smithy.SerializationError{Err: err} 3158 } 3159 in.Request = request 3160 3161 endTimer() 3162 span.End() 3163 return next.HandleSerialize(ctx, in) 3164 } 3165 func awsRestxml_serializeOpHttpBindingsGetHealthCheckInput(v *GetHealthCheckInput, encoder *httpbinding.Encoder) error { 3166 if v == nil { 3167 return fmt.Errorf("unsupported serialization of nil %T", v) 3168 } 3169 3170 if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 { 3171 return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")} 3172 } 3173 if v.HealthCheckId != nil { 3174 if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil { 3175 return err 3176 } 3177 } 3178 3179 return nil 3180 } 3181 3182 type awsRestxml_serializeOpGetHealthCheckCount struct { 3183 } 3184 3185 func (*awsRestxml_serializeOpGetHealthCheckCount) ID() string { 3186 return "OperationSerializer" 3187 } 3188 3189 func (m *awsRestxml_serializeOpGetHealthCheckCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3190 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3191 ) { 3192 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3193 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3194 defer endTimer() 3195 defer span.End() 3196 request, ok := in.Request.(*smithyhttp.Request) 3197 if !ok { 3198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3199 } 3200 3201 input, ok := in.Parameters.(*GetHealthCheckCountInput) 3202 _ = input 3203 if !ok { 3204 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3205 } 3206 3207 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheckcount") 3208 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3209 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3210 request.Method = "GET" 3211 var restEncoder *httpbinding.Encoder 3212 if request.URL.RawPath == "" { 3213 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3214 } else { 3215 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3216 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3217 } 3218 3219 if err != nil { 3220 return out, metadata, &smithy.SerializationError{Err: err} 3221 } 3222 3223 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3224 return out, metadata, &smithy.SerializationError{Err: err} 3225 } 3226 in.Request = request 3227 3228 endTimer() 3229 span.End() 3230 return next.HandleSerialize(ctx, in) 3231 } 3232 func awsRestxml_serializeOpHttpBindingsGetHealthCheckCountInput(v *GetHealthCheckCountInput, encoder *httpbinding.Encoder) error { 3233 if v == nil { 3234 return fmt.Errorf("unsupported serialization of nil %T", v) 3235 } 3236 3237 return nil 3238 } 3239 3240 type awsRestxml_serializeOpGetHealthCheckLastFailureReason struct { 3241 } 3242 3243 func (*awsRestxml_serializeOpGetHealthCheckLastFailureReason) ID() string { 3244 return "OperationSerializer" 3245 } 3246 3247 func (m *awsRestxml_serializeOpGetHealthCheckLastFailureReason) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3248 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3249 ) { 3250 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3251 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3252 defer endTimer() 3253 defer span.End() 3254 request, ok := in.Request.(*smithyhttp.Request) 3255 if !ok { 3256 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3257 } 3258 3259 input, ok := in.Parameters.(*GetHealthCheckLastFailureReasonInput) 3260 _ = input 3261 if !ok { 3262 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3263 } 3264 3265 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}/lastfailurereason") 3266 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3267 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3268 request.Method = "GET" 3269 var restEncoder *httpbinding.Encoder 3270 if request.URL.RawPath == "" { 3271 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3272 } else { 3273 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3274 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3275 } 3276 3277 if err != nil { 3278 return out, metadata, &smithy.SerializationError{Err: err} 3279 } 3280 3281 if err := awsRestxml_serializeOpHttpBindingsGetHealthCheckLastFailureReasonInput(input, restEncoder); err != nil { 3282 return out, metadata, &smithy.SerializationError{Err: err} 3283 } 3284 3285 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3286 return out, metadata, &smithy.SerializationError{Err: err} 3287 } 3288 in.Request = request 3289 3290 endTimer() 3291 span.End() 3292 return next.HandleSerialize(ctx, in) 3293 } 3294 func awsRestxml_serializeOpHttpBindingsGetHealthCheckLastFailureReasonInput(v *GetHealthCheckLastFailureReasonInput, encoder *httpbinding.Encoder) error { 3295 if v == nil { 3296 return fmt.Errorf("unsupported serialization of nil %T", v) 3297 } 3298 3299 if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 { 3300 return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")} 3301 } 3302 if v.HealthCheckId != nil { 3303 if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil { 3304 return err 3305 } 3306 } 3307 3308 return nil 3309 } 3310 3311 type awsRestxml_serializeOpGetHealthCheckStatus struct { 3312 } 3313 3314 func (*awsRestxml_serializeOpGetHealthCheckStatus) ID() string { 3315 return "OperationSerializer" 3316 } 3317 3318 func (m *awsRestxml_serializeOpGetHealthCheckStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3319 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3320 ) { 3321 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3322 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3323 defer endTimer() 3324 defer span.End() 3325 request, ok := in.Request.(*smithyhttp.Request) 3326 if !ok { 3327 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3328 } 3329 3330 input, ok := in.Parameters.(*GetHealthCheckStatusInput) 3331 _ = input 3332 if !ok { 3333 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3334 } 3335 3336 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}/status") 3337 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3338 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3339 request.Method = "GET" 3340 var restEncoder *httpbinding.Encoder 3341 if request.URL.RawPath == "" { 3342 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3343 } else { 3344 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3345 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3346 } 3347 3348 if err != nil { 3349 return out, metadata, &smithy.SerializationError{Err: err} 3350 } 3351 3352 if err := awsRestxml_serializeOpHttpBindingsGetHealthCheckStatusInput(input, restEncoder); err != nil { 3353 return out, metadata, &smithy.SerializationError{Err: err} 3354 } 3355 3356 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3357 return out, metadata, &smithy.SerializationError{Err: err} 3358 } 3359 in.Request = request 3360 3361 endTimer() 3362 span.End() 3363 return next.HandleSerialize(ctx, in) 3364 } 3365 func awsRestxml_serializeOpHttpBindingsGetHealthCheckStatusInput(v *GetHealthCheckStatusInput, encoder *httpbinding.Encoder) error { 3366 if v == nil { 3367 return fmt.Errorf("unsupported serialization of nil %T", v) 3368 } 3369 3370 if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 { 3371 return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")} 3372 } 3373 if v.HealthCheckId != nil { 3374 if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil { 3375 return err 3376 } 3377 } 3378 3379 return nil 3380 } 3381 3382 type awsRestxml_serializeOpGetHostedZone struct { 3383 } 3384 3385 func (*awsRestxml_serializeOpGetHostedZone) ID() string { 3386 return "OperationSerializer" 3387 } 3388 3389 func (m *awsRestxml_serializeOpGetHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3390 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3391 ) { 3392 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3393 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3394 defer endTimer() 3395 defer span.End() 3396 request, ok := in.Request.(*smithyhttp.Request) 3397 if !ok { 3398 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3399 } 3400 3401 input, ok := in.Parameters.(*GetHostedZoneInput) 3402 _ = input 3403 if !ok { 3404 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3405 } 3406 3407 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{Id}") 3408 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3409 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3410 request.Method = "GET" 3411 var restEncoder *httpbinding.Encoder 3412 if request.URL.RawPath == "" { 3413 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3414 } else { 3415 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3416 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3417 } 3418 3419 if err != nil { 3420 return out, metadata, &smithy.SerializationError{Err: err} 3421 } 3422 3423 if err := awsRestxml_serializeOpHttpBindingsGetHostedZoneInput(input, restEncoder); err != nil { 3424 return out, metadata, &smithy.SerializationError{Err: err} 3425 } 3426 3427 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3428 return out, metadata, &smithy.SerializationError{Err: err} 3429 } 3430 in.Request = request 3431 3432 endTimer() 3433 span.End() 3434 return next.HandleSerialize(ctx, in) 3435 } 3436 func awsRestxml_serializeOpHttpBindingsGetHostedZoneInput(v *GetHostedZoneInput, encoder *httpbinding.Encoder) error { 3437 if v == nil { 3438 return fmt.Errorf("unsupported serialization of nil %T", v) 3439 } 3440 3441 if v.Id == nil || len(*v.Id) == 0 { 3442 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 3443 } 3444 if v.Id != nil { 3445 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 3446 return err 3447 } 3448 } 3449 3450 return nil 3451 } 3452 3453 type awsRestxml_serializeOpGetHostedZoneCount struct { 3454 } 3455 3456 func (*awsRestxml_serializeOpGetHostedZoneCount) ID() string { 3457 return "OperationSerializer" 3458 } 3459 3460 func (m *awsRestxml_serializeOpGetHostedZoneCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3461 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3462 ) { 3463 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3464 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3465 defer endTimer() 3466 defer span.End() 3467 request, ok := in.Request.(*smithyhttp.Request) 3468 if !ok { 3469 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3470 } 3471 3472 input, ok := in.Parameters.(*GetHostedZoneCountInput) 3473 _ = input 3474 if !ok { 3475 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3476 } 3477 3478 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonecount") 3479 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3480 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3481 request.Method = "GET" 3482 var restEncoder *httpbinding.Encoder 3483 if request.URL.RawPath == "" { 3484 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3485 } else { 3486 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3487 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3488 } 3489 3490 if err != nil { 3491 return out, metadata, &smithy.SerializationError{Err: err} 3492 } 3493 3494 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3495 return out, metadata, &smithy.SerializationError{Err: err} 3496 } 3497 in.Request = request 3498 3499 endTimer() 3500 span.End() 3501 return next.HandleSerialize(ctx, in) 3502 } 3503 func awsRestxml_serializeOpHttpBindingsGetHostedZoneCountInput(v *GetHostedZoneCountInput, encoder *httpbinding.Encoder) error { 3504 if v == nil { 3505 return fmt.Errorf("unsupported serialization of nil %T", v) 3506 } 3507 3508 return nil 3509 } 3510 3511 type awsRestxml_serializeOpGetHostedZoneLimit struct { 3512 } 3513 3514 func (*awsRestxml_serializeOpGetHostedZoneLimit) ID() string { 3515 return "OperationSerializer" 3516 } 3517 3518 func (m *awsRestxml_serializeOpGetHostedZoneLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3519 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3520 ) { 3521 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3522 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3523 defer endTimer() 3524 defer span.End() 3525 request, ok := in.Request.(*smithyhttp.Request) 3526 if !ok { 3527 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3528 } 3529 3530 input, ok := in.Parameters.(*GetHostedZoneLimitInput) 3531 _ = input 3532 if !ok { 3533 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3534 } 3535 3536 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonelimit/{HostedZoneId}/{Type}") 3537 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3538 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3539 request.Method = "GET" 3540 var restEncoder *httpbinding.Encoder 3541 if request.URL.RawPath == "" { 3542 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3543 } else { 3544 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3545 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3546 } 3547 3548 if err != nil { 3549 return out, metadata, &smithy.SerializationError{Err: err} 3550 } 3551 3552 if err := awsRestxml_serializeOpHttpBindingsGetHostedZoneLimitInput(input, restEncoder); err != nil { 3553 return out, metadata, &smithy.SerializationError{Err: err} 3554 } 3555 3556 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3557 return out, metadata, &smithy.SerializationError{Err: err} 3558 } 3559 in.Request = request 3560 3561 endTimer() 3562 span.End() 3563 return next.HandleSerialize(ctx, in) 3564 } 3565 func awsRestxml_serializeOpHttpBindingsGetHostedZoneLimitInput(v *GetHostedZoneLimitInput, encoder *httpbinding.Encoder) error { 3566 if v == nil { 3567 return fmt.Errorf("unsupported serialization of nil %T", v) 3568 } 3569 3570 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 3571 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 3572 } 3573 if v.HostedZoneId != nil { 3574 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 3575 return err 3576 } 3577 } 3578 3579 if len(v.Type) == 0 { 3580 return &smithy.SerializationError{Err: fmt.Errorf("input member Type must not be empty")} 3581 } 3582 if len(v.Type) > 0 { 3583 if err := encoder.SetURI("Type").String(string(v.Type)); err != nil { 3584 return err 3585 } 3586 } 3587 3588 return nil 3589 } 3590 3591 type awsRestxml_serializeOpGetQueryLoggingConfig struct { 3592 } 3593 3594 func (*awsRestxml_serializeOpGetQueryLoggingConfig) ID() string { 3595 return "OperationSerializer" 3596 } 3597 3598 func (m *awsRestxml_serializeOpGetQueryLoggingConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3599 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3600 ) { 3601 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3602 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3603 defer endTimer() 3604 defer span.End() 3605 request, ok := in.Request.(*smithyhttp.Request) 3606 if !ok { 3607 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3608 } 3609 3610 input, ok := in.Parameters.(*GetQueryLoggingConfigInput) 3611 _ = input 3612 if !ok { 3613 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3614 } 3615 3616 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig/{Id}") 3617 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3618 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3619 request.Method = "GET" 3620 var restEncoder *httpbinding.Encoder 3621 if request.URL.RawPath == "" { 3622 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3623 } else { 3624 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3625 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3626 } 3627 3628 if err != nil { 3629 return out, metadata, &smithy.SerializationError{Err: err} 3630 } 3631 3632 if err := awsRestxml_serializeOpHttpBindingsGetQueryLoggingConfigInput(input, restEncoder); err != nil { 3633 return out, metadata, &smithy.SerializationError{Err: err} 3634 } 3635 3636 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3637 return out, metadata, &smithy.SerializationError{Err: err} 3638 } 3639 in.Request = request 3640 3641 endTimer() 3642 span.End() 3643 return next.HandleSerialize(ctx, in) 3644 } 3645 func awsRestxml_serializeOpHttpBindingsGetQueryLoggingConfigInput(v *GetQueryLoggingConfigInput, encoder *httpbinding.Encoder) error { 3646 if v == nil { 3647 return fmt.Errorf("unsupported serialization of nil %T", v) 3648 } 3649 3650 if v.Id == nil || len(*v.Id) == 0 { 3651 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 3652 } 3653 if v.Id != nil { 3654 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 3655 return err 3656 } 3657 } 3658 3659 return nil 3660 } 3661 3662 type awsRestxml_serializeOpGetReusableDelegationSet struct { 3663 } 3664 3665 func (*awsRestxml_serializeOpGetReusableDelegationSet) ID() string { 3666 return "OperationSerializer" 3667 } 3668 3669 func (m *awsRestxml_serializeOpGetReusableDelegationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3670 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3671 ) { 3672 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3673 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3674 defer endTimer() 3675 defer span.End() 3676 request, ok := in.Request.(*smithyhttp.Request) 3677 if !ok { 3678 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3679 } 3680 3681 input, ok := in.Parameters.(*GetReusableDelegationSetInput) 3682 _ = input 3683 if !ok { 3684 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3685 } 3686 3687 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset/{Id}") 3688 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3689 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3690 request.Method = "GET" 3691 var restEncoder *httpbinding.Encoder 3692 if request.URL.RawPath == "" { 3693 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3694 } else { 3695 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3696 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3697 } 3698 3699 if err != nil { 3700 return out, metadata, &smithy.SerializationError{Err: err} 3701 } 3702 3703 if err := awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetInput(input, restEncoder); err != nil { 3704 return out, metadata, &smithy.SerializationError{Err: err} 3705 } 3706 3707 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3708 return out, metadata, &smithy.SerializationError{Err: err} 3709 } 3710 in.Request = request 3711 3712 endTimer() 3713 span.End() 3714 return next.HandleSerialize(ctx, in) 3715 } 3716 func awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetInput(v *GetReusableDelegationSetInput, encoder *httpbinding.Encoder) error { 3717 if v == nil { 3718 return fmt.Errorf("unsupported serialization of nil %T", v) 3719 } 3720 3721 if v.Id == nil || len(*v.Id) == 0 { 3722 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 3723 } 3724 if v.Id != nil { 3725 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 3726 return err 3727 } 3728 } 3729 3730 return nil 3731 } 3732 3733 type awsRestxml_serializeOpGetReusableDelegationSetLimit struct { 3734 } 3735 3736 func (*awsRestxml_serializeOpGetReusableDelegationSetLimit) ID() string { 3737 return "OperationSerializer" 3738 } 3739 3740 func (m *awsRestxml_serializeOpGetReusableDelegationSetLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3741 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3742 ) { 3743 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3744 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3745 defer endTimer() 3746 defer span.End() 3747 request, ok := in.Request.(*smithyhttp.Request) 3748 if !ok { 3749 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3750 } 3751 3752 input, ok := in.Parameters.(*GetReusableDelegationSetLimitInput) 3753 _ = input 3754 if !ok { 3755 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3756 } 3757 3758 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/reusabledelegationsetlimit/{DelegationSetId}/{Type}") 3759 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3760 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3761 request.Method = "GET" 3762 var restEncoder *httpbinding.Encoder 3763 if request.URL.RawPath == "" { 3764 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3765 } else { 3766 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3767 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3768 } 3769 3770 if err != nil { 3771 return out, metadata, &smithy.SerializationError{Err: err} 3772 } 3773 3774 if err := awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetLimitInput(input, restEncoder); err != nil { 3775 return out, metadata, &smithy.SerializationError{Err: err} 3776 } 3777 3778 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3779 return out, metadata, &smithy.SerializationError{Err: err} 3780 } 3781 in.Request = request 3782 3783 endTimer() 3784 span.End() 3785 return next.HandleSerialize(ctx, in) 3786 } 3787 func awsRestxml_serializeOpHttpBindingsGetReusableDelegationSetLimitInput(v *GetReusableDelegationSetLimitInput, encoder *httpbinding.Encoder) error { 3788 if v == nil { 3789 return fmt.Errorf("unsupported serialization of nil %T", v) 3790 } 3791 3792 if v.DelegationSetId == nil || len(*v.DelegationSetId) == 0 { 3793 return &smithy.SerializationError{Err: fmt.Errorf("input member DelegationSetId must not be empty")} 3794 } 3795 if v.DelegationSetId != nil { 3796 if err := encoder.SetURI("DelegationSetId").String(*v.DelegationSetId); err != nil { 3797 return err 3798 } 3799 } 3800 3801 if len(v.Type) == 0 { 3802 return &smithy.SerializationError{Err: fmt.Errorf("input member Type must not be empty")} 3803 } 3804 if len(v.Type) > 0 { 3805 if err := encoder.SetURI("Type").String(string(v.Type)); err != nil { 3806 return err 3807 } 3808 } 3809 3810 return nil 3811 } 3812 3813 type awsRestxml_serializeOpGetTrafficPolicy struct { 3814 } 3815 3816 func (*awsRestxml_serializeOpGetTrafficPolicy) ID() string { 3817 return "OperationSerializer" 3818 } 3819 3820 func (m *awsRestxml_serializeOpGetTrafficPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3821 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3822 ) { 3823 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3824 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3825 defer endTimer() 3826 defer span.End() 3827 request, ok := in.Request.(*smithyhttp.Request) 3828 if !ok { 3829 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3830 } 3831 3832 input, ok := in.Parameters.(*GetTrafficPolicyInput) 3833 _ = input 3834 if !ok { 3835 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3836 } 3837 3838 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}/{Version}") 3839 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3840 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3841 request.Method = "GET" 3842 var restEncoder *httpbinding.Encoder 3843 if request.URL.RawPath == "" { 3844 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3845 } else { 3846 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3847 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3848 } 3849 3850 if err != nil { 3851 return out, metadata, &smithy.SerializationError{Err: err} 3852 } 3853 3854 if err := awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInput(input, restEncoder); err != nil { 3855 return out, metadata, &smithy.SerializationError{Err: err} 3856 } 3857 3858 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3859 return out, metadata, &smithy.SerializationError{Err: err} 3860 } 3861 in.Request = request 3862 3863 endTimer() 3864 span.End() 3865 return next.HandleSerialize(ctx, in) 3866 } 3867 func awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInput(v *GetTrafficPolicyInput, encoder *httpbinding.Encoder) error { 3868 if v == nil { 3869 return fmt.Errorf("unsupported serialization of nil %T", v) 3870 } 3871 3872 if v.Id == nil || len(*v.Id) == 0 { 3873 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 3874 } 3875 if v.Id != nil { 3876 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 3877 return err 3878 } 3879 } 3880 3881 if v.Version == nil { 3882 return &smithy.SerializationError{Err: fmt.Errorf("input member Version must not be empty")} 3883 } 3884 if v.Version != nil { 3885 if err := encoder.SetURI("Version").Integer(*v.Version); err != nil { 3886 return err 3887 } 3888 } 3889 3890 return nil 3891 } 3892 3893 type awsRestxml_serializeOpGetTrafficPolicyInstance struct { 3894 } 3895 3896 func (*awsRestxml_serializeOpGetTrafficPolicyInstance) ID() string { 3897 return "OperationSerializer" 3898 } 3899 3900 func (m *awsRestxml_serializeOpGetTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3901 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3902 ) { 3903 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3904 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3905 defer endTimer() 3906 defer span.End() 3907 request, ok := in.Request.(*smithyhttp.Request) 3908 if !ok { 3909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3910 } 3911 3912 input, ok := in.Parameters.(*GetTrafficPolicyInstanceInput) 3913 _ = input 3914 if !ok { 3915 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3916 } 3917 3918 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance/{Id}") 3919 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3920 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3921 request.Method = "GET" 3922 var restEncoder *httpbinding.Encoder 3923 if request.URL.RawPath == "" { 3924 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3925 } else { 3926 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3927 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3928 } 3929 3930 if err != nil { 3931 return out, metadata, &smithy.SerializationError{Err: err} 3932 } 3933 3934 if err := awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInstanceInput(input, restEncoder); err != nil { 3935 return out, metadata, &smithy.SerializationError{Err: err} 3936 } 3937 3938 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3939 return out, metadata, &smithy.SerializationError{Err: err} 3940 } 3941 in.Request = request 3942 3943 endTimer() 3944 span.End() 3945 return next.HandleSerialize(ctx, in) 3946 } 3947 func awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInstanceInput(v *GetTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error { 3948 if v == nil { 3949 return fmt.Errorf("unsupported serialization of nil %T", v) 3950 } 3951 3952 if v.Id == nil || len(*v.Id) == 0 { 3953 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 3954 } 3955 if v.Id != nil { 3956 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 3957 return err 3958 } 3959 } 3960 3961 return nil 3962 } 3963 3964 type awsRestxml_serializeOpGetTrafficPolicyInstanceCount struct { 3965 } 3966 3967 func (*awsRestxml_serializeOpGetTrafficPolicyInstanceCount) ID() string { 3968 return "OperationSerializer" 3969 } 3970 3971 func (m *awsRestxml_serializeOpGetTrafficPolicyInstanceCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3972 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3973 ) { 3974 _, span := tracing.StartSpan(ctx, "OperationSerializer") 3975 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 3976 defer endTimer() 3977 defer span.End() 3978 request, ok := in.Request.(*smithyhttp.Request) 3979 if !ok { 3980 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3981 } 3982 3983 input, ok := in.Parameters.(*GetTrafficPolicyInstanceCountInput) 3984 _ = input 3985 if !ok { 3986 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3987 } 3988 3989 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstancecount") 3990 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3991 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3992 request.Method = "GET" 3993 var restEncoder *httpbinding.Encoder 3994 if request.URL.RawPath == "" { 3995 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3996 } else { 3997 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 3998 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 3999 } 4000 4001 if err != nil { 4002 return out, metadata, &smithy.SerializationError{Err: err} 4003 } 4004 4005 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4006 return out, metadata, &smithy.SerializationError{Err: err} 4007 } 4008 in.Request = request 4009 4010 endTimer() 4011 span.End() 4012 return next.HandleSerialize(ctx, in) 4013 } 4014 func awsRestxml_serializeOpHttpBindingsGetTrafficPolicyInstanceCountInput(v *GetTrafficPolicyInstanceCountInput, encoder *httpbinding.Encoder) error { 4015 if v == nil { 4016 return fmt.Errorf("unsupported serialization of nil %T", v) 4017 } 4018 4019 return nil 4020 } 4021 4022 type awsRestxml_serializeOpListCidrBlocks struct { 4023 } 4024 4025 func (*awsRestxml_serializeOpListCidrBlocks) ID() string { 4026 return "OperationSerializer" 4027 } 4028 4029 func (m *awsRestxml_serializeOpListCidrBlocks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4030 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4031 ) { 4032 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4033 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4034 defer endTimer() 4035 defer span.End() 4036 request, ok := in.Request.(*smithyhttp.Request) 4037 if !ok { 4038 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4039 } 4040 4041 input, ok := in.Parameters.(*ListCidrBlocksInput) 4042 _ = input 4043 if !ok { 4044 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4045 } 4046 4047 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{CollectionId}/cidrblocks") 4048 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4049 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4050 request.Method = "GET" 4051 var restEncoder *httpbinding.Encoder 4052 if request.URL.RawPath == "" { 4053 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4054 } else { 4055 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4056 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4057 } 4058 4059 if err != nil { 4060 return out, metadata, &smithy.SerializationError{Err: err} 4061 } 4062 4063 if err := awsRestxml_serializeOpHttpBindingsListCidrBlocksInput(input, restEncoder); err != nil { 4064 return out, metadata, &smithy.SerializationError{Err: err} 4065 } 4066 4067 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4068 return out, metadata, &smithy.SerializationError{Err: err} 4069 } 4070 in.Request = request 4071 4072 endTimer() 4073 span.End() 4074 return next.HandleSerialize(ctx, in) 4075 } 4076 func awsRestxml_serializeOpHttpBindingsListCidrBlocksInput(v *ListCidrBlocksInput, encoder *httpbinding.Encoder) error { 4077 if v == nil { 4078 return fmt.Errorf("unsupported serialization of nil %T", v) 4079 } 4080 4081 if v.CollectionId == nil || len(*v.CollectionId) == 0 { 4082 return &smithy.SerializationError{Err: fmt.Errorf("input member CollectionId must not be empty")} 4083 } 4084 if v.CollectionId != nil { 4085 if err := encoder.SetURI("CollectionId").String(*v.CollectionId); err != nil { 4086 return err 4087 } 4088 } 4089 4090 if v.LocationName != nil { 4091 encoder.SetQuery("location").String(*v.LocationName) 4092 } 4093 4094 if v.MaxResults != nil { 4095 encoder.SetQuery("maxresults").Integer(*v.MaxResults) 4096 } 4097 4098 if v.NextToken != nil { 4099 encoder.SetQuery("nexttoken").String(*v.NextToken) 4100 } 4101 4102 return nil 4103 } 4104 4105 type awsRestxml_serializeOpListCidrCollections struct { 4106 } 4107 4108 func (*awsRestxml_serializeOpListCidrCollections) ID() string { 4109 return "OperationSerializer" 4110 } 4111 4112 func (m *awsRestxml_serializeOpListCidrCollections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4113 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4114 ) { 4115 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4116 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4117 defer endTimer() 4118 defer span.End() 4119 request, ok := in.Request.(*smithyhttp.Request) 4120 if !ok { 4121 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4122 } 4123 4124 input, ok := in.Parameters.(*ListCidrCollectionsInput) 4125 _ = input 4126 if !ok { 4127 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4128 } 4129 4130 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection") 4131 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4132 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4133 request.Method = "GET" 4134 var restEncoder *httpbinding.Encoder 4135 if request.URL.RawPath == "" { 4136 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4137 } else { 4138 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4139 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4140 } 4141 4142 if err != nil { 4143 return out, metadata, &smithy.SerializationError{Err: err} 4144 } 4145 4146 if err := awsRestxml_serializeOpHttpBindingsListCidrCollectionsInput(input, restEncoder); err != nil { 4147 return out, metadata, &smithy.SerializationError{Err: err} 4148 } 4149 4150 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4151 return out, metadata, &smithy.SerializationError{Err: err} 4152 } 4153 in.Request = request 4154 4155 endTimer() 4156 span.End() 4157 return next.HandleSerialize(ctx, in) 4158 } 4159 func awsRestxml_serializeOpHttpBindingsListCidrCollectionsInput(v *ListCidrCollectionsInput, encoder *httpbinding.Encoder) error { 4160 if v == nil { 4161 return fmt.Errorf("unsupported serialization of nil %T", v) 4162 } 4163 4164 if v.MaxResults != nil { 4165 encoder.SetQuery("maxresults").Integer(*v.MaxResults) 4166 } 4167 4168 if v.NextToken != nil { 4169 encoder.SetQuery("nexttoken").String(*v.NextToken) 4170 } 4171 4172 return nil 4173 } 4174 4175 type awsRestxml_serializeOpListCidrLocations struct { 4176 } 4177 4178 func (*awsRestxml_serializeOpListCidrLocations) ID() string { 4179 return "OperationSerializer" 4180 } 4181 4182 func (m *awsRestxml_serializeOpListCidrLocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4183 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4184 ) { 4185 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4186 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4187 defer endTimer() 4188 defer span.End() 4189 request, ok := in.Request.(*smithyhttp.Request) 4190 if !ok { 4191 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4192 } 4193 4194 input, ok := in.Parameters.(*ListCidrLocationsInput) 4195 _ = input 4196 if !ok { 4197 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4198 } 4199 4200 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/cidrcollection/{CollectionId}") 4201 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4202 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4203 request.Method = "GET" 4204 var restEncoder *httpbinding.Encoder 4205 if request.URL.RawPath == "" { 4206 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4207 } else { 4208 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4209 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4210 } 4211 4212 if err != nil { 4213 return out, metadata, &smithy.SerializationError{Err: err} 4214 } 4215 4216 if err := awsRestxml_serializeOpHttpBindingsListCidrLocationsInput(input, restEncoder); err != nil { 4217 return out, metadata, &smithy.SerializationError{Err: err} 4218 } 4219 4220 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4221 return out, metadata, &smithy.SerializationError{Err: err} 4222 } 4223 in.Request = request 4224 4225 endTimer() 4226 span.End() 4227 return next.HandleSerialize(ctx, in) 4228 } 4229 func awsRestxml_serializeOpHttpBindingsListCidrLocationsInput(v *ListCidrLocationsInput, encoder *httpbinding.Encoder) error { 4230 if v == nil { 4231 return fmt.Errorf("unsupported serialization of nil %T", v) 4232 } 4233 4234 if v.CollectionId == nil || len(*v.CollectionId) == 0 { 4235 return &smithy.SerializationError{Err: fmt.Errorf("input member CollectionId must not be empty")} 4236 } 4237 if v.CollectionId != nil { 4238 if err := encoder.SetURI("CollectionId").String(*v.CollectionId); err != nil { 4239 return err 4240 } 4241 } 4242 4243 if v.MaxResults != nil { 4244 encoder.SetQuery("maxresults").Integer(*v.MaxResults) 4245 } 4246 4247 if v.NextToken != nil { 4248 encoder.SetQuery("nexttoken").String(*v.NextToken) 4249 } 4250 4251 return nil 4252 } 4253 4254 type awsRestxml_serializeOpListGeoLocations struct { 4255 } 4256 4257 func (*awsRestxml_serializeOpListGeoLocations) ID() string { 4258 return "OperationSerializer" 4259 } 4260 4261 func (m *awsRestxml_serializeOpListGeoLocations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4262 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4263 ) { 4264 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4265 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4266 defer endTimer() 4267 defer span.End() 4268 request, ok := in.Request.(*smithyhttp.Request) 4269 if !ok { 4270 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4271 } 4272 4273 input, ok := in.Parameters.(*ListGeoLocationsInput) 4274 _ = input 4275 if !ok { 4276 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4277 } 4278 4279 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/geolocations") 4280 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4281 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4282 request.Method = "GET" 4283 var restEncoder *httpbinding.Encoder 4284 if request.URL.RawPath == "" { 4285 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4286 } else { 4287 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4288 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4289 } 4290 4291 if err != nil { 4292 return out, metadata, &smithy.SerializationError{Err: err} 4293 } 4294 4295 if err := awsRestxml_serializeOpHttpBindingsListGeoLocationsInput(input, restEncoder); err != nil { 4296 return out, metadata, &smithy.SerializationError{Err: err} 4297 } 4298 4299 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4300 return out, metadata, &smithy.SerializationError{Err: err} 4301 } 4302 in.Request = request 4303 4304 endTimer() 4305 span.End() 4306 return next.HandleSerialize(ctx, in) 4307 } 4308 func awsRestxml_serializeOpHttpBindingsListGeoLocationsInput(v *ListGeoLocationsInput, encoder *httpbinding.Encoder) error { 4309 if v == nil { 4310 return fmt.Errorf("unsupported serialization of nil %T", v) 4311 } 4312 4313 if v.MaxItems != nil { 4314 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 4315 } 4316 4317 if v.StartContinentCode != nil { 4318 encoder.SetQuery("startcontinentcode").String(*v.StartContinentCode) 4319 } 4320 4321 if v.StartCountryCode != nil { 4322 encoder.SetQuery("startcountrycode").String(*v.StartCountryCode) 4323 } 4324 4325 if v.StartSubdivisionCode != nil { 4326 encoder.SetQuery("startsubdivisioncode").String(*v.StartSubdivisionCode) 4327 } 4328 4329 return nil 4330 } 4331 4332 type awsRestxml_serializeOpListHealthChecks struct { 4333 } 4334 4335 func (*awsRestxml_serializeOpListHealthChecks) ID() string { 4336 return "OperationSerializer" 4337 } 4338 4339 func (m *awsRestxml_serializeOpListHealthChecks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4340 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4341 ) { 4342 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4343 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4344 defer endTimer() 4345 defer span.End() 4346 request, ok := in.Request.(*smithyhttp.Request) 4347 if !ok { 4348 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4349 } 4350 4351 input, ok := in.Parameters.(*ListHealthChecksInput) 4352 _ = input 4353 if !ok { 4354 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4355 } 4356 4357 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck") 4358 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4359 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4360 request.Method = "GET" 4361 var restEncoder *httpbinding.Encoder 4362 if request.URL.RawPath == "" { 4363 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4364 } else { 4365 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4366 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4367 } 4368 4369 if err != nil { 4370 return out, metadata, &smithy.SerializationError{Err: err} 4371 } 4372 4373 if err := awsRestxml_serializeOpHttpBindingsListHealthChecksInput(input, restEncoder); err != nil { 4374 return out, metadata, &smithy.SerializationError{Err: err} 4375 } 4376 4377 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4378 return out, metadata, &smithy.SerializationError{Err: err} 4379 } 4380 in.Request = request 4381 4382 endTimer() 4383 span.End() 4384 return next.HandleSerialize(ctx, in) 4385 } 4386 func awsRestxml_serializeOpHttpBindingsListHealthChecksInput(v *ListHealthChecksInput, encoder *httpbinding.Encoder) error { 4387 if v == nil { 4388 return fmt.Errorf("unsupported serialization of nil %T", v) 4389 } 4390 4391 if v.Marker != nil { 4392 encoder.SetQuery("marker").String(*v.Marker) 4393 } 4394 4395 if v.MaxItems != nil { 4396 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 4397 } 4398 4399 return nil 4400 } 4401 4402 type awsRestxml_serializeOpListHostedZones struct { 4403 } 4404 4405 func (*awsRestxml_serializeOpListHostedZones) ID() string { 4406 return "OperationSerializer" 4407 } 4408 4409 func (m *awsRestxml_serializeOpListHostedZones) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4410 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4411 ) { 4412 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4413 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4414 defer endTimer() 4415 defer span.End() 4416 request, ok := in.Request.(*smithyhttp.Request) 4417 if !ok { 4418 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4419 } 4420 4421 input, ok := in.Parameters.(*ListHostedZonesInput) 4422 _ = input 4423 if !ok { 4424 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4425 } 4426 4427 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone") 4428 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4429 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4430 request.Method = "GET" 4431 var restEncoder *httpbinding.Encoder 4432 if request.URL.RawPath == "" { 4433 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4434 } else { 4435 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4436 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4437 } 4438 4439 if err != nil { 4440 return out, metadata, &smithy.SerializationError{Err: err} 4441 } 4442 4443 if err := awsRestxml_serializeOpHttpBindingsListHostedZonesInput(input, restEncoder); err != nil { 4444 return out, metadata, &smithy.SerializationError{Err: err} 4445 } 4446 4447 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4448 return out, metadata, &smithy.SerializationError{Err: err} 4449 } 4450 in.Request = request 4451 4452 endTimer() 4453 span.End() 4454 return next.HandleSerialize(ctx, in) 4455 } 4456 func awsRestxml_serializeOpHttpBindingsListHostedZonesInput(v *ListHostedZonesInput, encoder *httpbinding.Encoder) error { 4457 if v == nil { 4458 return fmt.Errorf("unsupported serialization of nil %T", v) 4459 } 4460 4461 if v.DelegationSetId != nil { 4462 encoder.SetQuery("delegationsetid").String(*v.DelegationSetId) 4463 } 4464 4465 if len(v.HostedZoneType) > 0 { 4466 encoder.SetQuery("hostedzonetype").String(string(v.HostedZoneType)) 4467 } 4468 4469 if v.Marker != nil { 4470 encoder.SetQuery("marker").String(*v.Marker) 4471 } 4472 4473 if v.MaxItems != nil { 4474 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 4475 } 4476 4477 return nil 4478 } 4479 4480 type awsRestxml_serializeOpListHostedZonesByName struct { 4481 } 4482 4483 func (*awsRestxml_serializeOpListHostedZonesByName) ID() string { 4484 return "OperationSerializer" 4485 } 4486 4487 func (m *awsRestxml_serializeOpListHostedZonesByName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4488 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4489 ) { 4490 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4491 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4492 defer endTimer() 4493 defer span.End() 4494 request, ok := in.Request.(*smithyhttp.Request) 4495 if !ok { 4496 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4497 } 4498 4499 input, ok := in.Parameters.(*ListHostedZonesByNameInput) 4500 _ = input 4501 if !ok { 4502 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4503 } 4504 4505 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonesbyname") 4506 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4507 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4508 request.Method = "GET" 4509 var restEncoder *httpbinding.Encoder 4510 if request.URL.RawPath == "" { 4511 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4512 } else { 4513 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4514 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4515 } 4516 4517 if err != nil { 4518 return out, metadata, &smithy.SerializationError{Err: err} 4519 } 4520 4521 if err := awsRestxml_serializeOpHttpBindingsListHostedZonesByNameInput(input, restEncoder); err != nil { 4522 return out, metadata, &smithy.SerializationError{Err: err} 4523 } 4524 4525 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4526 return out, metadata, &smithy.SerializationError{Err: err} 4527 } 4528 in.Request = request 4529 4530 endTimer() 4531 span.End() 4532 return next.HandleSerialize(ctx, in) 4533 } 4534 func awsRestxml_serializeOpHttpBindingsListHostedZonesByNameInput(v *ListHostedZonesByNameInput, encoder *httpbinding.Encoder) error { 4535 if v == nil { 4536 return fmt.Errorf("unsupported serialization of nil %T", v) 4537 } 4538 4539 if v.DNSName != nil { 4540 encoder.SetQuery("dnsname").String(*v.DNSName) 4541 } 4542 4543 if v.HostedZoneId != nil { 4544 encoder.SetQuery("hostedzoneid").String(*v.HostedZoneId) 4545 } 4546 4547 if v.MaxItems != nil { 4548 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 4549 } 4550 4551 return nil 4552 } 4553 4554 type awsRestxml_serializeOpListHostedZonesByVPC struct { 4555 } 4556 4557 func (*awsRestxml_serializeOpListHostedZonesByVPC) ID() string { 4558 return "OperationSerializer" 4559 } 4560 4561 func (m *awsRestxml_serializeOpListHostedZonesByVPC) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4562 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4563 ) { 4564 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4565 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4566 defer endTimer() 4567 defer span.End() 4568 request, ok := in.Request.(*smithyhttp.Request) 4569 if !ok { 4570 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4571 } 4572 4573 input, ok := in.Parameters.(*ListHostedZonesByVPCInput) 4574 _ = input 4575 if !ok { 4576 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4577 } 4578 4579 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzonesbyvpc") 4580 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4581 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4582 request.Method = "GET" 4583 var restEncoder *httpbinding.Encoder 4584 if request.URL.RawPath == "" { 4585 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4586 } else { 4587 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4588 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4589 } 4590 4591 if err != nil { 4592 return out, metadata, &smithy.SerializationError{Err: err} 4593 } 4594 4595 if err := awsRestxml_serializeOpHttpBindingsListHostedZonesByVPCInput(input, restEncoder); err != nil { 4596 return out, metadata, &smithy.SerializationError{Err: err} 4597 } 4598 4599 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4600 return out, metadata, &smithy.SerializationError{Err: err} 4601 } 4602 in.Request = request 4603 4604 endTimer() 4605 span.End() 4606 return next.HandleSerialize(ctx, in) 4607 } 4608 func awsRestxml_serializeOpHttpBindingsListHostedZonesByVPCInput(v *ListHostedZonesByVPCInput, encoder *httpbinding.Encoder) error { 4609 if v == nil { 4610 return fmt.Errorf("unsupported serialization of nil %T", v) 4611 } 4612 4613 if v.MaxItems != nil { 4614 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 4615 } 4616 4617 if v.NextToken != nil { 4618 encoder.SetQuery("nexttoken").String(*v.NextToken) 4619 } 4620 4621 if v.VPCId != nil { 4622 encoder.SetQuery("vpcid").String(*v.VPCId) 4623 } 4624 4625 if len(v.VPCRegion) > 0 { 4626 encoder.SetQuery("vpcregion").String(string(v.VPCRegion)) 4627 } 4628 4629 return nil 4630 } 4631 4632 type awsRestxml_serializeOpListQueryLoggingConfigs struct { 4633 } 4634 4635 func (*awsRestxml_serializeOpListQueryLoggingConfigs) ID() string { 4636 return "OperationSerializer" 4637 } 4638 4639 func (m *awsRestxml_serializeOpListQueryLoggingConfigs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4640 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4641 ) { 4642 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4643 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4644 defer endTimer() 4645 defer span.End() 4646 request, ok := in.Request.(*smithyhttp.Request) 4647 if !ok { 4648 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4649 } 4650 4651 input, ok := in.Parameters.(*ListQueryLoggingConfigsInput) 4652 _ = input 4653 if !ok { 4654 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4655 } 4656 4657 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/queryloggingconfig") 4658 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4659 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4660 request.Method = "GET" 4661 var restEncoder *httpbinding.Encoder 4662 if request.URL.RawPath == "" { 4663 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4664 } else { 4665 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4666 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4667 } 4668 4669 if err != nil { 4670 return out, metadata, &smithy.SerializationError{Err: err} 4671 } 4672 4673 if err := awsRestxml_serializeOpHttpBindingsListQueryLoggingConfigsInput(input, restEncoder); err != nil { 4674 return out, metadata, &smithy.SerializationError{Err: err} 4675 } 4676 4677 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4678 return out, metadata, &smithy.SerializationError{Err: err} 4679 } 4680 in.Request = request 4681 4682 endTimer() 4683 span.End() 4684 return next.HandleSerialize(ctx, in) 4685 } 4686 func awsRestxml_serializeOpHttpBindingsListQueryLoggingConfigsInput(v *ListQueryLoggingConfigsInput, encoder *httpbinding.Encoder) error { 4687 if v == nil { 4688 return fmt.Errorf("unsupported serialization of nil %T", v) 4689 } 4690 4691 if v.HostedZoneId != nil { 4692 encoder.SetQuery("hostedzoneid").String(*v.HostedZoneId) 4693 } 4694 4695 if v.MaxResults != nil { 4696 encoder.SetQuery("maxresults").Integer(*v.MaxResults) 4697 } 4698 4699 if v.NextToken != nil { 4700 encoder.SetQuery("nexttoken").String(*v.NextToken) 4701 } 4702 4703 return nil 4704 } 4705 4706 type awsRestxml_serializeOpListResourceRecordSets struct { 4707 } 4708 4709 func (*awsRestxml_serializeOpListResourceRecordSets) ID() string { 4710 return "OperationSerializer" 4711 } 4712 4713 func (m *awsRestxml_serializeOpListResourceRecordSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4714 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4715 ) { 4716 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4717 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4718 defer endTimer() 4719 defer span.End() 4720 request, ok := in.Request.(*smithyhttp.Request) 4721 if !ok { 4722 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4723 } 4724 4725 input, ok := in.Parameters.(*ListResourceRecordSetsInput) 4726 _ = input 4727 if !ok { 4728 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4729 } 4730 4731 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/rrset") 4732 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4733 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4734 request.Method = "GET" 4735 var restEncoder *httpbinding.Encoder 4736 if request.URL.RawPath == "" { 4737 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4738 } else { 4739 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4740 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4741 } 4742 4743 if err != nil { 4744 return out, metadata, &smithy.SerializationError{Err: err} 4745 } 4746 4747 if err := awsRestxml_serializeOpHttpBindingsListResourceRecordSetsInput(input, restEncoder); err != nil { 4748 return out, metadata, &smithy.SerializationError{Err: err} 4749 } 4750 4751 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4752 return out, metadata, &smithy.SerializationError{Err: err} 4753 } 4754 in.Request = request 4755 4756 endTimer() 4757 span.End() 4758 return next.HandleSerialize(ctx, in) 4759 } 4760 func awsRestxml_serializeOpHttpBindingsListResourceRecordSetsInput(v *ListResourceRecordSetsInput, encoder *httpbinding.Encoder) error { 4761 if v == nil { 4762 return fmt.Errorf("unsupported serialization of nil %T", v) 4763 } 4764 4765 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 4766 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 4767 } 4768 if v.HostedZoneId != nil { 4769 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 4770 return err 4771 } 4772 } 4773 4774 if v.MaxItems != nil { 4775 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 4776 } 4777 4778 if v.StartRecordIdentifier != nil { 4779 encoder.SetQuery("identifier").String(*v.StartRecordIdentifier) 4780 } 4781 4782 if v.StartRecordName != nil { 4783 encoder.SetQuery("name").String(*v.StartRecordName) 4784 } 4785 4786 if len(v.StartRecordType) > 0 { 4787 encoder.SetQuery("type").String(string(v.StartRecordType)) 4788 } 4789 4790 return nil 4791 } 4792 4793 type awsRestxml_serializeOpListReusableDelegationSets struct { 4794 } 4795 4796 func (*awsRestxml_serializeOpListReusableDelegationSets) ID() string { 4797 return "OperationSerializer" 4798 } 4799 4800 func (m *awsRestxml_serializeOpListReusableDelegationSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4801 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4802 ) { 4803 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4804 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4805 defer endTimer() 4806 defer span.End() 4807 request, ok := in.Request.(*smithyhttp.Request) 4808 if !ok { 4809 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4810 } 4811 4812 input, ok := in.Parameters.(*ListReusableDelegationSetsInput) 4813 _ = input 4814 if !ok { 4815 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4816 } 4817 4818 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/delegationset") 4819 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4820 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4821 request.Method = "GET" 4822 var restEncoder *httpbinding.Encoder 4823 if request.URL.RawPath == "" { 4824 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4825 } else { 4826 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4827 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4828 } 4829 4830 if err != nil { 4831 return out, metadata, &smithy.SerializationError{Err: err} 4832 } 4833 4834 if err := awsRestxml_serializeOpHttpBindingsListReusableDelegationSetsInput(input, restEncoder); err != nil { 4835 return out, metadata, &smithy.SerializationError{Err: err} 4836 } 4837 4838 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4839 return out, metadata, &smithy.SerializationError{Err: err} 4840 } 4841 in.Request = request 4842 4843 endTimer() 4844 span.End() 4845 return next.HandleSerialize(ctx, in) 4846 } 4847 func awsRestxml_serializeOpHttpBindingsListReusableDelegationSetsInput(v *ListReusableDelegationSetsInput, encoder *httpbinding.Encoder) error { 4848 if v == nil { 4849 return fmt.Errorf("unsupported serialization of nil %T", v) 4850 } 4851 4852 if v.Marker != nil { 4853 encoder.SetQuery("marker").String(*v.Marker) 4854 } 4855 4856 if v.MaxItems != nil { 4857 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 4858 } 4859 4860 return nil 4861 } 4862 4863 type awsRestxml_serializeOpListTagsForResource struct { 4864 } 4865 4866 func (*awsRestxml_serializeOpListTagsForResource) ID() string { 4867 return "OperationSerializer" 4868 } 4869 4870 func (m *awsRestxml_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4871 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4872 ) { 4873 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4874 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4875 defer endTimer() 4876 defer span.End() 4877 request, ok := in.Request.(*smithyhttp.Request) 4878 if !ok { 4879 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4880 } 4881 4882 input, ok := in.Parameters.(*ListTagsForResourceInput) 4883 _ = input 4884 if !ok { 4885 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4886 } 4887 4888 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/tags/{ResourceType}/{ResourceId}") 4889 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4890 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4891 request.Method = "GET" 4892 var restEncoder *httpbinding.Encoder 4893 if request.URL.RawPath == "" { 4894 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4895 } else { 4896 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4897 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4898 } 4899 4900 if err != nil { 4901 return out, metadata, &smithy.SerializationError{Err: err} 4902 } 4903 4904 if err := awsRestxml_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 4905 return out, metadata, &smithy.SerializationError{Err: err} 4906 } 4907 4908 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4909 return out, metadata, &smithy.SerializationError{Err: err} 4910 } 4911 in.Request = request 4912 4913 endTimer() 4914 span.End() 4915 return next.HandleSerialize(ctx, in) 4916 } 4917 func awsRestxml_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 4918 if v == nil { 4919 return fmt.Errorf("unsupported serialization of nil %T", v) 4920 } 4921 4922 if v.ResourceId == nil || len(*v.ResourceId) == 0 { 4923 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceId must not be empty")} 4924 } 4925 if v.ResourceId != nil { 4926 if err := encoder.SetURI("ResourceId").String(*v.ResourceId); err != nil { 4927 return err 4928 } 4929 } 4930 4931 if len(v.ResourceType) == 0 { 4932 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceType must not be empty")} 4933 } 4934 if len(v.ResourceType) > 0 { 4935 if err := encoder.SetURI("ResourceType").String(string(v.ResourceType)); err != nil { 4936 return err 4937 } 4938 } 4939 4940 return nil 4941 } 4942 4943 type awsRestxml_serializeOpListTagsForResources struct { 4944 } 4945 4946 func (*awsRestxml_serializeOpListTagsForResources) ID() string { 4947 return "OperationSerializer" 4948 } 4949 4950 func (m *awsRestxml_serializeOpListTagsForResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4951 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4952 ) { 4953 _, span := tracing.StartSpan(ctx, "OperationSerializer") 4954 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 4955 defer endTimer() 4956 defer span.End() 4957 request, ok := in.Request.(*smithyhttp.Request) 4958 if !ok { 4959 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4960 } 4961 4962 input, ok := in.Parameters.(*ListTagsForResourcesInput) 4963 _ = input 4964 if !ok { 4965 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4966 } 4967 4968 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/tags/{ResourceType}") 4969 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4970 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4971 request.Method = "POST" 4972 var restEncoder *httpbinding.Encoder 4973 if request.URL.RawPath == "" { 4974 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4975 } else { 4976 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 4977 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 4978 } 4979 4980 if err != nil { 4981 return out, metadata, &smithy.SerializationError{Err: err} 4982 } 4983 4984 if err := awsRestxml_serializeOpHttpBindingsListTagsForResourcesInput(input, restEncoder); err != nil { 4985 return out, metadata, &smithy.SerializationError{Err: err} 4986 } 4987 4988 restEncoder.SetHeader("Content-Type").String("application/xml") 4989 4990 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 4991 rootAttr := []smithyxml.Attr{} 4992 root := smithyxml.StartElement{ 4993 Name: smithyxml.Name{ 4994 Local: "ListTagsForResourcesRequest", 4995 }, 4996 Attr: rootAttr, 4997 } 4998 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 4999 if err := awsRestxml_serializeOpDocumentListTagsForResourcesInput(input, xmlEncoder.RootElement(root)); err != nil { 5000 return out, metadata, &smithy.SerializationError{Err: err} 5001 } 5002 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 5003 return out, metadata, &smithy.SerializationError{Err: err} 5004 } 5005 5006 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5007 return out, metadata, &smithy.SerializationError{Err: err} 5008 } 5009 in.Request = request 5010 5011 endTimer() 5012 span.End() 5013 return next.HandleSerialize(ctx, in) 5014 } 5015 func awsRestxml_serializeOpHttpBindingsListTagsForResourcesInput(v *ListTagsForResourcesInput, encoder *httpbinding.Encoder) error { 5016 if v == nil { 5017 return fmt.Errorf("unsupported serialization of nil %T", v) 5018 } 5019 5020 if len(v.ResourceType) == 0 { 5021 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceType must not be empty")} 5022 } 5023 if len(v.ResourceType) > 0 { 5024 if err := encoder.SetURI("ResourceType").String(string(v.ResourceType)); err != nil { 5025 return err 5026 } 5027 } 5028 5029 return nil 5030 } 5031 5032 func awsRestxml_serializeOpDocumentListTagsForResourcesInput(v *ListTagsForResourcesInput, value smithyxml.Value) error { 5033 defer value.Close() 5034 if v.ResourceIds != nil { 5035 rootAttr := []smithyxml.Attr{} 5036 root := smithyxml.StartElement{ 5037 Name: smithyxml.Name{ 5038 Local: "ResourceIds", 5039 }, 5040 Attr: rootAttr, 5041 } 5042 el := value.MemberElement(root) 5043 if err := awsRestxml_serializeDocumentTagResourceIdList(v.ResourceIds, el); err != nil { 5044 return err 5045 } 5046 } 5047 return nil 5048 } 5049 5050 type awsRestxml_serializeOpListTrafficPolicies struct { 5051 } 5052 5053 func (*awsRestxml_serializeOpListTrafficPolicies) ID() string { 5054 return "OperationSerializer" 5055 } 5056 5057 func (m *awsRestxml_serializeOpListTrafficPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5058 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5059 ) { 5060 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5061 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5062 defer endTimer() 5063 defer span.End() 5064 request, ok := in.Request.(*smithyhttp.Request) 5065 if !ok { 5066 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5067 } 5068 5069 input, ok := in.Parameters.(*ListTrafficPoliciesInput) 5070 _ = input 5071 if !ok { 5072 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5073 } 5074 5075 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicies") 5076 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5077 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5078 request.Method = "GET" 5079 var restEncoder *httpbinding.Encoder 5080 if request.URL.RawPath == "" { 5081 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5082 } else { 5083 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5084 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5085 } 5086 5087 if err != nil { 5088 return out, metadata, &smithy.SerializationError{Err: err} 5089 } 5090 5091 if err := awsRestxml_serializeOpHttpBindingsListTrafficPoliciesInput(input, restEncoder); err != nil { 5092 return out, metadata, &smithy.SerializationError{Err: err} 5093 } 5094 5095 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5096 return out, metadata, &smithy.SerializationError{Err: err} 5097 } 5098 in.Request = request 5099 5100 endTimer() 5101 span.End() 5102 return next.HandleSerialize(ctx, in) 5103 } 5104 func awsRestxml_serializeOpHttpBindingsListTrafficPoliciesInput(v *ListTrafficPoliciesInput, encoder *httpbinding.Encoder) error { 5105 if v == nil { 5106 return fmt.Errorf("unsupported serialization of nil %T", v) 5107 } 5108 5109 if v.MaxItems != nil { 5110 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 5111 } 5112 5113 if v.TrafficPolicyIdMarker != nil { 5114 encoder.SetQuery("trafficpolicyid").String(*v.TrafficPolicyIdMarker) 5115 } 5116 5117 return nil 5118 } 5119 5120 type awsRestxml_serializeOpListTrafficPolicyInstances struct { 5121 } 5122 5123 func (*awsRestxml_serializeOpListTrafficPolicyInstances) ID() string { 5124 return "OperationSerializer" 5125 } 5126 5127 func (m *awsRestxml_serializeOpListTrafficPolicyInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5128 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5129 ) { 5130 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5131 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5132 defer endTimer() 5133 defer span.End() 5134 request, ok := in.Request.(*smithyhttp.Request) 5135 if !ok { 5136 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5137 } 5138 5139 input, ok := in.Parameters.(*ListTrafficPolicyInstancesInput) 5140 _ = input 5141 if !ok { 5142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5143 } 5144 5145 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstances") 5146 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5147 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5148 request.Method = "GET" 5149 var restEncoder *httpbinding.Encoder 5150 if request.URL.RawPath == "" { 5151 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5152 } else { 5153 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5154 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5155 } 5156 5157 if err != nil { 5158 return out, metadata, &smithy.SerializationError{Err: err} 5159 } 5160 5161 if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesInput(input, restEncoder); err != nil { 5162 return out, metadata, &smithy.SerializationError{Err: err} 5163 } 5164 5165 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5166 return out, metadata, &smithy.SerializationError{Err: err} 5167 } 5168 in.Request = request 5169 5170 endTimer() 5171 span.End() 5172 return next.HandleSerialize(ctx, in) 5173 } 5174 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesInput(v *ListTrafficPolicyInstancesInput, encoder *httpbinding.Encoder) error { 5175 if v == nil { 5176 return fmt.Errorf("unsupported serialization of nil %T", v) 5177 } 5178 5179 if v.HostedZoneIdMarker != nil { 5180 encoder.SetQuery("hostedzoneid").String(*v.HostedZoneIdMarker) 5181 } 5182 5183 if v.MaxItems != nil { 5184 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 5185 } 5186 5187 if v.TrafficPolicyInstanceNameMarker != nil { 5188 encoder.SetQuery("trafficpolicyinstancename").String(*v.TrafficPolicyInstanceNameMarker) 5189 } 5190 5191 if len(v.TrafficPolicyInstanceTypeMarker) > 0 { 5192 encoder.SetQuery("trafficpolicyinstancetype").String(string(v.TrafficPolicyInstanceTypeMarker)) 5193 } 5194 5195 return nil 5196 } 5197 5198 type awsRestxml_serializeOpListTrafficPolicyInstancesByHostedZone struct { 5199 } 5200 5201 func (*awsRestxml_serializeOpListTrafficPolicyInstancesByHostedZone) ID() string { 5202 return "OperationSerializer" 5203 } 5204 5205 func (m *awsRestxml_serializeOpListTrafficPolicyInstancesByHostedZone) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5206 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5207 ) { 5208 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5209 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5210 defer endTimer() 5211 defer span.End() 5212 request, ok := in.Request.(*smithyhttp.Request) 5213 if !ok { 5214 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5215 } 5216 5217 input, ok := in.Parameters.(*ListTrafficPolicyInstancesByHostedZoneInput) 5218 _ = input 5219 if !ok { 5220 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5221 } 5222 5223 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstances/hostedzone") 5224 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5225 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5226 request.Method = "GET" 5227 var restEncoder *httpbinding.Encoder 5228 if request.URL.RawPath == "" { 5229 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5230 } else { 5231 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5232 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5233 } 5234 5235 if err != nil { 5236 return out, metadata, &smithy.SerializationError{Err: err} 5237 } 5238 5239 if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByHostedZoneInput(input, restEncoder); err != nil { 5240 return out, metadata, &smithy.SerializationError{Err: err} 5241 } 5242 5243 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5244 return out, metadata, &smithy.SerializationError{Err: err} 5245 } 5246 in.Request = request 5247 5248 endTimer() 5249 span.End() 5250 return next.HandleSerialize(ctx, in) 5251 } 5252 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByHostedZoneInput(v *ListTrafficPolicyInstancesByHostedZoneInput, encoder *httpbinding.Encoder) error { 5253 if v == nil { 5254 return fmt.Errorf("unsupported serialization of nil %T", v) 5255 } 5256 5257 if v.HostedZoneId != nil { 5258 encoder.SetQuery("id").String(*v.HostedZoneId) 5259 } 5260 5261 if v.MaxItems != nil { 5262 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 5263 } 5264 5265 if v.TrafficPolicyInstanceNameMarker != nil { 5266 encoder.SetQuery("trafficpolicyinstancename").String(*v.TrafficPolicyInstanceNameMarker) 5267 } 5268 5269 if len(v.TrafficPolicyInstanceTypeMarker) > 0 { 5270 encoder.SetQuery("trafficpolicyinstancetype").String(string(v.TrafficPolicyInstanceTypeMarker)) 5271 } 5272 5273 return nil 5274 } 5275 5276 type awsRestxml_serializeOpListTrafficPolicyInstancesByPolicy struct { 5277 } 5278 5279 func (*awsRestxml_serializeOpListTrafficPolicyInstancesByPolicy) ID() string { 5280 return "OperationSerializer" 5281 } 5282 5283 func (m *awsRestxml_serializeOpListTrafficPolicyInstancesByPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5284 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5285 ) { 5286 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5287 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5288 defer endTimer() 5289 defer span.End() 5290 request, ok := in.Request.(*smithyhttp.Request) 5291 if !ok { 5292 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5293 } 5294 5295 input, ok := in.Parameters.(*ListTrafficPolicyInstancesByPolicyInput) 5296 _ = input 5297 if !ok { 5298 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5299 } 5300 5301 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstances/trafficpolicy") 5302 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5303 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5304 request.Method = "GET" 5305 var restEncoder *httpbinding.Encoder 5306 if request.URL.RawPath == "" { 5307 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5308 } else { 5309 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5310 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5311 } 5312 5313 if err != nil { 5314 return out, metadata, &smithy.SerializationError{Err: err} 5315 } 5316 5317 if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByPolicyInput(input, restEncoder); err != nil { 5318 return out, metadata, &smithy.SerializationError{Err: err} 5319 } 5320 5321 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5322 return out, metadata, &smithy.SerializationError{Err: err} 5323 } 5324 in.Request = request 5325 5326 endTimer() 5327 span.End() 5328 return next.HandleSerialize(ctx, in) 5329 } 5330 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyInstancesByPolicyInput(v *ListTrafficPolicyInstancesByPolicyInput, encoder *httpbinding.Encoder) error { 5331 if v == nil { 5332 return fmt.Errorf("unsupported serialization of nil %T", v) 5333 } 5334 5335 if v.HostedZoneIdMarker != nil { 5336 encoder.SetQuery("hostedzoneid").String(*v.HostedZoneIdMarker) 5337 } 5338 5339 if v.MaxItems != nil { 5340 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 5341 } 5342 5343 if v.TrafficPolicyId != nil { 5344 encoder.SetQuery("id").String(*v.TrafficPolicyId) 5345 } 5346 5347 if v.TrafficPolicyInstanceNameMarker != nil { 5348 encoder.SetQuery("trafficpolicyinstancename").String(*v.TrafficPolicyInstanceNameMarker) 5349 } 5350 5351 if len(v.TrafficPolicyInstanceTypeMarker) > 0 { 5352 encoder.SetQuery("trafficpolicyinstancetype").String(string(v.TrafficPolicyInstanceTypeMarker)) 5353 } 5354 5355 if v.TrafficPolicyVersion != nil { 5356 encoder.SetQuery("version").Integer(*v.TrafficPolicyVersion) 5357 } 5358 5359 return nil 5360 } 5361 5362 type awsRestxml_serializeOpListTrafficPolicyVersions struct { 5363 } 5364 5365 func (*awsRestxml_serializeOpListTrafficPolicyVersions) ID() string { 5366 return "OperationSerializer" 5367 } 5368 5369 func (m *awsRestxml_serializeOpListTrafficPolicyVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5370 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5371 ) { 5372 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5373 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5374 defer endTimer() 5375 defer span.End() 5376 request, ok := in.Request.(*smithyhttp.Request) 5377 if !ok { 5378 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5379 } 5380 5381 input, ok := in.Parameters.(*ListTrafficPolicyVersionsInput) 5382 _ = input 5383 if !ok { 5384 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5385 } 5386 5387 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicies/{Id}/versions") 5388 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5389 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5390 request.Method = "GET" 5391 var restEncoder *httpbinding.Encoder 5392 if request.URL.RawPath == "" { 5393 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5394 } else { 5395 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5396 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5397 } 5398 5399 if err != nil { 5400 return out, metadata, &smithy.SerializationError{Err: err} 5401 } 5402 5403 if err := awsRestxml_serializeOpHttpBindingsListTrafficPolicyVersionsInput(input, restEncoder); err != nil { 5404 return out, metadata, &smithy.SerializationError{Err: err} 5405 } 5406 5407 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5408 return out, metadata, &smithy.SerializationError{Err: err} 5409 } 5410 in.Request = request 5411 5412 endTimer() 5413 span.End() 5414 return next.HandleSerialize(ctx, in) 5415 } 5416 func awsRestxml_serializeOpHttpBindingsListTrafficPolicyVersionsInput(v *ListTrafficPolicyVersionsInput, encoder *httpbinding.Encoder) error { 5417 if v == nil { 5418 return fmt.Errorf("unsupported serialization of nil %T", v) 5419 } 5420 5421 if v.Id == nil || len(*v.Id) == 0 { 5422 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 5423 } 5424 if v.Id != nil { 5425 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 5426 return err 5427 } 5428 } 5429 5430 if v.MaxItems != nil { 5431 encoder.SetQuery("maxitems").Integer(*v.MaxItems) 5432 } 5433 5434 if v.TrafficPolicyVersionMarker != nil { 5435 encoder.SetQuery("trafficpolicyversion").String(*v.TrafficPolicyVersionMarker) 5436 } 5437 5438 return nil 5439 } 5440 5441 type awsRestxml_serializeOpListVPCAssociationAuthorizations struct { 5442 } 5443 5444 func (*awsRestxml_serializeOpListVPCAssociationAuthorizations) ID() string { 5445 return "OperationSerializer" 5446 } 5447 5448 func (m *awsRestxml_serializeOpListVPCAssociationAuthorizations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5449 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5450 ) { 5451 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5452 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5453 defer endTimer() 5454 defer span.End() 5455 request, ok := in.Request.(*smithyhttp.Request) 5456 if !ok { 5457 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5458 } 5459 5460 input, ok := in.Parameters.(*ListVPCAssociationAuthorizationsInput) 5461 _ = input 5462 if !ok { 5463 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5464 } 5465 5466 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation") 5467 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5468 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5469 request.Method = "GET" 5470 var restEncoder *httpbinding.Encoder 5471 if request.URL.RawPath == "" { 5472 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5473 } else { 5474 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5475 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5476 } 5477 5478 if err != nil { 5479 return out, metadata, &smithy.SerializationError{Err: err} 5480 } 5481 5482 if err := awsRestxml_serializeOpHttpBindingsListVPCAssociationAuthorizationsInput(input, restEncoder); err != nil { 5483 return out, metadata, &smithy.SerializationError{Err: err} 5484 } 5485 5486 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5487 return out, metadata, &smithy.SerializationError{Err: err} 5488 } 5489 in.Request = request 5490 5491 endTimer() 5492 span.End() 5493 return next.HandleSerialize(ctx, in) 5494 } 5495 func awsRestxml_serializeOpHttpBindingsListVPCAssociationAuthorizationsInput(v *ListVPCAssociationAuthorizationsInput, encoder *httpbinding.Encoder) error { 5496 if v == nil { 5497 return fmt.Errorf("unsupported serialization of nil %T", v) 5498 } 5499 5500 if v.HostedZoneId == nil || len(*v.HostedZoneId) == 0 { 5501 return &smithy.SerializationError{Err: fmt.Errorf("input member HostedZoneId must not be empty")} 5502 } 5503 if v.HostedZoneId != nil { 5504 if err := encoder.SetURI("HostedZoneId").String(*v.HostedZoneId); err != nil { 5505 return err 5506 } 5507 } 5508 5509 if v.MaxResults != nil { 5510 encoder.SetQuery("maxresults").Integer(*v.MaxResults) 5511 } 5512 5513 if v.NextToken != nil { 5514 encoder.SetQuery("nexttoken").String(*v.NextToken) 5515 } 5516 5517 return nil 5518 } 5519 5520 type awsRestxml_serializeOpTestDNSAnswer struct { 5521 } 5522 5523 func (*awsRestxml_serializeOpTestDNSAnswer) ID() string { 5524 return "OperationSerializer" 5525 } 5526 5527 func (m *awsRestxml_serializeOpTestDNSAnswer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5528 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5529 ) { 5530 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5531 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5532 defer endTimer() 5533 defer span.End() 5534 request, ok := in.Request.(*smithyhttp.Request) 5535 if !ok { 5536 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5537 } 5538 5539 input, ok := in.Parameters.(*TestDNSAnswerInput) 5540 _ = input 5541 if !ok { 5542 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5543 } 5544 5545 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/testdnsanswer") 5546 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5547 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5548 request.Method = "GET" 5549 var restEncoder *httpbinding.Encoder 5550 if request.URL.RawPath == "" { 5551 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5552 } else { 5553 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5554 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5555 } 5556 5557 if err != nil { 5558 return out, metadata, &smithy.SerializationError{Err: err} 5559 } 5560 5561 if err := awsRestxml_serializeOpHttpBindingsTestDNSAnswerInput(input, restEncoder); err != nil { 5562 return out, metadata, &smithy.SerializationError{Err: err} 5563 } 5564 5565 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5566 return out, metadata, &smithy.SerializationError{Err: err} 5567 } 5568 in.Request = request 5569 5570 endTimer() 5571 span.End() 5572 return next.HandleSerialize(ctx, in) 5573 } 5574 func awsRestxml_serializeOpHttpBindingsTestDNSAnswerInput(v *TestDNSAnswerInput, encoder *httpbinding.Encoder) error { 5575 if v == nil { 5576 return fmt.Errorf("unsupported serialization of nil %T", v) 5577 } 5578 5579 if v.EDNS0ClientSubnetIP != nil { 5580 encoder.SetQuery("edns0clientsubnetip").String(*v.EDNS0ClientSubnetIP) 5581 } 5582 5583 if v.EDNS0ClientSubnetMask != nil { 5584 encoder.SetQuery("edns0clientsubnetmask").String(*v.EDNS0ClientSubnetMask) 5585 } 5586 5587 if v.HostedZoneId != nil { 5588 encoder.SetQuery("hostedzoneid").String(*v.HostedZoneId) 5589 } 5590 5591 if v.RecordName != nil { 5592 encoder.SetQuery("recordname").String(*v.RecordName) 5593 } 5594 5595 if len(v.RecordType) > 0 { 5596 encoder.SetQuery("recordtype").String(string(v.RecordType)) 5597 } 5598 5599 if v.ResolverIP != nil { 5600 encoder.SetQuery("resolverip").String(*v.ResolverIP) 5601 } 5602 5603 return nil 5604 } 5605 5606 type awsRestxml_serializeOpUpdateHealthCheck struct { 5607 } 5608 5609 func (*awsRestxml_serializeOpUpdateHealthCheck) ID() string { 5610 return "OperationSerializer" 5611 } 5612 5613 func (m *awsRestxml_serializeOpUpdateHealthCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5614 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5615 ) { 5616 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5617 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5618 defer endTimer() 5619 defer span.End() 5620 request, ok := in.Request.(*smithyhttp.Request) 5621 if !ok { 5622 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5623 } 5624 5625 input, ok := in.Parameters.(*UpdateHealthCheckInput) 5626 _ = input 5627 if !ok { 5628 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5629 } 5630 5631 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/healthcheck/{HealthCheckId}") 5632 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5633 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5634 request.Method = "POST" 5635 var restEncoder *httpbinding.Encoder 5636 if request.URL.RawPath == "" { 5637 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5638 } else { 5639 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5640 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5641 } 5642 5643 if err != nil { 5644 return out, metadata, &smithy.SerializationError{Err: err} 5645 } 5646 5647 if err := awsRestxml_serializeOpHttpBindingsUpdateHealthCheckInput(input, restEncoder); err != nil { 5648 return out, metadata, &smithy.SerializationError{Err: err} 5649 } 5650 5651 restEncoder.SetHeader("Content-Type").String("application/xml") 5652 5653 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 5654 rootAttr := []smithyxml.Attr{} 5655 root := smithyxml.StartElement{ 5656 Name: smithyxml.Name{ 5657 Local: "UpdateHealthCheckRequest", 5658 }, 5659 Attr: rootAttr, 5660 } 5661 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 5662 if err := awsRestxml_serializeOpDocumentUpdateHealthCheckInput(input, xmlEncoder.RootElement(root)); err != nil { 5663 return out, metadata, &smithy.SerializationError{Err: err} 5664 } 5665 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 5666 return out, metadata, &smithy.SerializationError{Err: err} 5667 } 5668 5669 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5670 return out, metadata, &smithy.SerializationError{Err: err} 5671 } 5672 in.Request = request 5673 5674 endTimer() 5675 span.End() 5676 return next.HandleSerialize(ctx, in) 5677 } 5678 func awsRestxml_serializeOpHttpBindingsUpdateHealthCheckInput(v *UpdateHealthCheckInput, encoder *httpbinding.Encoder) error { 5679 if v == nil { 5680 return fmt.Errorf("unsupported serialization of nil %T", v) 5681 } 5682 5683 if v.HealthCheckId == nil || len(*v.HealthCheckId) == 0 { 5684 return &smithy.SerializationError{Err: fmt.Errorf("input member HealthCheckId must not be empty")} 5685 } 5686 if v.HealthCheckId != nil { 5687 if err := encoder.SetURI("HealthCheckId").String(*v.HealthCheckId); err != nil { 5688 return err 5689 } 5690 } 5691 5692 return nil 5693 } 5694 5695 func awsRestxml_serializeOpDocumentUpdateHealthCheckInput(v *UpdateHealthCheckInput, value smithyxml.Value) error { 5696 defer value.Close() 5697 if v.AlarmIdentifier != nil { 5698 rootAttr := []smithyxml.Attr{} 5699 root := smithyxml.StartElement{ 5700 Name: smithyxml.Name{ 5701 Local: "AlarmIdentifier", 5702 }, 5703 Attr: rootAttr, 5704 } 5705 el := value.MemberElement(root) 5706 if err := awsRestxml_serializeDocumentAlarmIdentifier(v.AlarmIdentifier, el); err != nil { 5707 return err 5708 } 5709 } 5710 if v.ChildHealthChecks != nil { 5711 rootAttr := []smithyxml.Attr{} 5712 root := smithyxml.StartElement{ 5713 Name: smithyxml.Name{ 5714 Local: "ChildHealthChecks", 5715 }, 5716 Attr: rootAttr, 5717 } 5718 el := value.MemberElement(root) 5719 if err := awsRestxml_serializeDocumentChildHealthCheckList(v.ChildHealthChecks, el); err != nil { 5720 return err 5721 } 5722 } 5723 if v.Disabled != nil { 5724 rootAttr := []smithyxml.Attr{} 5725 root := smithyxml.StartElement{ 5726 Name: smithyxml.Name{ 5727 Local: "Disabled", 5728 }, 5729 Attr: rootAttr, 5730 } 5731 el := value.MemberElement(root) 5732 el.Boolean(*v.Disabled) 5733 } 5734 if v.EnableSNI != nil { 5735 rootAttr := []smithyxml.Attr{} 5736 root := smithyxml.StartElement{ 5737 Name: smithyxml.Name{ 5738 Local: "EnableSNI", 5739 }, 5740 Attr: rootAttr, 5741 } 5742 el := value.MemberElement(root) 5743 el.Boolean(*v.EnableSNI) 5744 } 5745 if v.FailureThreshold != nil { 5746 rootAttr := []smithyxml.Attr{} 5747 root := smithyxml.StartElement{ 5748 Name: smithyxml.Name{ 5749 Local: "FailureThreshold", 5750 }, 5751 Attr: rootAttr, 5752 } 5753 el := value.MemberElement(root) 5754 el.Integer(*v.FailureThreshold) 5755 } 5756 if v.FullyQualifiedDomainName != nil { 5757 rootAttr := []smithyxml.Attr{} 5758 root := smithyxml.StartElement{ 5759 Name: smithyxml.Name{ 5760 Local: "FullyQualifiedDomainName", 5761 }, 5762 Attr: rootAttr, 5763 } 5764 el := value.MemberElement(root) 5765 el.String(*v.FullyQualifiedDomainName) 5766 } 5767 if v.HealthCheckVersion != nil { 5768 rootAttr := []smithyxml.Attr{} 5769 root := smithyxml.StartElement{ 5770 Name: smithyxml.Name{ 5771 Local: "HealthCheckVersion", 5772 }, 5773 Attr: rootAttr, 5774 } 5775 el := value.MemberElement(root) 5776 el.Long(*v.HealthCheckVersion) 5777 } 5778 if v.HealthThreshold != nil { 5779 rootAttr := []smithyxml.Attr{} 5780 root := smithyxml.StartElement{ 5781 Name: smithyxml.Name{ 5782 Local: "HealthThreshold", 5783 }, 5784 Attr: rootAttr, 5785 } 5786 el := value.MemberElement(root) 5787 el.Integer(*v.HealthThreshold) 5788 } 5789 if len(v.InsufficientDataHealthStatus) > 0 { 5790 rootAttr := []smithyxml.Attr{} 5791 root := smithyxml.StartElement{ 5792 Name: smithyxml.Name{ 5793 Local: "InsufficientDataHealthStatus", 5794 }, 5795 Attr: rootAttr, 5796 } 5797 el := value.MemberElement(root) 5798 el.String(string(v.InsufficientDataHealthStatus)) 5799 } 5800 if v.Inverted != nil { 5801 rootAttr := []smithyxml.Attr{} 5802 root := smithyxml.StartElement{ 5803 Name: smithyxml.Name{ 5804 Local: "Inverted", 5805 }, 5806 Attr: rootAttr, 5807 } 5808 el := value.MemberElement(root) 5809 el.Boolean(*v.Inverted) 5810 } 5811 if v.IPAddress != nil { 5812 rootAttr := []smithyxml.Attr{} 5813 root := smithyxml.StartElement{ 5814 Name: smithyxml.Name{ 5815 Local: "IPAddress", 5816 }, 5817 Attr: rootAttr, 5818 } 5819 el := value.MemberElement(root) 5820 el.String(*v.IPAddress) 5821 } 5822 if v.Port != nil { 5823 rootAttr := []smithyxml.Attr{} 5824 root := smithyxml.StartElement{ 5825 Name: smithyxml.Name{ 5826 Local: "Port", 5827 }, 5828 Attr: rootAttr, 5829 } 5830 el := value.MemberElement(root) 5831 el.Integer(*v.Port) 5832 } 5833 if v.Regions != nil { 5834 rootAttr := []smithyxml.Attr{} 5835 root := smithyxml.StartElement{ 5836 Name: smithyxml.Name{ 5837 Local: "Regions", 5838 }, 5839 Attr: rootAttr, 5840 } 5841 el := value.MemberElement(root) 5842 if err := awsRestxml_serializeDocumentHealthCheckRegionList(v.Regions, el); err != nil { 5843 return err 5844 } 5845 } 5846 if v.ResetElements != nil { 5847 rootAttr := []smithyxml.Attr{} 5848 root := smithyxml.StartElement{ 5849 Name: smithyxml.Name{ 5850 Local: "ResetElements", 5851 }, 5852 Attr: rootAttr, 5853 } 5854 el := value.MemberElement(root) 5855 if err := awsRestxml_serializeDocumentResettableElementNameList(v.ResetElements, el); err != nil { 5856 return err 5857 } 5858 } 5859 if v.ResourcePath != nil { 5860 rootAttr := []smithyxml.Attr{} 5861 root := smithyxml.StartElement{ 5862 Name: smithyxml.Name{ 5863 Local: "ResourcePath", 5864 }, 5865 Attr: rootAttr, 5866 } 5867 el := value.MemberElement(root) 5868 el.String(*v.ResourcePath) 5869 } 5870 if v.SearchString != nil { 5871 rootAttr := []smithyxml.Attr{} 5872 root := smithyxml.StartElement{ 5873 Name: smithyxml.Name{ 5874 Local: "SearchString", 5875 }, 5876 Attr: rootAttr, 5877 } 5878 el := value.MemberElement(root) 5879 el.String(*v.SearchString) 5880 } 5881 return nil 5882 } 5883 5884 type awsRestxml_serializeOpUpdateHostedZoneComment struct { 5885 } 5886 5887 func (*awsRestxml_serializeOpUpdateHostedZoneComment) ID() string { 5888 return "OperationSerializer" 5889 } 5890 5891 func (m *awsRestxml_serializeOpUpdateHostedZoneComment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5892 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5893 ) { 5894 _, span := tracing.StartSpan(ctx, "OperationSerializer") 5895 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 5896 defer endTimer() 5897 defer span.End() 5898 request, ok := in.Request.(*smithyhttp.Request) 5899 if !ok { 5900 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5901 } 5902 5903 input, ok := in.Parameters.(*UpdateHostedZoneCommentInput) 5904 _ = input 5905 if !ok { 5906 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5907 } 5908 5909 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/hostedzone/{Id}") 5910 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5911 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5912 request.Method = "POST" 5913 var restEncoder *httpbinding.Encoder 5914 if request.URL.RawPath == "" { 5915 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5916 } else { 5917 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 5918 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 5919 } 5920 5921 if err != nil { 5922 return out, metadata, &smithy.SerializationError{Err: err} 5923 } 5924 5925 if err := awsRestxml_serializeOpHttpBindingsUpdateHostedZoneCommentInput(input, restEncoder); err != nil { 5926 return out, metadata, &smithy.SerializationError{Err: err} 5927 } 5928 5929 restEncoder.SetHeader("Content-Type").String("application/xml") 5930 5931 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 5932 rootAttr := []smithyxml.Attr{} 5933 root := smithyxml.StartElement{ 5934 Name: smithyxml.Name{ 5935 Local: "UpdateHostedZoneCommentRequest", 5936 }, 5937 Attr: rootAttr, 5938 } 5939 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 5940 if err := awsRestxml_serializeOpDocumentUpdateHostedZoneCommentInput(input, xmlEncoder.RootElement(root)); err != nil { 5941 return out, metadata, &smithy.SerializationError{Err: err} 5942 } 5943 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 5944 return out, metadata, &smithy.SerializationError{Err: err} 5945 } 5946 5947 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5948 return out, metadata, &smithy.SerializationError{Err: err} 5949 } 5950 in.Request = request 5951 5952 endTimer() 5953 span.End() 5954 return next.HandleSerialize(ctx, in) 5955 } 5956 func awsRestxml_serializeOpHttpBindingsUpdateHostedZoneCommentInput(v *UpdateHostedZoneCommentInput, encoder *httpbinding.Encoder) error { 5957 if v == nil { 5958 return fmt.Errorf("unsupported serialization of nil %T", v) 5959 } 5960 5961 if v.Id == nil || len(*v.Id) == 0 { 5962 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 5963 } 5964 if v.Id != nil { 5965 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 5966 return err 5967 } 5968 } 5969 5970 return nil 5971 } 5972 5973 func awsRestxml_serializeOpDocumentUpdateHostedZoneCommentInput(v *UpdateHostedZoneCommentInput, value smithyxml.Value) error { 5974 defer value.Close() 5975 if v.Comment != nil { 5976 rootAttr := []smithyxml.Attr{} 5977 root := smithyxml.StartElement{ 5978 Name: smithyxml.Name{ 5979 Local: "Comment", 5980 }, 5981 Attr: rootAttr, 5982 } 5983 el := value.MemberElement(root) 5984 el.String(*v.Comment) 5985 } 5986 return nil 5987 } 5988 5989 type awsRestxml_serializeOpUpdateTrafficPolicyComment struct { 5990 } 5991 5992 func (*awsRestxml_serializeOpUpdateTrafficPolicyComment) ID() string { 5993 return "OperationSerializer" 5994 } 5995 5996 func (m *awsRestxml_serializeOpUpdateTrafficPolicyComment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5997 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5998 ) { 5999 _, span := tracing.StartSpan(ctx, "OperationSerializer") 6000 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 6001 defer endTimer() 6002 defer span.End() 6003 request, ok := in.Request.(*smithyhttp.Request) 6004 if !ok { 6005 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6006 } 6007 6008 input, ok := in.Parameters.(*UpdateTrafficPolicyCommentInput) 6009 _ = input 6010 if !ok { 6011 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6012 } 6013 6014 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicy/{Id}/{Version}") 6015 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6016 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6017 request.Method = "POST" 6018 var restEncoder *httpbinding.Encoder 6019 if request.URL.RawPath == "" { 6020 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6021 } else { 6022 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 6023 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 6024 } 6025 6026 if err != nil { 6027 return out, metadata, &smithy.SerializationError{Err: err} 6028 } 6029 6030 if err := awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyCommentInput(input, restEncoder); err != nil { 6031 return out, metadata, &smithy.SerializationError{Err: err} 6032 } 6033 6034 restEncoder.SetHeader("Content-Type").String("application/xml") 6035 6036 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 6037 rootAttr := []smithyxml.Attr{} 6038 root := smithyxml.StartElement{ 6039 Name: smithyxml.Name{ 6040 Local: "UpdateTrafficPolicyCommentRequest", 6041 }, 6042 Attr: rootAttr, 6043 } 6044 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 6045 if err := awsRestxml_serializeOpDocumentUpdateTrafficPolicyCommentInput(input, xmlEncoder.RootElement(root)); err != nil { 6046 return out, metadata, &smithy.SerializationError{Err: err} 6047 } 6048 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 6049 return out, metadata, &smithy.SerializationError{Err: err} 6050 } 6051 6052 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6053 return out, metadata, &smithy.SerializationError{Err: err} 6054 } 6055 in.Request = request 6056 6057 endTimer() 6058 span.End() 6059 return next.HandleSerialize(ctx, in) 6060 } 6061 func awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyCommentInput(v *UpdateTrafficPolicyCommentInput, encoder *httpbinding.Encoder) error { 6062 if v == nil { 6063 return fmt.Errorf("unsupported serialization of nil %T", v) 6064 } 6065 6066 if v.Id == nil || len(*v.Id) == 0 { 6067 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 6068 } 6069 if v.Id != nil { 6070 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 6071 return err 6072 } 6073 } 6074 6075 if v.Version == nil { 6076 return &smithy.SerializationError{Err: fmt.Errorf("input member Version must not be empty")} 6077 } 6078 if v.Version != nil { 6079 if err := encoder.SetURI("Version").Integer(*v.Version); err != nil { 6080 return err 6081 } 6082 } 6083 6084 return nil 6085 } 6086 6087 func awsRestxml_serializeOpDocumentUpdateTrafficPolicyCommentInput(v *UpdateTrafficPolicyCommentInput, value smithyxml.Value) error { 6088 defer value.Close() 6089 if v.Comment != nil { 6090 rootAttr := []smithyxml.Attr{} 6091 root := smithyxml.StartElement{ 6092 Name: smithyxml.Name{ 6093 Local: "Comment", 6094 }, 6095 Attr: rootAttr, 6096 } 6097 el := value.MemberElement(root) 6098 el.String(*v.Comment) 6099 } 6100 return nil 6101 } 6102 6103 type awsRestxml_serializeOpUpdateTrafficPolicyInstance struct { 6104 } 6105 6106 func (*awsRestxml_serializeOpUpdateTrafficPolicyInstance) ID() string { 6107 return "OperationSerializer" 6108 } 6109 6110 func (m *awsRestxml_serializeOpUpdateTrafficPolicyInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6111 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6112 ) { 6113 _, span := tracing.StartSpan(ctx, "OperationSerializer") 6114 endTimer := startMetricTimer(ctx, "client.call.serialization_duration") 6115 defer endTimer() 6116 defer span.End() 6117 request, ok := in.Request.(*smithyhttp.Request) 6118 if !ok { 6119 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6120 } 6121 6122 input, ok := in.Parameters.(*UpdateTrafficPolicyInstanceInput) 6123 _ = input 6124 if !ok { 6125 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6126 } 6127 6128 opPath, opQuery := httpbinding.SplitURI("/2013-04-01/trafficpolicyinstance/{Id}") 6129 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6130 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6131 request.Method = "POST" 6132 var restEncoder *httpbinding.Encoder 6133 if request.URL.RawPath == "" { 6134 restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6135 } else { 6136 request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath) 6137 restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header) 6138 } 6139 6140 if err != nil { 6141 return out, metadata, &smithy.SerializationError{Err: err} 6142 } 6143 6144 if err := awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyInstanceInput(input, restEncoder); err != nil { 6145 return out, metadata, &smithy.SerializationError{Err: err} 6146 } 6147 6148 restEncoder.SetHeader("Content-Type").String("application/xml") 6149 6150 xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil)) 6151 rootAttr := []smithyxml.Attr{} 6152 root := smithyxml.StartElement{ 6153 Name: smithyxml.Name{ 6154 Local: "UpdateTrafficPolicyInstanceRequest", 6155 }, 6156 Attr: rootAttr, 6157 } 6158 root.Attr = append(root.Attr, smithyxml.NewNamespaceAttribute("", "https://route53.amazonaws.com/doc/2013-04-01/")) 6159 if err := awsRestxml_serializeOpDocumentUpdateTrafficPolicyInstanceInput(input, xmlEncoder.RootElement(root)); err != nil { 6160 return out, metadata, &smithy.SerializationError{Err: err} 6161 } 6162 if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); err != nil { 6163 return out, metadata, &smithy.SerializationError{Err: err} 6164 } 6165 6166 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6167 return out, metadata, &smithy.SerializationError{Err: err} 6168 } 6169 in.Request = request 6170 6171 endTimer() 6172 span.End() 6173 return next.HandleSerialize(ctx, in) 6174 } 6175 func awsRestxml_serializeOpHttpBindingsUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput, encoder *httpbinding.Encoder) error { 6176 if v == nil { 6177 return fmt.Errorf("unsupported serialization of nil %T", v) 6178 } 6179 6180 if v.Id == nil || len(*v.Id) == 0 { 6181 return &smithy.SerializationError{Err: fmt.Errorf("input member Id must not be empty")} 6182 } 6183 if v.Id != nil { 6184 if err := encoder.SetURI("Id").String(*v.Id); err != nil { 6185 return err 6186 } 6187 } 6188 6189 return nil 6190 } 6191 6192 func awsRestxml_serializeOpDocumentUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput, value smithyxml.Value) error { 6193 defer value.Close() 6194 if v.TrafficPolicyId != nil { 6195 rootAttr := []smithyxml.Attr{} 6196 root := smithyxml.StartElement{ 6197 Name: smithyxml.Name{ 6198 Local: "TrafficPolicyId", 6199 }, 6200 Attr: rootAttr, 6201 } 6202 el := value.MemberElement(root) 6203 el.String(*v.TrafficPolicyId) 6204 } 6205 if v.TrafficPolicyVersion != nil { 6206 rootAttr := []smithyxml.Attr{} 6207 root := smithyxml.StartElement{ 6208 Name: smithyxml.Name{ 6209 Local: "TrafficPolicyVersion", 6210 }, 6211 Attr: rootAttr, 6212 } 6213 el := value.MemberElement(root) 6214 el.Integer(*v.TrafficPolicyVersion) 6215 } 6216 if v.TTL != nil { 6217 rootAttr := []smithyxml.Attr{} 6218 root := smithyxml.StartElement{ 6219 Name: smithyxml.Name{ 6220 Local: "TTL", 6221 }, 6222 Attr: rootAttr, 6223 } 6224 el := value.MemberElement(root) 6225 el.Long(*v.TTL) 6226 } 6227 return nil 6228 } 6229 6230 func awsRestxml_serializeDocumentAlarmIdentifier(v *types.AlarmIdentifier, value smithyxml.Value) error { 6231 defer value.Close() 6232 if v.Name != nil { 6233 rootAttr := []smithyxml.Attr{} 6234 root := smithyxml.StartElement{ 6235 Name: smithyxml.Name{ 6236 Local: "Name", 6237 }, 6238 Attr: rootAttr, 6239 } 6240 el := value.MemberElement(root) 6241 el.String(*v.Name) 6242 } 6243 if len(v.Region) > 0 { 6244 rootAttr := []smithyxml.Attr{} 6245 root := smithyxml.StartElement{ 6246 Name: smithyxml.Name{ 6247 Local: "Region", 6248 }, 6249 Attr: rootAttr, 6250 } 6251 el := value.MemberElement(root) 6252 el.String(string(v.Region)) 6253 } 6254 return nil 6255 } 6256 6257 func awsRestxml_serializeDocumentAliasTarget(v *types.AliasTarget, value smithyxml.Value) error { 6258 defer value.Close() 6259 if v.DNSName != nil { 6260 rootAttr := []smithyxml.Attr{} 6261 root := smithyxml.StartElement{ 6262 Name: smithyxml.Name{ 6263 Local: "DNSName", 6264 }, 6265 Attr: rootAttr, 6266 } 6267 el := value.MemberElement(root) 6268 el.String(*v.DNSName) 6269 } 6270 { 6271 rootAttr := []smithyxml.Attr{} 6272 root := smithyxml.StartElement{ 6273 Name: smithyxml.Name{ 6274 Local: "EvaluateTargetHealth", 6275 }, 6276 Attr: rootAttr, 6277 } 6278 el := value.MemberElement(root) 6279 el.Boolean(v.EvaluateTargetHealth) 6280 } 6281 if v.HostedZoneId != nil { 6282 rootAttr := []smithyxml.Attr{} 6283 root := smithyxml.StartElement{ 6284 Name: smithyxml.Name{ 6285 Local: "HostedZoneId", 6286 }, 6287 Attr: rootAttr, 6288 } 6289 el := value.MemberElement(root) 6290 el.String(*v.HostedZoneId) 6291 } 6292 return nil 6293 } 6294 6295 func awsRestxml_serializeDocumentChange(v *types.Change, value smithyxml.Value) error { 6296 defer value.Close() 6297 if len(v.Action) > 0 { 6298 rootAttr := []smithyxml.Attr{} 6299 root := smithyxml.StartElement{ 6300 Name: smithyxml.Name{ 6301 Local: "Action", 6302 }, 6303 Attr: rootAttr, 6304 } 6305 el := value.MemberElement(root) 6306 el.String(string(v.Action)) 6307 } 6308 if v.ResourceRecordSet != nil { 6309 rootAttr := []smithyxml.Attr{} 6310 root := smithyxml.StartElement{ 6311 Name: smithyxml.Name{ 6312 Local: "ResourceRecordSet", 6313 }, 6314 Attr: rootAttr, 6315 } 6316 el := value.MemberElement(root) 6317 if err := awsRestxml_serializeDocumentResourceRecordSet(v.ResourceRecordSet, el); err != nil { 6318 return err 6319 } 6320 } 6321 return nil 6322 } 6323 6324 func awsRestxml_serializeDocumentChangeBatch(v *types.ChangeBatch, value smithyxml.Value) error { 6325 defer value.Close() 6326 if v.Changes != nil { 6327 rootAttr := []smithyxml.Attr{} 6328 root := smithyxml.StartElement{ 6329 Name: smithyxml.Name{ 6330 Local: "Changes", 6331 }, 6332 Attr: rootAttr, 6333 } 6334 el := value.MemberElement(root) 6335 if err := awsRestxml_serializeDocumentChanges(v.Changes, el); err != nil { 6336 return err 6337 } 6338 } 6339 if v.Comment != nil { 6340 rootAttr := []smithyxml.Attr{} 6341 root := smithyxml.StartElement{ 6342 Name: smithyxml.Name{ 6343 Local: "Comment", 6344 }, 6345 Attr: rootAttr, 6346 } 6347 el := value.MemberElement(root) 6348 el.String(*v.Comment) 6349 } 6350 return nil 6351 } 6352 6353 func awsRestxml_serializeDocumentChanges(v []types.Change, value smithyxml.Value) error { 6354 var array *smithyxml.Array 6355 if !value.IsFlattened() { 6356 defer value.Close() 6357 } 6358 customMemberNameAttr := []smithyxml.Attr{} 6359 customMemberName := smithyxml.StartElement{ 6360 Name: smithyxml.Name{ 6361 Local: "Change", 6362 }, 6363 Attr: customMemberNameAttr, 6364 } 6365 array = value.ArrayWithCustomName(customMemberName) 6366 for i := range v { 6367 am := array.Member() 6368 if err := awsRestxml_serializeDocumentChange(&v[i], am); err != nil { 6369 return err 6370 } 6371 } 6372 return nil 6373 } 6374 6375 func awsRestxml_serializeDocumentChildHealthCheckList(v []string, value smithyxml.Value) error { 6376 var array *smithyxml.Array 6377 if !value.IsFlattened() { 6378 defer value.Close() 6379 } 6380 customMemberNameAttr := []smithyxml.Attr{} 6381 customMemberName := smithyxml.StartElement{ 6382 Name: smithyxml.Name{ 6383 Local: "ChildHealthCheck", 6384 }, 6385 Attr: customMemberNameAttr, 6386 } 6387 array = value.ArrayWithCustomName(customMemberName) 6388 for i := range v { 6389 am := array.Member() 6390 am.String(v[i]) 6391 } 6392 return nil 6393 } 6394 6395 func awsRestxml_serializeDocumentCidrCollectionChange(v *types.CidrCollectionChange, value smithyxml.Value) error { 6396 defer value.Close() 6397 if len(v.Action) > 0 { 6398 rootAttr := []smithyxml.Attr{} 6399 root := smithyxml.StartElement{ 6400 Name: smithyxml.Name{ 6401 Local: "Action", 6402 }, 6403 Attr: rootAttr, 6404 } 6405 el := value.MemberElement(root) 6406 el.String(string(v.Action)) 6407 } 6408 if v.CidrList != nil { 6409 rootAttr := []smithyxml.Attr{} 6410 root := smithyxml.StartElement{ 6411 Name: smithyxml.Name{ 6412 Local: "CidrList", 6413 }, 6414 Attr: rootAttr, 6415 } 6416 el := value.MemberElement(root) 6417 if err := awsRestxml_serializeDocumentCidrList(v.CidrList, el); err != nil { 6418 return err 6419 } 6420 } 6421 if v.LocationName != nil { 6422 rootAttr := []smithyxml.Attr{} 6423 root := smithyxml.StartElement{ 6424 Name: smithyxml.Name{ 6425 Local: "LocationName", 6426 }, 6427 Attr: rootAttr, 6428 } 6429 el := value.MemberElement(root) 6430 el.String(*v.LocationName) 6431 } 6432 return nil 6433 } 6434 6435 func awsRestxml_serializeDocumentCidrCollectionChanges(v []types.CidrCollectionChange, value smithyxml.Value) error { 6436 var array *smithyxml.Array 6437 if !value.IsFlattened() { 6438 defer value.Close() 6439 } 6440 array = value.Array() 6441 for i := range v { 6442 am := array.Member() 6443 if err := awsRestxml_serializeDocumentCidrCollectionChange(&v[i], am); err != nil { 6444 return err 6445 } 6446 } 6447 return nil 6448 } 6449 6450 func awsRestxml_serializeDocumentCidrList(v []string, value smithyxml.Value) error { 6451 var array *smithyxml.Array 6452 if !value.IsFlattened() { 6453 defer value.Close() 6454 } 6455 customMemberNameAttr := []smithyxml.Attr{} 6456 customMemberName := smithyxml.StartElement{ 6457 Name: smithyxml.Name{ 6458 Local: "Cidr", 6459 }, 6460 Attr: customMemberNameAttr, 6461 } 6462 array = value.ArrayWithCustomName(customMemberName) 6463 for i := range v { 6464 am := array.Member() 6465 am.String(v[i]) 6466 } 6467 return nil 6468 } 6469 6470 func awsRestxml_serializeDocumentCidrRoutingConfig(v *types.CidrRoutingConfig, value smithyxml.Value) error { 6471 defer value.Close() 6472 if v.CollectionId != nil { 6473 rootAttr := []smithyxml.Attr{} 6474 root := smithyxml.StartElement{ 6475 Name: smithyxml.Name{ 6476 Local: "CollectionId", 6477 }, 6478 Attr: rootAttr, 6479 } 6480 el := value.MemberElement(root) 6481 el.String(*v.CollectionId) 6482 } 6483 if v.LocationName != nil { 6484 rootAttr := []smithyxml.Attr{} 6485 root := smithyxml.StartElement{ 6486 Name: smithyxml.Name{ 6487 Local: "LocationName", 6488 }, 6489 Attr: rootAttr, 6490 } 6491 el := value.MemberElement(root) 6492 el.String(*v.LocationName) 6493 } 6494 return nil 6495 } 6496 6497 func awsRestxml_serializeDocumentCoordinates(v *types.Coordinates, value smithyxml.Value) error { 6498 defer value.Close() 6499 if v.Latitude != nil { 6500 rootAttr := []smithyxml.Attr{} 6501 root := smithyxml.StartElement{ 6502 Name: smithyxml.Name{ 6503 Local: "Latitude", 6504 }, 6505 Attr: rootAttr, 6506 } 6507 el := value.MemberElement(root) 6508 el.String(*v.Latitude) 6509 } 6510 if v.Longitude != nil { 6511 rootAttr := []smithyxml.Attr{} 6512 root := smithyxml.StartElement{ 6513 Name: smithyxml.Name{ 6514 Local: "Longitude", 6515 }, 6516 Attr: rootAttr, 6517 } 6518 el := value.MemberElement(root) 6519 el.String(*v.Longitude) 6520 } 6521 return nil 6522 } 6523 6524 func awsRestxml_serializeDocumentGeoLocation(v *types.GeoLocation, value smithyxml.Value) error { 6525 defer value.Close() 6526 if v.ContinentCode != nil { 6527 rootAttr := []smithyxml.Attr{} 6528 root := smithyxml.StartElement{ 6529 Name: smithyxml.Name{ 6530 Local: "ContinentCode", 6531 }, 6532 Attr: rootAttr, 6533 } 6534 el := value.MemberElement(root) 6535 el.String(*v.ContinentCode) 6536 } 6537 if v.CountryCode != nil { 6538 rootAttr := []smithyxml.Attr{} 6539 root := smithyxml.StartElement{ 6540 Name: smithyxml.Name{ 6541 Local: "CountryCode", 6542 }, 6543 Attr: rootAttr, 6544 } 6545 el := value.MemberElement(root) 6546 el.String(*v.CountryCode) 6547 } 6548 if v.SubdivisionCode != nil { 6549 rootAttr := []smithyxml.Attr{} 6550 root := smithyxml.StartElement{ 6551 Name: smithyxml.Name{ 6552 Local: "SubdivisionCode", 6553 }, 6554 Attr: rootAttr, 6555 } 6556 el := value.MemberElement(root) 6557 el.String(*v.SubdivisionCode) 6558 } 6559 return nil 6560 } 6561 6562 func awsRestxml_serializeDocumentGeoProximityLocation(v *types.GeoProximityLocation, value smithyxml.Value) error { 6563 defer value.Close() 6564 if v.AWSRegion != nil { 6565 rootAttr := []smithyxml.Attr{} 6566 root := smithyxml.StartElement{ 6567 Name: smithyxml.Name{ 6568 Local: "AWSRegion", 6569 }, 6570 Attr: rootAttr, 6571 } 6572 el := value.MemberElement(root) 6573 el.String(*v.AWSRegion) 6574 } 6575 if v.Bias != nil { 6576 rootAttr := []smithyxml.Attr{} 6577 root := smithyxml.StartElement{ 6578 Name: smithyxml.Name{ 6579 Local: "Bias", 6580 }, 6581 Attr: rootAttr, 6582 } 6583 el := value.MemberElement(root) 6584 el.Integer(*v.Bias) 6585 } 6586 if v.Coordinates != nil { 6587 rootAttr := []smithyxml.Attr{} 6588 root := smithyxml.StartElement{ 6589 Name: smithyxml.Name{ 6590 Local: "Coordinates", 6591 }, 6592 Attr: rootAttr, 6593 } 6594 el := value.MemberElement(root) 6595 if err := awsRestxml_serializeDocumentCoordinates(v.Coordinates, el); err != nil { 6596 return err 6597 } 6598 } 6599 if v.LocalZoneGroup != nil { 6600 rootAttr := []smithyxml.Attr{} 6601 root := smithyxml.StartElement{ 6602 Name: smithyxml.Name{ 6603 Local: "LocalZoneGroup", 6604 }, 6605 Attr: rootAttr, 6606 } 6607 el := value.MemberElement(root) 6608 el.String(*v.LocalZoneGroup) 6609 } 6610 return nil 6611 } 6612 6613 func awsRestxml_serializeDocumentHealthCheckConfig(v *types.HealthCheckConfig, value smithyxml.Value) error { 6614 defer value.Close() 6615 if v.AlarmIdentifier != nil { 6616 rootAttr := []smithyxml.Attr{} 6617 root := smithyxml.StartElement{ 6618 Name: smithyxml.Name{ 6619 Local: "AlarmIdentifier", 6620 }, 6621 Attr: rootAttr, 6622 } 6623 el := value.MemberElement(root) 6624 if err := awsRestxml_serializeDocumentAlarmIdentifier(v.AlarmIdentifier, el); err != nil { 6625 return err 6626 } 6627 } 6628 if v.ChildHealthChecks != nil { 6629 rootAttr := []smithyxml.Attr{} 6630 root := smithyxml.StartElement{ 6631 Name: smithyxml.Name{ 6632 Local: "ChildHealthChecks", 6633 }, 6634 Attr: rootAttr, 6635 } 6636 el := value.MemberElement(root) 6637 if err := awsRestxml_serializeDocumentChildHealthCheckList(v.ChildHealthChecks, el); err != nil { 6638 return err 6639 } 6640 } 6641 if v.Disabled != nil { 6642 rootAttr := []smithyxml.Attr{} 6643 root := smithyxml.StartElement{ 6644 Name: smithyxml.Name{ 6645 Local: "Disabled", 6646 }, 6647 Attr: rootAttr, 6648 } 6649 el := value.MemberElement(root) 6650 el.Boolean(*v.Disabled) 6651 } 6652 if v.EnableSNI != nil { 6653 rootAttr := []smithyxml.Attr{} 6654 root := smithyxml.StartElement{ 6655 Name: smithyxml.Name{ 6656 Local: "EnableSNI", 6657 }, 6658 Attr: rootAttr, 6659 } 6660 el := value.MemberElement(root) 6661 el.Boolean(*v.EnableSNI) 6662 } 6663 if v.FailureThreshold != nil { 6664 rootAttr := []smithyxml.Attr{} 6665 root := smithyxml.StartElement{ 6666 Name: smithyxml.Name{ 6667 Local: "FailureThreshold", 6668 }, 6669 Attr: rootAttr, 6670 } 6671 el := value.MemberElement(root) 6672 el.Integer(*v.FailureThreshold) 6673 } 6674 if v.FullyQualifiedDomainName != nil { 6675 rootAttr := []smithyxml.Attr{} 6676 root := smithyxml.StartElement{ 6677 Name: smithyxml.Name{ 6678 Local: "FullyQualifiedDomainName", 6679 }, 6680 Attr: rootAttr, 6681 } 6682 el := value.MemberElement(root) 6683 el.String(*v.FullyQualifiedDomainName) 6684 } 6685 if v.HealthThreshold != nil { 6686 rootAttr := []smithyxml.Attr{} 6687 root := smithyxml.StartElement{ 6688 Name: smithyxml.Name{ 6689 Local: "HealthThreshold", 6690 }, 6691 Attr: rootAttr, 6692 } 6693 el := value.MemberElement(root) 6694 el.Integer(*v.HealthThreshold) 6695 } 6696 if len(v.InsufficientDataHealthStatus) > 0 { 6697 rootAttr := []smithyxml.Attr{} 6698 root := smithyxml.StartElement{ 6699 Name: smithyxml.Name{ 6700 Local: "InsufficientDataHealthStatus", 6701 }, 6702 Attr: rootAttr, 6703 } 6704 el := value.MemberElement(root) 6705 el.String(string(v.InsufficientDataHealthStatus)) 6706 } 6707 if v.Inverted != nil { 6708 rootAttr := []smithyxml.Attr{} 6709 root := smithyxml.StartElement{ 6710 Name: smithyxml.Name{ 6711 Local: "Inverted", 6712 }, 6713 Attr: rootAttr, 6714 } 6715 el := value.MemberElement(root) 6716 el.Boolean(*v.Inverted) 6717 } 6718 if v.IPAddress != nil { 6719 rootAttr := []smithyxml.Attr{} 6720 root := smithyxml.StartElement{ 6721 Name: smithyxml.Name{ 6722 Local: "IPAddress", 6723 }, 6724 Attr: rootAttr, 6725 } 6726 el := value.MemberElement(root) 6727 el.String(*v.IPAddress) 6728 } 6729 if v.MeasureLatency != nil { 6730 rootAttr := []smithyxml.Attr{} 6731 root := smithyxml.StartElement{ 6732 Name: smithyxml.Name{ 6733 Local: "MeasureLatency", 6734 }, 6735 Attr: rootAttr, 6736 } 6737 el := value.MemberElement(root) 6738 el.Boolean(*v.MeasureLatency) 6739 } 6740 if v.Port != nil { 6741 rootAttr := []smithyxml.Attr{} 6742 root := smithyxml.StartElement{ 6743 Name: smithyxml.Name{ 6744 Local: "Port", 6745 }, 6746 Attr: rootAttr, 6747 } 6748 el := value.MemberElement(root) 6749 el.Integer(*v.Port) 6750 } 6751 if v.Regions != nil { 6752 rootAttr := []smithyxml.Attr{} 6753 root := smithyxml.StartElement{ 6754 Name: smithyxml.Name{ 6755 Local: "Regions", 6756 }, 6757 Attr: rootAttr, 6758 } 6759 el := value.MemberElement(root) 6760 if err := awsRestxml_serializeDocumentHealthCheckRegionList(v.Regions, el); err != nil { 6761 return err 6762 } 6763 } 6764 if v.RequestInterval != nil { 6765 rootAttr := []smithyxml.Attr{} 6766 root := smithyxml.StartElement{ 6767 Name: smithyxml.Name{ 6768 Local: "RequestInterval", 6769 }, 6770 Attr: rootAttr, 6771 } 6772 el := value.MemberElement(root) 6773 el.Integer(*v.RequestInterval) 6774 } 6775 if v.ResourcePath != nil { 6776 rootAttr := []smithyxml.Attr{} 6777 root := smithyxml.StartElement{ 6778 Name: smithyxml.Name{ 6779 Local: "ResourcePath", 6780 }, 6781 Attr: rootAttr, 6782 } 6783 el := value.MemberElement(root) 6784 el.String(*v.ResourcePath) 6785 } 6786 if v.RoutingControlArn != nil { 6787 rootAttr := []smithyxml.Attr{} 6788 root := smithyxml.StartElement{ 6789 Name: smithyxml.Name{ 6790 Local: "RoutingControlArn", 6791 }, 6792 Attr: rootAttr, 6793 } 6794 el := value.MemberElement(root) 6795 el.String(*v.RoutingControlArn) 6796 } 6797 if v.SearchString != nil { 6798 rootAttr := []smithyxml.Attr{} 6799 root := smithyxml.StartElement{ 6800 Name: smithyxml.Name{ 6801 Local: "SearchString", 6802 }, 6803 Attr: rootAttr, 6804 } 6805 el := value.MemberElement(root) 6806 el.String(*v.SearchString) 6807 } 6808 if len(v.Type) > 0 { 6809 rootAttr := []smithyxml.Attr{} 6810 root := smithyxml.StartElement{ 6811 Name: smithyxml.Name{ 6812 Local: "Type", 6813 }, 6814 Attr: rootAttr, 6815 } 6816 el := value.MemberElement(root) 6817 el.String(string(v.Type)) 6818 } 6819 return nil 6820 } 6821 6822 func awsRestxml_serializeDocumentHealthCheckRegionList(v []types.HealthCheckRegion, value smithyxml.Value) error { 6823 var array *smithyxml.Array 6824 if !value.IsFlattened() { 6825 defer value.Close() 6826 } 6827 customMemberNameAttr := []smithyxml.Attr{} 6828 customMemberName := smithyxml.StartElement{ 6829 Name: smithyxml.Name{ 6830 Local: "Region", 6831 }, 6832 Attr: customMemberNameAttr, 6833 } 6834 array = value.ArrayWithCustomName(customMemberName) 6835 for i := range v { 6836 am := array.Member() 6837 am.String(string(v[i])) 6838 } 6839 return nil 6840 } 6841 6842 func awsRestxml_serializeDocumentHostedZoneConfig(v *types.HostedZoneConfig, value smithyxml.Value) error { 6843 defer value.Close() 6844 if v.Comment != nil { 6845 rootAttr := []smithyxml.Attr{} 6846 root := smithyxml.StartElement{ 6847 Name: smithyxml.Name{ 6848 Local: "Comment", 6849 }, 6850 Attr: rootAttr, 6851 } 6852 el := value.MemberElement(root) 6853 el.String(*v.Comment) 6854 } 6855 if v.PrivateZone { 6856 rootAttr := []smithyxml.Attr{} 6857 root := smithyxml.StartElement{ 6858 Name: smithyxml.Name{ 6859 Local: "PrivateZone", 6860 }, 6861 Attr: rootAttr, 6862 } 6863 el := value.MemberElement(root) 6864 el.Boolean(v.PrivateZone) 6865 } 6866 return nil 6867 } 6868 6869 func awsRestxml_serializeDocumentResettableElementNameList(v []types.ResettableElementName, value smithyxml.Value) error { 6870 var array *smithyxml.Array 6871 if !value.IsFlattened() { 6872 defer value.Close() 6873 } 6874 customMemberNameAttr := []smithyxml.Attr{} 6875 customMemberName := smithyxml.StartElement{ 6876 Name: smithyxml.Name{ 6877 Local: "ResettableElementName", 6878 }, 6879 Attr: customMemberNameAttr, 6880 } 6881 array = value.ArrayWithCustomName(customMemberName) 6882 for i := range v { 6883 am := array.Member() 6884 am.String(string(v[i])) 6885 } 6886 return nil 6887 } 6888 6889 func awsRestxml_serializeDocumentResourceRecord(v *types.ResourceRecord, value smithyxml.Value) error { 6890 defer value.Close() 6891 if v.Value != nil { 6892 rootAttr := []smithyxml.Attr{} 6893 root := smithyxml.StartElement{ 6894 Name: smithyxml.Name{ 6895 Local: "Value", 6896 }, 6897 Attr: rootAttr, 6898 } 6899 el := value.MemberElement(root) 6900 el.String(*v.Value) 6901 } 6902 return nil 6903 } 6904 6905 func awsRestxml_serializeDocumentResourceRecords(v []types.ResourceRecord, value smithyxml.Value) error { 6906 var array *smithyxml.Array 6907 if !value.IsFlattened() { 6908 defer value.Close() 6909 } 6910 customMemberNameAttr := []smithyxml.Attr{} 6911 customMemberName := smithyxml.StartElement{ 6912 Name: smithyxml.Name{ 6913 Local: "ResourceRecord", 6914 }, 6915 Attr: customMemberNameAttr, 6916 } 6917 array = value.ArrayWithCustomName(customMemberName) 6918 for i := range v { 6919 am := array.Member() 6920 if err := awsRestxml_serializeDocumentResourceRecord(&v[i], am); err != nil { 6921 return err 6922 } 6923 } 6924 return nil 6925 } 6926 6927 func awsRestxml_serializeDocumentResourceRecordSet(v *types.ResourceRecordSet, value smithyxml.Value) error { 6928 defer value.Close() 6929 if v.AliasTarget != nil { 6930 rootAttr := []smithyxml.Attr{} 6931 root := smithyxml.StartElement{ 6932 Name: smithyxml.Name{ 6933 Local: "AliasTarget", 6934 }, 6935 Attr: rootAttr, 6936 } 6937 el := value.MemberElement(root) 6938 if err := awsRestxml_serializeDocumentAliasTarget(v.AliasTarget, el); err != nil { 6939 return err 6940 } 6941 } 6942 if v.CidrRoutingConfig != nil { 6943 rootAttr := []smithyxml.Attr{} 6944 root := smithyxml.StartElement{ 6945 Name: smithyxml.Name{ 6946 Local: "CidrRoutingConfig", 6947 }, 6948 Attr: rootAttr, 6949 } 6950 el := value.MemberElement(root) 6951 if err := awsRestxml_serializeDocumentCidrRoutingConfig(v.CidrRoutingConfig, el); err != nil { 6952 return err 6953 } 6954 } 6955 if len(v.Failover) > 0 { 6956 rootAttr := []smithyxml.Attr{} 6957 root := smithyxml.StartElement{ 6958 Name: smithyxml.Name{ 6959 Local: "Failover", 6960 }, 6961 Attr: rootAttr, 6962 } 6963 el := value.MemberElement(root) 6964 el.String(string(v.Failover)) 6965 } 6966 if v.GeoLocation != nil { 6967 rootAttr := []smithyxml.Attr{} 6968 root := smithyxml.StartElement{ 6969 Name: smithyxml.Name{ 6970 Local: "GeoLocation", 6971 }, 6972 Attr: rootAttr, 6973 } 6974 el := value.MemberElement(root) 6975 if err := awsRestxml_serializeDocumentGeoLocation(v.GeoLocation, el); err != nil { 6976 return err 6977 } 6978 } 6979 if v.GeoProximityLocation != nil { 6980 rootAttr := []smithyxml.Attr{} 6981 root := smithyxml.StartElement{ 6982 Name: smithyxml.Name{ 6983 Local: "GeoProximityLocation", 6984 }, 6985 Attr: rootAttr, 6986 } 6987 el := value.MemberElement(root) 6988 if err := awsRestxml_serializeDocumentGeoProximityLocation(v.GeoProximityLocation, el); err != nil { 6989 return err 6990 } 6991 } 6992 if v.HealthCheckId != nil { 6993 rootAttr := []smithyxml.Attr{} 6994 root := smithyxml.StartElement{ 6995 Name: smithyxml.Name{ 6996 Local: "HealthCheckId", 6997 }, 6998 Attr: rootAttr, 6999 } 7000 el := value.MemberElement(root) 7001 el.String(*v.HealthCheckId) 7002 } 7003 if v.MultiValueAnswer != nil { 7004 rootAttr := []smithyxml.Attr{} 7005 root := smithyxml.StartElement{ 7006 Name: smithyxml.Name{ 7007 Local: "MultiValueAnswer", 7008 }, 7009 Attr: rootAttr, 7010 } 7011 el := value.MemberElement(root) 7012 el.Boolean(*v.MultiValueAnswer) 7013 } 7014 if v.Name != nil { 7015 rootAttr := []smithyxml.Attr{} 7016 root := smithyxml.StartElement{ 7017 Name: smithyxml.Name{ 7018 Local: "Name", 7019 }, 7020 Attr: rootAttr, 7021 } 7022 el := value.MemberElement(root) 7023 el.String(*v.Name) 7024 } 7025 if len(v.Region) > 0 { 7026 rootAttr := []smithyxml.Attr{} 7027 root := smithyxml.StartElement{ 7028 Name: smithyxml.Name{ 7029 Local: "Region", 7030 }, 7031 Attr: rootAttr, 7032 } 7033 el := value.MemberElement(root) 7034 el.String(string(v.Region)) 7035 } 7036 if v.ResourceRecords != nil { 7037 rootAttr := []smithyxml.Attr{} 7038 root := smithyxml.StartElement{ 7039 Name: smithyxml.Name{ 7040 Local: "ResourceRecords", 7041 }, 7042 Attr: rootAttr, 7043 } 7044 el := value.MemberElement(root) 7045 if err := awsRestxml_serializeDocumentResourceRecords(v.ResourceRecords, el); err != nil { 7046 return err 7047 } 7048 } 7049 if v.SetIdentifier != nil { 7050 rootAttr := []smithyxml.Attr{} 7051 root := smithyxml.StartElement{ 7052 Name: smithyxml.Name{ 7053 Local: "SetIdentifier", 7054 }, 7055 Attr: rootAttr, 7056 } 7057 el := value.MemberElement(root) 7058 el.String(*v.SetIdentifier) 7059 } 7060 if v.TrafficPolicyInstanceId != nil { 7061 rootAttr := []smithyxml.Attr{} 7062 root := smithyxml.StartElement{ 7063 Name: smithyxml.Name{ 7064 Local: "TrafficPolicyInstanceId", 7065 }, 7066 Attr: rootAttr, 7067 } 7068 el := value.MemberElement(root) 7069 el.String(*v.TrafficPolicyInstanceId) 7070 } 7071 if v.TTL != nil { 7072 rootAttr := []smithyxml.Attr{} 7073 root := smithyxml.StartElement{ 7074 Name: smithyxml.Name{ 7075 Local: "TTL", 7076 }, 7077 Attr: rootAttr, 7078 } 7079 el := value.MemberElement(root) 7080 el.Long(*v.TTL) 7081 } 7082 if len(v.Type) > 0 { 7083 rootAttr := []smithyxml.Attr{} 7084 root := smithyxml.StartElement{ 7085 Name: smithyxml.Name{ 7086 Local: "Type", 7087 }, 7088 Attr: rootAttr, 7089 } 7090 el := value.MemberElement(root) 7091 el.String(string(v.Type)) 7092 } 7093 if v.Weight != nil { 7094 rootAttr := []smithyxml.Attr{} 7095 root := smithyxml.StartElement{ 7096 Name: smithyxml.Name{ 7097 Local: "Weight", 7098 }, 7099 Attr: rootAttr, 7100 } 7101 el := value.MemberElement(root) 7102 el.Long(*v.Weight) 7103 } 7104 return nil 7105 } 7106 7107 func awsRestxml_serializeDocumentTag(v *types.Tag, value smithyxml.Value) error { 7108 defer value.Close() 7109 if v.Key != nil { 7110 rootAttr := []smithyxml.Attr{} 7111 root := smithyxml.StartElement{ 7112 Name: smithyxml.Name{ 7113 Local: "Key", 7114 }, 7115 Attr: rootAttr, 7116 } 7117 el := value.MemberElement(root) 7118 el.String(*v.Key) 7119 } 7120 if v.Value != nil { 7121 rootAttr := []smithyxml.Attr{} 7122 root := smithyxml.StartElement{ 7123 Name: smithyxml.Name{ 7124 Local: "Value", 7125 }, 7126 Attr: rootAttr, 7127 } 7128 el := value.MemberElement(root) 7129 el.String(*v.Value) 7130 } 7131 return nil 7132 } 7133 7134 func awsRestxml_serializeDocumentTagKeyList(v []string, value smithyxml.Value) error { 7135 var array *smithyxml.Array 7136 if !value.IsFlattened() { 7137 defer value.Close() 7138 } 7139 customMemberNameAttr := []smithyxml.Attr{} 7140 customMemberName := smithyxml.StartElement{ 7141 Name: smithyxml.Name{ 7142 Local: "Key", 7143 }, 7144 Attr: customMemberNameAttr, 7145 } 7146 array = value.ArrayWithCustomName(customMemberName) 7147 for i := range v { 7148 am := array.Member() 7149 am.String(v[i]) 7150 } 7151 return nil 7152 } 7153 7154 func awsRestxml_serializeDocumentTagList(v []types.Tag, value smithyxml.Value) error { 7155 var array *smithyxml.Array 7156 if !value.IsFlattened() { 7157 defer value.Close() 7158 } 7159 customMemberNameAttr := []smithyxml.Attr{} 7160 customMemberName := smithyxml.StartElement{ 7161 Name: smithyxml.Name{ 7162 Local: "Tag", 7163 }, 7164 Attr: customMemberNameAttr, 7165 } 7166 array = value.ArrayWithCustomName(customMemberName) 7167 for i := range v { 7168 am := array.Member() 7169 if err := awsRestxml_serializeDocumentTag(&v[i], am); err != nil { 7170 return err 7171 } 7172 } 7173 return nil 7174 } 7175 7176 func awsRestxml_serializeDocumentTagResourceIdList(v []string, value smithyxml.Value) error { 7177 var array *smithyxml.Array 7178 if !value.IsFlattened() { 7179 defer value.Close() 7180 } 7181 customMemberNameAttr := []smithyxml.Attr{} 7182 customMemberName := smithyxml.StartElement{ 7183 Name: smithyxml.Name{ 7184 Local: "ResourceId", 7185 }, 7186 Attr: customMemberNameAttr, 7187 } 7188 array = value.ArrayWithCustomName(customMemberName) 7189 for i := range v { 7190 am := array.Member() 7191 am.String(v[i]) 7192 } 7193 return nil 7194 } 7195 7196 func awsRestxml_serializeDocumentVPC(v *types.VPC, value smithyxml.Value) error { 7197 defer value.Close() 7198 if v.VPCId != nil { 7199 rootAttr := []smithyxml.Attr{} 7200 root := smithyxml.StartElement{ 7201 Name: smithyxml.Name{ 7202 Local: "VPCId", 7203 }, 7204 Attr: rootAttr, 7205 } 7206 el := value.MemberElement(root) 7207 el.String(*v.VPCId) 7208 } 7209 if len(v.VPCRegion) > 0 { 7210 rootAttr := []smithyxml.Attr{} 7211 root := smithyxml.StartElement{ 7212 Name: smithyxml.Name{ 7213 Local: "VPCRegion", 7214 }, 7215 Attr: rootAttr, 7216 } 7217 el := value.MemberElement(root) 7218 el.String(string(v.VPCRegion)) 7219 } 7220 return nil 7221 }