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