1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package mediaconnect 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/mediaconnect/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpAddFlowOutputs struct { 18} 19 20func (*awsRestjson1_serializeOpAddFlowOutputs) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpAddFlowOutputs) 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.(*AddFlowOutputsInput) 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("/v1/flows/{FlowArn}/outputs") 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 := awsRestjson1_serializeOpHttpBindingsAddFlowOutputsInput(input, restEncoder); err != nil { 48 return out, metadata, &smithy.SerializationError{Err: err} 49 } 50 51 restEncoder.SetHeader("Content-Type").String("application/json") 52 53 jsonEncoder := smithyjson.NewEncoder() 54 if err := awsRestjson1_serializeOpDocumentAddFlowOutputsInput(input, jsonEncoder.Value); err != nil { 55 return out, metadata, &smithy.SerializationError{Err: err} 56 } 57 58 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 59 return out, metadata, &smithy.SerializationError{Err: err} 60 } 61 62 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 63 return out, metadata, &smithy.SerializationError{Err: err} 64 } 65 in.Request = request 66 67 return next.HandleSerialize(ctx, in) 68} 69func awsRestjson1_serializeOpHttpBindingsAddFlowOutputsInput(v *AddFlowOutputsInput, encoder *httpbinding.Encoder) error { 70 if v == nil { 71 return fmt.Errorf("unsupported serialization of nil %T", v) 72 } 73 74 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 75 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 76 } 77 if v.FlowArn != nil { 78 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 79 return err 80 } 81 } 82 83 return nil 84} 85 86func awsRestjson1_serializeOpDocumentAddFlowOutputsInput(v *AddFlowOutputsInput, value smithyjson.Value) error { 87 object := value.Object() 88 defer object.Close() 89 90 if v.Outputs != nil { 91 ok := object.Key("outputs") 92 if err := awsRestjson1_serializeDocument__listOfAddOutputRequest(v.Outputs, ok); err != nil { 93 return err 94 } 95 } 96 97 return nil 98} 99 100type awsRestjson1_serializeOpAddFlowSources struct { 101} 102 103func (*awsRestjson1_serializeOpAddFlowSources) ID() string { 104 return "OperationSerializer" 105} 106 107func (m *awsRestjson1_serializeOpAddFlowSources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 108 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 109) { 110 request, ok := in.Request.(*smithyhttp.Request) 111 if !ok { 112 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 113 } 114 115 input, ok := in.Parameters.(*AddFlowSourcesInput) 116 _ = input 117 if !ok { 118 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 119 } 120 121 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/source") 122 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 123 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 124 request.Method = "POST" 125 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 126 if err != nil { 127 return out, metadata, &smithy.SerializationError{Err: err} 128 } 129 130 if err := awsRestjson1_serializeOpHttpBindingsAddFlowSourcesInput(input, restEncoder); err != nil { 131 return out, metadata, &smithy.SerializationError{Err: err} 132 } 133 134 restEncoder.SetHeader("Content-Type").String("application/json") 135 136 jsonEncoder := smithyjson.NewEncoder() 137 if err := awsRestjson1_serializeOpDocumentAddFlowSourcesInput(input, jsonEncoder.Value); err != nil { 138 return out, metadata, &smithy.SerializationError{Err: err} 139 } 140 141 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 142 return out, metadata, &smithy.SerializationError{Err: err} 143 } 144 145 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 146 return out, metadata, &smithy.SerializationError{Err: err} 147 } 148 in.Request = request 149 150 return next.HandleSerialize(ctx, in) 151} 152func awsRestjson1_serializeOpHttpBindingsAddFlowSourcesInput(v *AddFlowSourcesInput, encoder *httpbinding.Encoder) error { 153 if v == nil { 154 return fmt.Errorf("unsupported serialization of nil %T", v) 155 } 156 157 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 158 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 159 } 160 if v.FlowArn != nil { 161 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 162 return err 163 } 164 } 165 166 return nil 167} 168 169func awsRestjson1_serializeOpDocumentAddFlowSourcesInput(v *AddFlowSourcesInput, value smithyjson.Value) error { 170 object := value.Object() 171 defer object.Close() 172 173 if v.Sources != nil { 174 ok := object.Key("sources") 175 if err := awsRestjson1_serializeDocument__listOfSetSourceRequest(v.Sources, ok); err != nil { 176 return err 177 } 178 } 179 180 return nil 181} 182 183type awsRestjson1_serializeOpAddFlowVpcInterfaces struct { 184} 185 186func (*awsRestjson1_serializeOpAddFlowVpcInterfaces) ID() string { 187 return "OperationSerializer" 188} 189 190func (m *awsRestjson1_serializeOpAddFlowVpcInterfaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 191 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 192) { 193 request, ok := in.Request.(*smithyhttp.Request) 194 if !ok { 195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 196 } 197 198 input, ok := in.Parameters.(*AddFlowVpcInterfacesInput) 199 _ = input 200 if !ok { 201 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 202 } 203 204 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/vpcInterfaces") 205 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 206 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 207 request.Method = "POST" 208 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 209 if err != nil { 210 return out, metadata, &smithy.SerializationError{Err: err} 211 } 212 213 if err := awsRestjson1_serializeOpHttpBindingsAddFlowVpcInterfacesInput(input, restEncoder); err != nil { 214 return out, metadata, &smithy.SerializationError{Err: err} 215 } 216 217 restEncoder.SetHeader("Content-Type").String("application/json") 218 219 jsonEncoder := smithyjson.NewEncoder() 220 if err := awsRestjson1_serializeOpDocumentAddFlowVpcInterfacesInput(input, jsonEncoder.Value); err != nil { 221 return out, metadata, &smithy.SerializationError{Err: err} 222 } 223 224 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 225 return out, metadata, &smithy.SerializationError{Err: err} 226 } 227 228 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 229 return out, metadata, &smithy.SerializationError{Err: err} 230 } 231 in.Request = request 232 233 return next.HandleSerialize(ctx, in) 234} 235func awsRestjson1_serializeOpHttpBindingsAddFlowVpcInterfacesInput(v *AddFlowVpcInterfacesInput, encoder *httpbinding.Encoder) error { 236 if v == nil { 237 return fmt.Errorf("unsupported serialization of nil %T", v) 238 } 239 240 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 241 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 242 } 243 if v.FlowArn != nil { 244 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 245 return err 246 } 247 } 248 249 return nil 250} 251 252func awsRestjson1_serializeOpDocumentAddFlowVpcInterfacesInput(v *AddFlowVpcInterfacesInput, value smithyjson.Value) error { 253 object := value.Object() 254 defer object.Close() 255 256 if v.VpcInterfaces != nil { 257 ok := object.Key("vpcInterfaces") 258 if err := awsRestjson1_serializeDocument__listOfVpcInterfaceRequest(v.VpcInterfaces, ok); err != nil { 259 return err 260 } 261 } 262 263 return nil 264} 265 266type awsRestjson1_serializeOpCreateFlow struct { 267} 268 269func (*awsRestjson1_serializeOpCreateFlow) ID() string { 270 return "OperationSerializer" 271} 272 273func (m *awsRestjson1_serializeOpCreateFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 274 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 275) { 276 request, ok := in.Request.(*smithyhttp.Request) 277 if !ok { 278 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 279 } 280 281 input, ok := in.Parameters.(*CreateFlowInput) 282 _ = input 283 if !ok { 284 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 285 } 286 287 opPath, opQuery := httpbinding.SplitURI("/v1/flows") 288 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 289 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 290 request.Method = "POST" 291 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 292 if err != nil { 293 return out, metadata, &smithy.SerializationError{Err: err} 294 } 295 296 restEncoder.SetHeader("Content-Type").String("application/json") 297 298 jsonEncoder := smithyjson.NewEncoder() 299 if err := awsRestjson1_serializeOpDocumentCreateFlowInput(input, jsonEncoder.Value); err != nil { 300 return out, metadata, &smithy.SerializationError{Err: err} 301 } 302 303 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 304 return out, metadata, &smithy.SerializationError{Err: err} 305 } 306 307 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 308 return out, metadata, &smithy.SerializationError{Err: err} 309 } 310 in.Request = request 311 312 return next.HandleSerialize(ctx, in) 313} 314func awsRestjson1_serializeOpHttpBindingsCreateFlowInput(v *CreateFlowInput, encoder *httpbinding.Encoder) error { 315 if v == nil { 316 return fmt.Errorf("unsupported serialization of nil %T", v) 317 } 318 319 return nil 320} 321 322func awsRestjson1_serializeOpDocumentCreateFlowInput(v *CreateFlowInput, value smithyjson.Value) error { 323 object := value.Object() 324 defer object.Close() 325 326 if v.AvailabilityZone != nil { 327 ok := object.Key("availabilityZone") 328 ok.String(*v.AvailabilityZone) 329 } 330 331 if v.Entitlements != nil { 332 ok := object.Key("entitlements") 333 if err := awsRestjson1_serializeDocument__listOfGrantEntitlementRequest(v.Entitlements, ok); err != nil { 334 return err 335 } 336 } 337 338 if v.Name != nil { 339 ok := object.Key("name") 340 ok.String(*v.Name) 341 } 342 343 if v.Outputs != nil { 344 ok := object.Key("outputs") 345 if err := awsRestjson1_serializeDocument__listOfAddOutputRequest(v.Outputs, ok); err != nil { 346 return err 347 } 348 } 349 350 if v.Source != nil { 351 ok := object.Key("source") 352 if err := awsRestjson1_serializeDocumentSetSourceRequest(v.Source, ok); err != nil { 353 return err 354 } 355 } 356 357 if v.SourceFailoverConfig != nil { 358 ok := object.Key("sourceFailoverConfig") 359 if err := awsRestjson1_serializeDocumentFailoverConfig(v.SourceFailoverConfig, ok); err != nil { 360 return err 361 } 362 } 363 364 if v.Sources != nil { 365 ok := object.Key("sources") 366 if err := awsRestjson1_serializeDocument__listOfSetSourceRequest(v.Sources, ok); err != nil { 367 return err 368 } 369 } 370 371 if v.VpcInterfaces != nil { 372 ok := object.Key("vpcInterfaces") 373 if err := awsRestjson1_serializeDocument__listOfVpcInterfaceRequest(v.VpcInterfaces, ok); err != nil { 374 return err 375 } 376 } 377 378 return nil 379} 380 381type awsRestjson1_serializeOpDeleteFlow struct { 382} 383 384func (*awsRestjson1_serializeOpDeleteFlow) ID() string { 385 return "OperationSerializer" 386} 387 388func (m *awsRestjson1_serializeOpDeleteFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 389 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 390) { 391 request, ok := in.Request.(*smithyhttp.Request) 392 if !ok { 393 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 394 } 395 396 input, ok := in.Parameters.(*DeleteFlowInput) 397 _ = input 398 if !ok { 399 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 400 } 401 402 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}") 403 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 404 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 405 request.Method = "DELETE" 406 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 407 if err != nil { 408 return out, metadata, &smithy.SerializationError{Err: err} 409 } 410 411 if err := awsRestjson1_serializeOpHttpBindingsDeleteFlowInput(input, restEncoder); err != nil { 412 return out, metadata, &smithy.SerializationError{Err: err} 413 } 414 415 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 416 return out, metadata, &smithy.SerializationError{Err: err} 417 } 418 in.Request = request 419 420 return next.HandleSerialize(ctx, in) 421} 422func awsRestjson1_serializeOpHttpBindingsDeleteFlowInput(v *DeleteFlowInput, encoder *httpbinding.Encoder) error { 423 if v == nil { 424 return fmt.Errorf("unsupported serialization of nil %T", v) 425 } 426 427 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 428 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 429 } 430 if v.FlowArn != nil { 431 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 432 return err 433 } 434 } 435 436 return nil 437} 438 439type awsRestjson1_serializeOpDescribeFlow struct { 440} 441 442func (*awsRestjson1_serializeOpDescribeFlow) ID() string { 443 return "OperationSerializer" 444} 445 446func (m *awsRestjson1_serializeOpDescribeFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 447 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 448) { 449 request, ok := in.Request.(*smithyhttp.Request) 450 if !ok { 451 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 452 } 453 454 input, ok := in.Parameters.(*DescribeFlowInput) 455 _ = input 456 if !ok { 457 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 458 } 459 460 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}") 461 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 462 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 463 request.Method = "GET" 464 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 465 if err != nil { 466 return out, metadata, &smithy.SerializationError{Err: err} 467 } 468 469 if err := awsRestjson1_serializeOpHttpBindingsDescribeFlowInput(input, restEncoder); err != nil { 470 return out, metadata, &smithy.SerializationError{Err: err} 471 } 472 473 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 474 return out, metadata, &smithy.SerializationError{Err: err} 475 } 476 in.Request = request 477 478 return next.HandleSerialize(ctx, in) 479} 480func awsRestjson1_serializeOpHttpBindingsDescribeFlowInput(v *DescribeFlowInput, encoder *httpbinding.Encoder) error { 481 if v == nil { 482 return fmt.Errorf("unsupported serialization of nil %T", v) 483 } 484 485 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 486 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 487 } 488 if v.FlowArn != nil { 489 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 490 return err 491 } 492 } 493 494 return nil 495} 496 497type awsRestjson1_serializeOpDescribeOffering struct { 498} 499 500func (*awsRestjson1_serializeOpDescribeOffering) ID() string { 501 return "OperationSerializer" 502} 503 504func (m *awsRestjson1_serializeOpDescribeOffering) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 505 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 506) { 507 request, ok := in.Request.(*smithyhttp.Request) 508 if !ok { 509 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 510 } 511 512 input, ok := in.Parameters.(*DescribeOfferingInput) 513 _ = input 514 if !ok { 515 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 516 } 517 518 opPath, opQuery := httpbinding.SplitURI("/v1/offerings/{OfferingArn}") 519 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 520 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 521 request.Method = "GET" 522 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 523 if err != nil { 524 return out, metadata, &smithy.SerializationError{Err: err} 525 } 526 527 if err := awsRestjson1_serializeOpHttpBindingsDescribeOfferingInput(input, restEncoder); err != nil { 528 return out, metadata, &smithy.SerializationError{Err: err} 529 } 530 531 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 532 return out, metadata, &smithy.SerializationError{Err: err} 533 } 534 in.Request = request 535 536 return next.HandleSerialize(ctx, in) 537} 538func awsRestjson1_serializeOpHttpBindingsDescribeOfferingInput(v *DescribeOfferingInput, encoder *httpbinding.Encoder) error { 539 if v == nil { 540 return fmt.Errorf("unsupported serialization of nil %T", v) 541 } 542 543 if v.OfferingArn == nil || len(*v.OfferingArn) == 0 { 544 return &smithy.SerializationError{Err: fmt.Errorf("input member OfferingArn must not be empty")} 545 } 546 if v.OfferingArn != nil { 547 if err := encoder.SetURI("OfferingArn").String(*v.OfferingArn); err != nil { 548 return err 549 } 550 } 551 552 return nil 553} 554 555type awsRestjson1_serializeOpDescribeReservation struct { 556} 557 558func (*awsRestjson1_serializeOpDescribeReservation) ID() string { 559 return "OperationSerializer" 560} 561 562func (m *awsRestjson1_serializeOpDescribeReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 563 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 564) { 565 request, ok := in.Request.(*smithyhttp.Request) 566 if !ok { 567 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 568 } 569 570 input, ok := in.Parameters.(*DescribeReservationInput) 571 _ = input 572 if !ok { 573 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 574 } 575 576 opPath, opQuery := httpbinding.SplitURI("/v1/reservations/{ReservationArn}") 577 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 578 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 579 request.Method = "GET" 580 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 581 if err != nil { 582 return out, metadata, &smithy.SerializationError{Err: err} 583 } 584 585 if err := awsRestjson1_serializeOpHttpBindingsDescribeReservationInput(input, restEncoder); err != nil { 586 return out, metadata, &smithy.SerializationError{Err: err} 587 } 588 589 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 590 return out, metadata, &smithy.SerializationError{Err: err} 591 } 592 in.Request = request 593 594 return next.HandleSerialize(ctx, in) 595} 596func awsRestjson1_serializeOpHttpBindingsDescribeReservationInput(v *DescribeReservationInput, encoder *httpbinding.Encoder) error { 597 if v == nil { 598 return fmt.Errorf("unsupported serialization of nil %T", v) 599 } 600 601 if v.ReservationArn == nil || len(*v.ReservationArn) == 0 { 602 return &smithy.SerializationError{Err: fmt.Errorf("input member ReservationArn must not be empty")} 603 } 604 if v.ReservationArn != nil { 605 if err := encoder.SetURI("ReservationArn").String(*v.ReservationArn); err != nil { 606 return err 607 } 608 } 609 610 return nil 611} 612 613type awsRestjson1_serializeOpGrantFlowEntitlements struct { 614} 615 616func (*awsRestjson1_serializeOpGrantFlowEntitlements) ID() string { 617 return "OperationSerializer" 618} 619 620func (m *awsRestjson1_serializeOpGrantFlowEntitlements) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 621 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 622) { 623 request, ok := in.Request.(*smithyhttp.Request) 624 if !ok { 625 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 626 } 627 628 input, ok := in.Parameters.(*GrantFlowEntitlementsInput) 629 _ = input 630 if !ok { 631 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 632 } 633 634 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/entitlements") 635 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 636 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 637 request.Method = "POST" 638 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 639 if err != nil { 640 return out, metadata, &smithy.SerializationError{Err: err} 641 } 642 643 if err := awsRestjson1_serializeOpHttpBindingsGrantFlowEntitlementsInput(input, restEncoder); err != nil { 644 return out, metadata, &smithy.SerializationError{Err: err} 645 } 646 647 restEncoder.SetHeader("Content-Type").String("application/json") 648 649 jsonEncoder := smithyjson.NewEncoder() 650 if err := awsRestjson1_serializeOpDocumentGrantFlowEntitlementsInput(input, jsonEncoder.Value); err != nil { 651 return out, metadata, &smithy.SerializationError{Err: err} 652 } 653 654 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 655 return out, metadata, &smithy.SerializationError{Err: err} 656 } 657 658 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 659 return out, metadata, &smithy.SerializationError{Err: err} 660 } 661 in.Request = request 662 663 return next.HandleSerialize(ctx, in) 664} 665func awsRestjson1_serializeOpHttpBindingsGrantFlowEntitlementsInput(v *GrantFlowEntitlementsInput, encoder *httpbinding.Encoder) error { 666 if v == nil { 667 return fmt.Errorf("unsupported serialization of nil %T", v) 668 } 669 670 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 671 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 672 } 673 if v.FlowArn != nil { 674 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 675 return err 676 } 677 } 678 679 return nil 680} 681 682func awsRestjson1_serializeOpDocumentGrantFlowEntitlementsInput(v *GrantFlowEntitlementsInput, value smithyjson.Value) error { 683 object := value.Object() 684 defer object.Close() 685 686 if v.Entitlements != nil { 687 ok := object.Key("entitlements") 688 if err := awsRestjson1_serializeDocument__listOfGrantEntitlementRequest(v.Entitlements, ok); err != nil { 689 return err 690 } 691 } 692 693 return nil 694} 695 696type awsRestjson1_serializeOpListEntitlements struct { 697} 698 699func (*awsRestjson1_serializeOpListEntitlements) ID() string { 700 return "OperationSerializer" 701} 702 703func (m *awsRestjson1_serializeOpListEntitlements) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 704 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 705) { 706 request, ok := in.Request.(*smithyhttp.Request) 707 if !ok { 708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 709 } 710 711 input, ok := in.Parameters.(*ListEntitlementsInput) 712 _ = input 713 if !ok { 714 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 715 } 716 717 opPath, opQuery := httpbinding.SplitURI("/v1/entitlements") 718 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 719 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 720 request.Method = "GET" 721 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 722 if err != nil { 723 return out, metadata, &smithy.SerializationError{Err: err} 724 } 725 726 if err := awsRestjson1_serializeOpHttpBindingsListEntitlementsInput(input, restEncoder); err != nil { 727 return out, metadata, &smithy.SerializationError{Err: err} 728 } 729 730 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 731 return out, metadata, &smithy.SerializationError{Err: err} 732 } 733 in.Request = request 734 735 return next.HandleSerialize(ctx, in) 736} 737func awsRestjson1_serializeOpHttpBindingsListEntitlementsInput(v *ListEntitlementsInput, encoder *httpbinding.Encoder) error { 738 if v == nil { 739 return fmt.Errorf("unsupported serialization of nil %T", v) 740 } 741 742 if v.MaxResults != 0 { 743 encoder.SetQuery("maxResults").Integer(v.MaxResults) 744 } 745 746 if v.NextToken != nil { 747 encoder.SetQuery("nextToken").String(*v.NextToken) 748 } 749 750 return nil 751} 752 753type awsRestjson1_serializeOpListFlows struct { 754} 755 756func (*awsRestjson1_serializeOpListFlows) ID() string { 757 return "OperationSerializer" 758} 759 760func (m *awsRestjson1_serializeOpListFlows) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 761 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 762) { 763 request, ok := in.Request.(*smithyhttp.Request) 764 if !ok { 765 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 766 } 767 768 input, ok := in.Parameters.(*ListFlowsInput) 769 _ = input 770 if !ok { 771 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 772 } 773 774 opPath, opQuery := httpbinding.SplitURI("/v1/flows") 775 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 776 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 777 request.Method = "GET" 778 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 779 if err != nil { 780 return out, metadata, &smithy.SerializationError{Err: err} 781 } 782 783 if err := awsRestjson1_serializeOpHttpBindingsListFlowsInput(input, restEncoder); err != nil { 784 return out, metadata, &smithy.SerializationError{Err: err} 785 } 786 787 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 788 return out, metadata, &smithy.SerializationError{Err: err} 789 } 790 in.Request = request 791 792 return next.HandleSerialize(ctx, in) 793} 794func awsRestjson1_serializeOpHttpBindingsListFlowsInput(v *ListFlowsInput, encoder *httpbinding.Encoder) error { 795 if v == nil { 796 return fmt.Errorf("unsupported serialization of nil %T", v) 797 } 798 799 if v.MaxResults != 0 { 800 encoder.SetQuery("maxResults").Integer(v.MaxResults) 801 } 802 803 if v.NextToken != nil { 804 encoder.SetQuery("nextToken").String(*v.NextToken) 805 } 806 807 return nil 808} 809 810type awsRestjson1_serializeOpListOfferings struct { 811} 812 813func (*awsRestjson1_serializeOpListOfferings) ID() string { 814 return "OperationSerializer" 815} 816 817func (m *awsRestjson1_serializeOpListOfferings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 818 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 819) { 820 request, ok := in.Request.(*smithyhttp.Request) 821 if !ok { 822 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 823 } 824 825 input, ok := in.Parameters.(*ListOfferingsInput) 826 _ = input 827 if !ok { 828 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 829 } 830 831 opPath, opQuery := httpbinding.SplitURI("/v1/offerings") 832 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 833 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 834 request.Method = "GET" 835 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 836 if err != nil { 837 return out, metadata, &smithy.SerializationError{Err: err} 838 } 839 840 if err := awsRestjson1_serializeOpHttpBindingsListOfferingsInput(input, restEncoder); err != nil { 841 return out, metadata, &smithy.SerializationError{Err: err} 842 } 843 844 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 845 return out, metadata, &smithy.SerializationError{Err: err} 846 } 847 in.Request = request 848 849 return next.HandleSerialize(ctx, in) 850} 851func awsRestjson1_serializeOpHttpBindingsListOfferingsInput(v *ListOfferingsInput, encoder *httpbinding.Encoder) error { 852 if v == nil { 853 return fmt.Errorf("unsupported serialization of nil %T", v) 854 } 855 856 if v.MaxResults != 0 { 857 encoder.SetQuery("maxResults").Integer(v.MaxResults) 858 } 859 860 if v.NextToken != nil { 861 encoder.SetQuery("nextToken").String(*v.NextToken) 862 } 863 864 return nil 865} 866 867type awsRestjson1_serializeOpListReservations struct { 868} 869 870func (*awsRestjson1_serializeOpListReservations) ID() string { 871 return "OperationSerializer" 872} 873 874func (m *awsRestjson1_serializeOpListReservations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 875 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 876) { 877 request, ok := in.Request.(*smithyhttp.Request) 878 if !ok { 879 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 880 } 881 882 input, ok := in.Parameters.(*ListReservationsInput) 883 _ = input 884 if !ok { 885 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 886 } 887 888 opPath, opQuery := httpbinding.SplitURI("/v1/reservations") 889 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 890 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 891 request.Method = "GET" 892 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 893 if err != nil { 894 return out, metadata, &smithy.SerializationError{Err: err} 895 } 896 897 if err := awsRestjson1_serializeOpHttpBindingsListReservationsInput(input, restEncoder); err != nil { 898 return out, metadata, &smithy.SerializationError{Err: err} 899 } 900 901 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 902 return out, metadata, &smithy.SerializationError{Err: err} 903 } 904 in.Request = request 905 906 return next.HandleSerialize(ctx, in) 907} 908func awsRestjson1_serializeOpHttpBindingsListReservationsInput(v *ListReservationsInput, encoder *httpbinding.Encoder) error { 909 if v == nil { 910 return fmt.Errorf("unsupported serialization of nil %T", v) 911 } 912 913 if v.MaxResults != 0 { 914 encoder.SetQuery("maxResults").Integer(v.MaxResults) 915 } 916 917 if v.NextToken != nil { 918 encoder.SetQuery("nextToken").String(*v.NextToken) 919 } 920 921 return nil 922} 923 924type awsRestjson1_serializeOpListTagsForResource struct { 925} 926 927func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 928 return "OperationSerializer" 929} 930 931func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 932 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 933) { 934 request, ok := in.Request.(*smithyhttp.Request) 935 if !ok { 936 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 937 } 938 939 input, ok := in.Parameters.(*ListTagsForResourceInput) 940 _ = input 941 if !ok { 942 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 943 } 944 945 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 946 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 947 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 948 request.Method = "GET" 949 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 950 if err != nil { 951 return out, metadata, &smithy.SerializationError{Err: err} 952 } 953 954 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 955 return out, metadata, &smithy.SerializationError{Err: err} 956 } 957 958 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 959 return out, metadata, &smithy.SerializationError{Err: err} 960 } 961 in.Request = request 962 963 return next.HandleSerialize(ctx, in) 964} 965func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 966 if v == nil { 967 return fmt.Errorf("unsupported serialization of nil %T", v) 968 } 969 970 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 971 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 972 } 973 if v.ResourceArn != nil { 974 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 975 return err 976 } 977 } 978 979 return nil 980} 981 982type awsRestjson1_serializeOpPurchaseOffering struct { 983} 984 985func (*awsRestjson1_serializeOpPurchaseOffering) ID() string { 986 return "OperationSerializer" 987} 988 989func (m *awsRestjson1_serializeOpPurchaseOffering) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 990 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 991) { 992 request, ok := in.Request.(*smithyhttp.Request) 993 if !ok { 994 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 995 } 996 997 input, ok := in.Parameters.(*PurchaseOfferingInput) 998 _ = input 999 if !ok { 1000 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1001 } 1002 1003 opPath, opQuery := httpbinding.SplitURI("/v1/offerings/{OfferingArn}") 1004 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1005 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1006 request.Method = "POST" 1007 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1008 if err != nil { 1009 return out, metadata, &smithy.SerializationError{Err: err} 1010 } 1011 1012 if err := awsRestjson1_serializeOpHttpBindingsPurchaseOfferingInput(input, restEncoder); err != nil { 1013 return out, metadata, &smithy.SerializationError{Err: err} 1014 } 1015 1016 restEncoder.SetHeader("Content-Type").String("application/json") 1017 1018 jsonEncoder := smithyjson.NewEncoder() 1019 if err := awsRestjson1_serializeOpDocumentPurchaseOfferingInput(input, jsonEncoder.Value); err != nil { 1020 return out, metadata, &smithy.SerializationError{Err: err} 1021 } 1022 1023 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1024 return out, metadata, &smithy.SerializationError{Err: err} 1025 } 1026 1027 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1028 return out, metadata, &smithy.SerializationError{Err: err} 1029 } 1030 in.Request = request 1031 1032 return next.HandleSerialize(ctx, in) 1033} 1034func awsRestjson1_serializeOpHttpBindingsPurchaseOfferingInput(v *PurchaseOfferingInput, encoder *httpbinding.Encoder) error { 1035 if v == nil { 1036 return fmt.Errorf("unsupported serialization of nil %T", v) 1037 } 1038 1039 if v.OfferingArn == nil || len(*v.OfferingArn) == 0 { 1040 return &smithy.SerializationError{Err: fmt.Errorf("input member OfferingArn must not be empty")} 1041 } 1042 if v.OfferingArn != nil { 1043 if err := encoder.SetURI("OfferingArn").String(*v.OfferingArn); err != nil { 1044 return err 1045 } 1046 } 1047 1048 return nil 1049} 1050 1051func awsRestjson1_serializeOpDocumentPurchaseOfferingInput(v *PurchaseOfferingInput, value smithyjson.Value) error { 1052 object := value.Object() 1053 defer object.Close() 1054 1055 if v.ReservationName != nil { 1056 ok := object.Key("reservationName") 1057 ok.String(*v.ReservationName) 1058 } 1059 1060 if v.Start != nil { 1061 ok := object.Key("start") 1062 ok.String(*v.Start) 1063 } 1064 1065 return nil 1066} 1067 1068type awsRestjson1_serializeOpRemoveFlowOutput struct { 1069} 1070 1071func (*awsRestjson1_serializeOpRemoveFlowOutput) ID() string { 1072 return "OperationSerializer" 1073} 1074 1075func (m *awsRestjson1_serializeOpRemoveFlowOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1076 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1077) { 1078 request, ok := in.Request.(*smithyhttp.Request) 1079 if !ok { 1080 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1081 } 1082 1083 input, ok := in.Parameters.(*RemoveFlowOutputInput) 1084 _ = input 1085 if !ok { 1086 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1087 } 1088 1089 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/outputs/{OutputArn}") 1090 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1091 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1092 request.Method = "DELETE" 1093 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1094 if err != nil { 1095 return out, metadata, &smithy.SerializationError{Err: err} 1096 } 1097 1098 if err := awsRestjson1_serializeOpHttpBindingsRemoveFlowOutputInput(input, restEncoder); err != nil { 1099 return out, metadata, &smithy.SerializationError{Err: err} 1100 } 1101 1102 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1103 return out, metadata, &smithy.SerializationError{Err: err} 1104 } 1105 in.Request = request 1106 1107 return next.HandleSerialize(ctx, in) 1108} 1109func awsRestjson1_serializeOpHttpBindingsRemoveFlowOutputInput(v *RemoveFlowOutputInput, encoder *httpbinding.Encoder) error { 1110 if v == nil { 1111 return fmt.Errorf("unsupported serialization of nil %T", v) 1112 } 1113 1114 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1115 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1116 } 1117 if v.FlowArn != nil { 1118 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1119 return err 1120 } 1121 } 1122 1123 if v.OutputArn == nil || len(*v.OutputArn) == 0 { 1124 return &smithy.SerializationError{Err: fmt.Errorf("input member OutputArn must not be empty")} 1125 } 1126 if v.OutputArn != nil { 1127 if err := encoder.SetURI("OutputArn").String(*v.OutputArn); err != nil { 1128 return err 1129 } 1130 } 1131 1132 return nil 1133} 1134 1135type awsRestjson1_serializeOpRemoveFlowSource struct { 1136} 1137 1138func (*awsRestjson1_serializeOpRemoveFlowSource) ID() string { 1139 return "OperationSerializer" 1140} 1141 1142func (m *awsRestjson1_serializeOpRemoveFlowSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1143 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1144) { 1145 request, ok := in.Request.(*smithyhttp.Request) 1146 if !ok { 1147 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1148 } 1149 1150 input, ok := in.Parameters.(*RemoveFlowSourceInput) 1151 _ = input 1152 if !ok { 1153 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1154 } 1155 1156 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/source/{SourceArn}") 1157 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1158 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1159 request.Method = "DELETE" 1160 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1161 if err != nil { 1162 return out, metadata, &smithy.SerializationError{Err: err} 1163 } 1164 1165 if err := awsRestjson1_serializeOpHttpBindingsRemoveFlowSourceInput(input, restEncoder); err != nil { 1166 return out, metadata, &smithy.SerializationError{Err: err} 1167 } 1168 1169 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1170 return out, metadata, &smithy.SerializationError{Err: err} 1171 } 1172 in.Request = request 1173 1174 return next.HandleSerialize(ctx, in) 1175} 1176func awsRestjson1_serializeOpHttpBindingsRemoveFlowSourceInput(v *RemoveFlowSourceInput, encoder *httpbinding.Encoder) error { 1177 if v == nil { 1178 return fmt.Errorf("unsupported serialization of nil %T", v) 1179 } 1180 1181 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1182 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1183 } 1184 if v.FlowArn != nil { 1185 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1186 return err 1187 } 1188 } 1189 1190 if v.SourceArn == nil || len(*v.SourceArn) == 0 { 1191 return &smithy.SerializationError{Err: fmt.Errorf("input member SourceArn must not be empty")} 1192 } 1193 if v.SourceArn != nil { 1194 if err := encoder.SetURI("SourceArn").String(*v.SourceArn); err != nil { 1195 return err 1196 } 1197 } 1198 1199 return nil 1200} 1201 1202type awsRestjson1_serializeOpRemoveFlowVpcInterface struct { 1203} 1204 1205func (*awsRestjson1_serializeOpRemoveFlowVpcInterface) ID() string { 1206 return "OperationSerializer" 1207} 1208 1209func (m *awsRestjson1_serializeOpRemoveFlowVpcInterface) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1210 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1211) { 1212 request, ok := in.Request.(*smithyhttp.Request) 1213 if !ok { 1214 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1215 } 1216 1217 input, ok := in.Parameters.(*RemoveFlowVpcInterfaceInput) 1218 _ = input 1219 if !ok { 1220 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1221 } 1222 1223 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/vpcInterfaces/{VpcInterfaceName}") 1224 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1225 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1226 request.Method = "DELETE" 1227 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1228 if err != nil { 1229 return out, metadata, &smithy.SerializationError{Err: err} 1230 } 1231 1232 if err := awsRestjson1_serializeOpHttpBindingsRemoveFlowVpcInterfaceInput(input, restEncoder); err != nil { 1233 return out, metadata, &smithy.SerializationError{Err: err} 1234 } 1235 1236 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1237 return out, metadata, &smithy.SerializationError{Err: err} 1238 } 1239 in.Request = request 1240 1241 return next.HandleSerialize(ctx, in) 1242} 1243func awsRestjson1_serializeOpHttpBindingsRemoveFlowVpcInterfaceInput(v *RemoveFlowVpcInterfaceInput, encoder *httpbinding.Encoder) error { 1244 if v == nil { 1245 return fmt.Errorf("unsupported serialization of nil %T", v) 1246 } 1247 1248 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1249 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1250 } 1251 if v.FlowArn != nil { 1252 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1253 return err 1254 } 1255 } 1256 1257 if v.VpcInterfaceName == nil || len(*v.VpcInterfaceName) == 0 { 1258 return &smithy.SerializationError{Err: fmt.Errorf("input member VpcInterfaceName must not be empty")} 1259 } 1260 if v.VpcInterfaceName != nil { 1261 if err := encoder.SetURI("VpcInterfaceName").String(*v.VpcInterfaceName); err != nil { 1262 return err 1263 } 1264 } 1265 1266 return nil 1267} 1268 1269type awsRestjson1_serializeOpRevokeFlowEntitlement struct { 1270} 1271 1272func (*awsRestjson1_serializeOpRevokeFlowEntitlement) ID() string { 1273 return "OperationSerializer" 1274} 1275 1276func (m *awsRestjson1_serializeOpRevokeFlowEntitlement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1277 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1278) { 1279 request, ok := in.Request.(*smithyhttp.Request) 1280 if !ok { 1281 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1282 } 1283 1284 input, ok := in.Parameters.(*RevokeFlowEntitlementInput) 1285 _ = input 1286 if !ok { 1287 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1288 } 1289 1290 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/entitlements/{EntitlementArn}") 1291 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1292 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1293 request.Method = "DELETE" 1294 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1295 if err != nil { 1296 return out, metadata, &smithy.SerializationError{Err: err} 1297 } 1298 1299 if err := awsRestjson1_serializeOpHttpBindingsRevokeFlowEntitlementInput(input, restEncoder); err != nil { 1300 return out, metadata, &smithy.SerializationError{Err: err} 1301 } 1302 1303 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1304 return out, metadata, &smithy.SerializationError{Err: err} 1305 } 1306 in.Request = request 1307 1308 return next.HandleSerialize(ctx, in) 1309} 1310func awsRestjson1_serializeOpHttpBindingsRevokeFlowEntitlementInput(v *RevokeFlowEntitlementInput, encoder *httpbinding.Encoder) error { 1311 if v == nil { 1312 return fmt.Errorf("unsupported serialization of nil %T", v) 1313 } 1314 1315 if v.EntitlementArn == nil || len(*v.EntitlementArn) == 0 { 1316 return &smithy.SerializationError{Err: fmt.Errorf("input member EntitlementArn must not be empty")} 1317 } 1318 if v.EntitlementArn != nil { 1319 if err := encoder.SetURI("EntitlementArn").String(*v.EntitlementArn); err != nil { 1320 return err 1321 } 1322 } 1323 1324 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1325 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1326 } 1327 if v.FlowArn != nil { 1328 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1329 return err 1330 } 1331 } 1332 1333 return nil 1334} 1335 1336type awsRestjson1_serializeOpStartFlow struct { 1337} 1338 1339func (*awsRestjson1_serializeOpStartFlow) ID() string { 1340 return "OperationSerializer" 1341} 1342 1343func (m *awsRestjson1_serializeOpStartFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1344 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1345) { 1346 request, ok := in.Request.(*smithyhttp.Request) 1347 if !ok { 1348 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1349 } 1350 1351 input, ok := in.Parameters.(*StartFlowInput) 1352 _ = input 1353 if !ok { 1354 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1355 } 1356 1357 opPath, opQuery := httpbinding.SplitURI("/v1/flows/start/{FlowArn}") 1358 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1359 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1360 request.Method = "POST" 1361 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1362 if err != nil { 1363 return out, metadata, &smithy.SerializationError{Err: err} 1364 } 1365 1366 if err := awsRestjson1_serializeOpHttpBindingsStartFlowInput(input, restEncoder); err != nil { 1367 return out, metadata, &smithy.SerializationError{Err: err} 1368 } 1369 1370 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1371 return out, metadata, &smithy.SerializationError{Err: err} 1372 } 1373 in.Request = request 1374 1375 return next.HandleSerialize(ctx, in) 1376} 1377func awsRestjson1_serializeOpHttpBindingsStartFlowInput(v *StartFlowInput, encoder *httpbinding.Encoder) error { 1378 if v == nil { 1379 return fmt.Errorf("unsupported serialization of nil %T", v) 1380 } 1381 1382 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1383 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1384 } 1385 if v.FlowArn != nil { 1386 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1387 return err 1388 } 1389 } 1390 1391 return nil 1392} 1393 1394type awsRestjson1_serializeOpStopFlow struct { 1395} 1396 1397func (*awsRestjson1_serializeOpStopFlow) ID() string { 1398 return "OperationSerializer" 1399} 1400 1401func (m *awsRestjson1_serializeOpStopFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1402 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1403) { 1404 request, ok := in.Request.(*smithyhttp.Request) 1405 if !ok { 1406 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1407 } 1408 1409 input, ok := in.Parameters.(*StopFlowInput) 1410 _ = input 1411 if !ok { 1412 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1413 } 1414 1415 opPath, opQuery := httpbinding.SplitURI("/v1/flows/stop/{FlowArn}") 1416 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1417 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1418 request.Method = "POST" 1419 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1420 if err != nil { 1421 return out, metadata, &smithy.SerializationError{Err: err} 1422 } 1423 1424 if err := awsRestjson1_serializeOpHttpBindingsStopFlowInput(input, restEncoder); err != nil { 1425 return out, metadata, &smithy.SerializationError{Err: err} 1426 } 1427 1428 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1429 return out, metadata, &smithy.SerializationError{Err: err} 1430 } 1431 in.Request = request 1432 1433 return next.HandleSerialize(ctx, in) 1434} 1435func awsRestjson1_serializeOpHttpBindingsStopFlowInput(v *StopFlowInput, encoder *httpbinding.Encoder) error { 1436 if v == nil { 1437 return fmt.Errorf("unsupported serialization of nil %T", v) 1438 } 1439 1440 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1441 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1442 } 1443 if v.FlowArn != nil { 1444 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1445 return err 1446 } 1447 } 1448 1449 return nil 1450} 1451 1452type awsRestjson1_serializeOpTagResource struct { 1453} 1454 1455func (*awsRestjson1_serializeOpTagResource) ID() string { 1456 return "OperationSerializer" 1457} 1458 1459func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1460 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1461) { 1462 request, ok := in.Request.(*smithyhttp.Request) 1463 if !ok { 1464 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1465 } 1466 1467 input, ok := in.Parameters.(*TagResourceInput) 1468 _ = input 1469 if !ok { 1470 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1471 } 1472 1473 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1474 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1475 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1476 request.Method = "POST" 1477 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1478 if err != nil { 1479 return out, metadata, &smithy.SerializationError{Err: err} 1480 } 1481 1482 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 1483 return out, metadata, &smithy.SerializationError{Err: err} 1484 } 1485 1486 restEncoder.SetHeader("Content-Type").String("application/json") 1487 1488 jsonEncoder := smithyjson.NewEncoder() 1489 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1490 return out, metadata, &smithy.SerializationError{Err: err} 1491 } 1492 1493 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1494 return out, metadata, &smithy.SerializationError{Err: err} 1495 } 1496 1497 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1498 return out, metadata, &smithy.SerializationError{Err: err} 1499 } 1500 in.Request = request 1501 1502 return next.HandleSerialize(ctx, in) 1503} 1504func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 1505 if v == nil { 1506 return fmt.Errorf("unsupported serialization of nil %T", v) 1507 } 1508 1509 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1510 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1511 } 1512 if v.ResourceArn != nil { 1513 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1514 return err 1515 } 1516 } 1517 1518 return nil 1519} 1520 1521func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 1522 object := value.Object() 1523 defer object.Close() 1524 1525 if v.Tags != nil { 1526 ok := object.Key("tags") 1527 if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil { 1528 return err 1529 } 1530 } 1531 1532 return nil 1533} 1534 1535type awsRestjson1_serializeOpUntagResource struct { 1536} 1537 1538func (*awsRestjson1_serializeOpUntagResource) ID() string { 1539 return "OperationSerializer" 1540} 1541 1542func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1543 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1544) { 1545 request, ok := in.Request.(*smithyhttp.Request) 1546 if !ok { 1547 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1548 } 1549 1550 input, ok := in.Parameters.(*UntagResourceInput) 1551 _ = input 1552 if !ok { 1553 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1554 } 1555 1556 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1557 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1558 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1559 request.Method = "DELETE" 1560 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1561 if err != nil { 1562 return out, metadata, &smithy.SerializationError{Err: err} 1563 } 1564 1565 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 1566 return out, metadata, &smithy.SerializationError{Err: err} 1567 } 1568 1569 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1570 return out, metadata, &smithy.SerializationError{Err: err} 1571 } 1572 in.Request = request 1573 1574 return next.HandleSerialize(ctx, in) 1575} 1576func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 1577 if v == nil { 1578 return fmt.Errorf("unsupported serialization of nil %T", v) 1579 } 1580 1581 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1582 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1583 } 1584 if v.ResourceArn != nil { 1585 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1586 return err 1587 } 1588 } 1589 1590 if v.TagKeys != nil { 1591 for i := range v.TagKeys { 1592 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 1593 } 1594 } 1595 1596 return nil 1597} 1598 1599type awsRestjson1_serializeOpUpdateFlow struct { 1600} 1601 1602func (*awsRestjson1_serializeOpUpdateFlow) ID() string { 1603 return "OperationSerializer" 1604} 1605 1606func (m *awsRestjson1_serializeOpUpdateFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1607 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1608) { 1609 request, ok := in.Request.(*smithyhttp.Request) 1610 if !ok { 1611 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1612 } 1613 1614 input, ok := in.Parameters.(*UpdateFlowInput) 1615 _ = input 1616 if !ok { 1617 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1618 } 1619 1620 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}") 1621 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1622 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1623 request.Method = "PUT" 1624 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1625 if err != nil { 1626 return out, metadata, &smithy.SerializationError{Err: err} 1627 } 1628 1629 if err := awsRestjson1_serializeOpHttpBindingsUpdateFlowInput(input, restEncoder); err != nil { 1630 return out, metadata, &smithy.SerializationError{Err: err} 1631 } 1632 1633 restEncoder.SetHeader("Content-Type").String("application/json") 1634 1635 jsonEncoder := smithyjson.NewEncoder() 1636 if err := awsRestjson1_serializeOpDocumentUpdateFlowInput(input, jsonEncoder.Value); err != nil { 1637 return out, metadata, &smithy.SerializationError{Err: err} 1638 } 1639 1640 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1641 return out, metadata, &smithy.SerializationError{Err: err} 1642 } 1643 1644 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1645 return out, metadata, &smithy.SerializationError{Err: err} 1646 } 1647 in.Request = request 1648 1649 return next.HandleSerialize(ctx, in) 1650} 1651func awsRestjson1_serializeOpHttpBindingsUpdateFlowInput(v *UpdateFlowInput, encoder *httpbinding.Encoder) error { 1652 if v == nil { 1653 return fmt.Errorf("unsupported serialization of nil %T", v) 1654 } 1655 1656 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1657 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1658 } 1659 if v.FlowArn != nil { 1660 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1661 return err 1662 } 1663 } 1664 1665 return nil 1666} 1667 1668func awsRestjson1_serializeOpDocumentUpdateFlowInput(v *UpdateFlowInput, value smithyjson.Value) error { 1669 object := value.Object() 1670 defer object.Close() 1671 1672 if v.SourceFailoverConfig != nil { 1673 ok := object.Key("sourceFailoverConfig") 1674 if err := awsRestjson1_serializeDocumentUpdateFailoverConfig(v.SourceFailoverConfig, ok); err != nil { 1675 return err 1676 } 1677 } 1678 1679 return nil 1680} 1681 1682type awsRestjson1_serializeOpUpdateFlowEntitlement struct { 1683} 1684 1685func (*awsRestjson1_serializeOpUpdateFlowEntitlement) ID() string { 1686 return "OperationSerializer" 1687} 1688 1689func (m *awsRestjson1_serializeOpUpdateFlowEntitlement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1690 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1691) { 1692 request, ok := in.Request.(*smithyhttp.Request) 1693 if !ok { 1694 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1695 } 1696 1697 input, ok := in.Parameters.(*UpdateFlowEntitlementInput) 1698 _ = input 1699 if !ok { 1700 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1701 } 1702 1703 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/entitlements/{EntitlementArn}") 1704 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1705 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1706 request.Method = "PUT" 1707 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1708 if err != nil { 1709 return out, metadata, &smithy.SerializationError{Err: err} 1710 } 1711 1712 if err := awsRestjson1_serializeOpHttpBindingsUpdateFlowEntitlementInput(input, restEncoder); err != nil { 1713 return out, metadata, &smithy.SerializationError{Err: err} 1714 } 1715 1716 restEncoder.SetHeader("Content-Type").String("application/json") 1717 1718 jsonEncoder := smithyjson.NewEncoder() 1719 if err := awsRestjson1_serializeOpDocumentUpdateFlowEntitlementInput(input, jsonEncoder.Value); err != nil { 1720 return out, metadata, &smithy.SerializationError{Err: err} 1721 } 1722 1723 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1724 return out, metadata, &smithy.SerializationError{Err: err} 1725 } 1726 1727 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1728 return out, metadata, &smithy.SerializationError{Err: err} 1729 } 1730 in.Request = request 1731 1732 return next.HandleSerialize(ctx, in) 1733} 1734func awsRestjson1_serializeOpHttpBindingsUpdateFlowEntitlementInput(v *UpdateFlowEntitlementInput, encoder *httpbinding.Encoder) error { 1735 if v == nil { 1736 return fmt.Errorf("unsupported serialization of nil %T", v) 1737 } 1738 1739 if v.EntitlementArn == nil || len(*v.EntitlementArn) == 0 { 1740 return &smithy.SerializationError{Err: fmt.Errorf("input member EntitlementArn must not be empty")} 1741 } 1742 if v.EntitlementArn != nil { 1743 if err := encoder.SetURI("EntitlementArn").String(*v.EntitlementArn); err != nil { 1744 return err 1745 } 1746 } 1747 1748 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1749 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1750 } 1751 if v.FlowArn != nil { 1752 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1753 return err 1754 } 1755 } 1756 1757 return nil 1758} 1759 1760func awsRestjson1_serializeOpDocumentUpdateFlowEntitlementInput(v *UpdateFlowEntitlementInput, value smithyjson.Value) error { 1761 object := value.Object() 1762 defer object.Close() 1763 1764 if v.Description != nil { 1765 ok := object.Key("description") 1766 ok.String(*v.Description) 1767 } 1768 1769 if v.Encryption != nil { 1770 ok := object.Key("encryption") 1771 if err := awsRestjson1_serializeDocumentUpdateEncryption(v.Encryption, ok); err != nil { 1772 return err 1773 } 1774 } 1775 1776 if len(v.EntitlementStatus) > 0 { 1777 ok := object.Key("entitlementStatus") 1778 ok.String(string(v.EntitlementStatus)) 1779 } 1780 1781 if v.Subscribers != nil { 1782 ok := object.Key("subscribers") 1783 if err := awsRestjson1_serializeDocument__listOf__string(v.Subscribers, ok); err != nil { 1784 return err 1785 } 1786 } 1787 1788 return nil 1789} 1790 1791type awsRestjson1_serializeOpUpdateFlowOutput struct { 1792} 1793 1794func (*awsRestjson1_serializeOpUpdateFlowOutput) ID() string { 1795 return "OperationSerializer" 1796} 1797 1798func (m *awsRestjson1_serializeOpUpdateFlowOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1799 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1800) { 1801 request, ok := in.Request.(*smithyhttp.Request) 1802 if !ok { 1803 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1804 } 1805 1806 input, ok := in.Parameters.(*UpdateFlowOutputInput) 1807 _ = input 1808 if !ok { 1809 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1810 } 1811 1812 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/outputs/{OutputArn}") 1813 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1814 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1815 request.Method = "PUT" 1816 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1817 if err != nil { 1818 return out, metadata, &smithy.SerializationError{Err: err} 1819 } 1820 1821 if err := awsRestjson1_serializeOpHttpBindingsUpdateFlowOutputInput(input, restEncoder); err != nil { 1822 return out, metadata, &smithy.SerializationError{Err: err} 1823 } 1824 1825 restEncoder.SetHeader("Content-Type").String("application/json") 1826 1827 jsonEncoder := smithyjson.NewEncoder() 1828 if err := awsRestjson1_serializeOpDocumentUpdateFlowOutputInput(input, jsonEncoder.Value); err != nil { 1829 return out, metadata, &smithy.SerializationError{Err: err} 1830 } 1831 1832 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1833 return out, metadata, &smithy.SerializationError{Err: err} 1834 } 1835 1836 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1837 return out, metadata, &smithy.SerializationError{Err: err} 1838 } 1839 in.Request = request 1840 1841 return next.HandleSerialize(ctx, in) 1842} 1843func awsRestjson1_serializeOpHttpBindingsUpdateFlowOutputInput(v *UpdateFlowOutputInput, encoder *httpbinding.Encoder) error { 1844 if v == nil { 1845 return fmt.Errorf("unsupported serialization of nil %T", v) 1846 } 1847 1848 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 1849 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 1850 } 1851 if v.FlowArn != nil { 1852 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 1853 return err 1854 } 1855 } 1856 1857 if v.OutputArn == nil || len(*v.OutputArn) == 0 { 1858 return &smithy.SerializationError{Err: fmt.Errorf("input member OutputArn must not be empty")} 1859 } 1860 if v.OutputArn != nil { 1861 if err := encoder.SetURI("OutputArn").String(*v.OutputArn); err != nil { 1862 return err 1863 } 1864 } 1865 1866 return nil 1867} 1868 1869func awsRestjson1_serializeOpDocumentUpdateFlowOutputInput(v *UpdateFlowOutputInput, value smithyjson.Value) error { 1870 object := value.Object() 1871 defer object.Close() 1872 1873 if v.CidrAllowList != nil { 1874 ok := object.Key("cidrAllowList") 1875 if err := awsRestjson1_serializeDocument__listOf__string(v.CidrAllowList, ok); err != nil { 1876 return err 1877 } 1878 } 1879 1880 if v.Description != nil { 1881 ok := object.Key("description") 1882 ok.String(*v.Description) 1883 } 1884 1885 if v.Destination != nil { 1886 ok := object.Key("destination") 1887 ok.String(*v.Destination) 1888 } 1889 1890 if v.Encryption != nil { 1891 ok := object.Key("encryption") 1892 if err := awsRestjson1_serializeDocumentUpdateEncryption(v.Encryption, ok); err != nil { 1893 return err 1894 } 1895 } 1896 1897 if v.MaxLatency != 0 { 1898 ok := object.Key("maxLatency") 1899 ok.Integer(v.MaxLatency) 1900 } 1901 1902 if v.MinLatency != 0 { 1903 ok := object.Key("minLatency") 1904 ok.Integer(v.MinLatency) 1905 } 1906 1907 if v.Port != 0 { 1908 ok := object.Key("port") 1909 ok.Integer(v.Port) 1910 } 1911 1912 if len(v.Protocol) > 0 { 1913 ok := object.Key("protocol") 1914 ok.String(string(v.Protocol)) 1915 } 1916 1917 if v.RemoteId != nil { 1918 ok := object.Key("remoteId") 1919 ok.String(*v.RemoteId) 1920 } 1921 1922 if v.SmoothingLatency != 0 { 1923 ok := object.Key("smoothingLatency") 1924 ok.Integer(v.SmoothingLatency) 1925 } 1926 1927 if v.StreamId != nil { 1928 ok := object.Key("streamId") 1929 ok.String(*v.StreamId) 1930 } 1931 1932 if v.VpcInterfaceAttachment != nil { 1933 ok := object.Key("vpcInterfaceAttachment") 1934 if err := awsRestjson1_serializeDocumentVpcInterfaceAttachment(v.VpcInterfaceAttachment, ok); err != nil { 1935 return err 1936 } 1937 } 1938 1939 return nil 1940} 1941 1942type awsRestjson1_serializeOpUpdateFlowSource struct { 1943} 1944 1945func (*awsRestjson1_serializeOpUpdateFlowSource) ID() string { 1946 return "OperationSerializer" 1947} 1948 1949func (m *awsRestjson1_serializeOpUpdateFlowSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1950 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1951) { 1952 request, ok := in.Request.(*smithyhttp.Request) 1953 if !ok { 1954 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1955 } 1956 1957 input, ok := in.Parameters.(*UpdateFlowSourceInput) 1958 _ = input 1959 if !ok { 1960 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1961 } 1962 1963 opPath, opQuery := httpbinding.SplitURI("/v1/flows/{FlowArn}/source/{SourceArn}") 1964 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1965 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1966 request.Method = "PUT" 1967 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1968 if err != nil { 1969 return out, metadata, &smithy.SerializationError{Err: err} 1970 } 1971 1972 if err := awsRestjson1_serializeOpHttpBindingsUpdateFlowSourceInput(input, restEncoder); err != nil { 1973 return out, metadata, &smithy.SerializationError{Err: err} 1974 } 1975 1976 restEncoder.SetHeader("Content-Type").String("application/json") 1977 1978 jsonEncoder := smithyjson.NewEncoder() 1979 if err := awsRestjson1_serializeOpDocumentUpdateFlowSourceInput(input, jsonEncoder.Value); err != nil { 1980 return out, metadata, &smithy.SerializationError{Err: err} 1981 } 1982 1983 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1984 return out, metadata, &smithy.SerializationError{Err: err} 1985 } 1986 1987 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1988 return out, metadata, &smithy.SerializationError{Err: err} 1989 } 1990 in.Request = request 1991 1992 return next.HandleSerialize(ctx, in) 1993} 1994func awsRestjson1_serializeOpHttpBindingsUpdateFlowSourceInput(v *UpdateFlowSourceInput, encoder *httpbinding.Encoder) error { 1995 if v == nil { 1996 return fmt.Errorf("unsupported serialization of nil %T", v) 1997 } 1998 1999 if v.FlowArn == nil || len(*v.FlowArn) == 0 { 2000 return &smithy.SerializationError{Err: fmt.Errorf("input member FlowArn must not be empty")} 2001 } 2002 if v.FlowArn != nil { 2003 if err := encoder.SetURI("FlowArn").String(*v.FlowArn); err != nil { 2004 return err 2005 } 2006 } 2007 2008 if v.SourceArn == nil || len(*v.SourceArn) == 0 { 2009 return &smithy.SerializationError{Err: fmt.Errorf("input member SourceArn must not be empty")} 2010 } 2011 if v.SourceArn != nil { 2012 if err := encoder.SetURI("SourceArn").String(*v.SourceArn); err != nil { 2013 return err 2014 } 2015 } 2016 2017 return nil 2018} 2019 2020func awsRestjson1_serializeOpDocumentUpdateFlowSourceInput(v *UpdateFlowSourceInput, value smithyjson.Value) error { 2021 object := value.Object() 2022 defer object.Close() 2023 2024 if v.Decryption != nil { 2025 ok := object.Key("decryption") 2026 if err := awsRestjson1_serializeDocumentUpdateEncryption(v.Decryption, ok); err != nil { 2027 return err 2028 } 2029 } 2030 2031 if v.Description != nil { 2032 ok := object.Key("description") 2033 ok.String(*v.Description) 2034 } 2035 2036 if v.EntitlementArn != nil { 2037 ok := object.Key("entitlementArn") 2038 ok.String(*v.EntitlementArn) 2039 } 2040 2041 if v.IngestPort != 0 { 2042 ok := object.Key("ingestPort") 2043 ok.Integer(v.IngestPort) 2044 } 2045 2046 if v.MaxBitrate != 0 { 2047 ok := object.Key("maxBitrate") 2048 ok.Integer(v.MaxBitrate) 2049 } 2050 2051 if v.MaxLatency != 0 { 2052 ok := object.Key("maxLatency") 2053 ok.Integer(v.MaxLatency) 2054 } 2055 2056 if v.MinLatency != 0 { 2057 ok := object.Key("minLatency") 2058 ok.Integer(v.MinLatency) 2059 } 2060 2061 if len(v.Protocol) > 0 { 2062 ok := object.Key("protocol") 2063 ok.String(string(v.Protocol)) 2064 } 2065 2066 if v.StreamId != nil { 2067 ok := object.Key("streamId") 2068 ok.String(*v.StreamId) 2069 } 2070 2071 if v.VpcInterfaceName != nil { 2072 ok := object.Key("vpcInterfaceName") 2073 ok.String(*v.VpcInterfaceName) 2074 } 2075 2076 if v.WhitelistCidr != nil { 2077 ok := object.Key("whitelistCidr") 2078 ok.String(*v.WhitelistCidr) 2079 } 2080 2081 return nil 2082} 2083 2084func awsRestjson1_serializeDocument__listOf__string(v []string, value smithyjson.Value) error { 2085 array := value.Array() 2086 defer array.Close() 2087 2088 for i := range v { 2089 av := array.Value() 2090 av.String(v[i]) 2091 } 2092 return nil 2093} 2094 2095func awsRestjson1_serializeDocument__listOfAddOutputRequest(v []types.AddOutputRequest, value smithyjson.Value) error { 2096 array := value.Array() 2097 defer array.Close() 2098 2099 for i := range v { 2100 av := array.Value() 2101 if err := awsRestjson1_serializeDocumentAddOutputRequest(&v[i], av); err != nil { 2102 return err 2103 } 2104 } 2105 return nil 2106} 2107 2108func awsRestjson1_serializeDocument__listOfGrantEntitlementRequest(v []types.GrantEntitlementRequest, value smithyjson.Value) error { 2109 array := value.Array() 2110 defer array.Close() 2111 2112 for i := range v { 2113 av := array.Value() 2114 if err := awsRestjson1_serializeDocumentGrantEntitlementRequest(&v[i], av); err != nil { 2115 return err 2116 } 2117 } 2118 return nil 2119} 2120 2121func awsRestjson1_serializeDocument__listOfSetSourceRequest(v []types.SetSourceRequest, value smithyjson.Value) error { 2122 array := value.Array() 2123 defer array.Close() 2124 2125 for i := range v { 2126 av := array.Value() 2127 if err := awsRestjson1_serializeDocumentSetSourceRequest(&v[i], av); err != nil { 2128 return err 2129 } 2130 } 2131 return nil 2132} 2133 2134func awsRestjson1_serializeDocument__listOfVpcInterfaceRequest(v []types.VpcInterfaceRequest, value smithyjson.Value) error { 2135 array := value.Array() 2136 defer array.Close() 2137 2138 for i := range v { 2139 av := array.Value() 2140 if err := awsRestjson1_serializeDocumentVpcInterfaceRequest(&v[i], av); err != nil { 2141 return err 2142 } 2143 } 2144 return nil 2145} 2146 2147func awsRestjson1_serializeDocument__mapOf__string(v map[string]string, value smithyjson.Value) error { 2148 object := value.Object() 2149 defer object.Close() 2150 2151 for key := range v { 2152 om := object.Key(key) 2153 om.String(v[key]) 2154 } 2155 return nil 2156} 2157 2158func awsRestjson1_serializeDocumentAddOutputRequest(v *types.AddOutputRequest, value smithyjson.Value) error { 2159 object := value.Object() 2160 defer object.Close() 2161 2162 if v.CidrAllowList != nil { 2163 ok := object.Key("cidrAllowList") 2164 if err := awsRestjson1_serializeDocument__listOf__string(v.CidrAllowList, ok); err != nil { 2165 return err 2166 } 2167 } 2168 2169 if v.Description != nil { 2170 ok := object.Key("description") 2171 ok.String(*v.Description) 2172 } 2173 2174 if v.Destination != nil { 2175 ok := object.Key("destination") 2176 ok.String(*v.Destination) 2177 } 2178 2179 if v.Encryption != nil { 2180 ok := object.Key("encryption") 2181 if err := awsRestjson1_serializeDocumentEncryption(v.Encryption, ok); err != nil { 2182 return err 2183 } 2184 } 2185 2186 if v.MaxLatency != 0 { 2187 ok := object.Key("maxLatency") 2188 ok.Integer(v.MaxLatency) 2189 } 2190 2191 if v.MinLatency != 0 { 2192 ok := object.Key("minLatency") 2193 ok.Integer(v.MinLatency) 2194 } 2195 2196 if v.Name != nil { 2197 ok := object.Key("name") 2198 ok.String(*v.Name) 2199 } 2200 2201 if v.Port != 0 { 2202 ok := object.Key("port") 2203 ok.Integer(v.Port) 2204 } 2205 2206 if len(v.Protocol) > 0 { 2207 ok := object.Key("protocol") 2208 ok.String(string(v.Protocol)) 2209 } 2210 2211 if v.RemoteId != nil { 2212 ok := object.Key("remoteId") 2213 ok.String(*v.RemoteId) 2214 } 2215 2216 if v.SmoothingLatency != 0 { 2217 ok := object.Key("smoothingLatency") 2218 ok.Integer(v.SmoothingLatency) 2219 } 2220 2221 if v.StreamId != nil { 2222 ok := object.Key("streamId") 2223 ok.String(*v.StreamId) 2224 } 2225 2226 if v.VpcInterfaceAttachment != nil { 2227 ok := object.Key("vpcInterfaceAttachment") 2228 if err := awsRestjson1_serializeDocumentVpcInterfaceAttachment(v.VpcInterfaceAttachment, ok); err != nil { 2229 return err 2230 } 2231 } 2232 2233 return nil 2234} 2235 2236func awsRestjson1_serializeDocumentEncryption(v *types.Encryption, value smithyjson.Value) error { 2237 object := value.Object() 2238 defer object.Close() 2239 2240 if len(v.Algorithm) > 0 { 2241 ok := object.Key("algorithm") 2242 ok.String(string(v.Algorithm)) 2243 } 2244 2245 if v.ConstantInitializationVector != nil { 2246 ok := object.Key("constantInitializationVector") 2247 ok.String(*v.ConstantInitializationVector) 2248 } 2249 2250 if v.DeviceId != nil { 2251 ok := object.Key("deviceId") 2252 ok.String(*v.DeviceId) 2253 } 2254 2255 if len(v.KeyType) > 0 { 2256 ok := object.Key("keyType") 2257 ok.String(string(v.KeyType)) 2258 } 2259 2260 if v.Region != nil { 2261 ok := object.Key("region") 2262 ok.String(*v.Region) 2263 } 2264 2265 if v.ResourceId != nil { 2266 ok := object.Key("resourceId") 2267 ok.String(*v.ResourceId) 2268 } 2269 2270 if v.RoleArn != nil { 2271 ok := object.Key("roleArn") 2272 ok.String(*v.RoleArn) 2273 } 2274 2275 if v.SecretArn != nil { 2276 ok := object.Key("secretArn") 2277 ok.String(*v.SecretArn) 2278 } 2279 2280 if v.Url != nil { 2281 ok := object.Key("url") 2282 ok.String(*v.Url) 2283 } 2284 2285 return nil 2286} 2287 2288func awsRestjson1_serializeDocumentFailoverConfig(v *types.FailoverConfig, value smithyjson.Value) error { 2289 object := value.Object() 2290 defer object.Close() 2291 2292 if v.RecoveryWindow != 0 { 2293 ok := object.Key("recoveryWindow") 2294 ok.Integer(v.RecoveryWindow) 2295 } 2296 2297 if len(v.State) > 0 { 2298 ok := object.Key("state") 2299 ok.String(string(v.State)) 2300 } 2301 2302 return nil 2303} 2304 2305func awsRestjson1_serializeDocumentGrantEntitlementRequest(v *types.GrantEntitlementRequest, value smithyjson.Value) error { 2306 object := value.Object() 2307 defer object.Close() 2308 2309 if v.DataTransferSubscriberFeePercent != 0 { 2310 ok := object.Key("dataTransferSubscriberFeePercent") 2311 ok.Integer(v.DataTransferSubscriberFeePercent) 2312 } 2313 2314 if v.Description != nil { 2315 ok := object.Key("description") 2316 ok.String(*v.Description) 2317 } 2318 2319 if v.Encryption != nil { 2320 ok := object.Key("encryption") 2321 if err := awsRestjson1_serializeDocumentEncryption(v.Encryption, ok); err != nil { 2322 return err 2323 } 2324 } 2325 2326 if len(v.EntitlementStatus) > 0 { 2327 ok := object.Key("entitlementStatus") 2328 ok.String(string(v.EntitlementStatus)) 2329 } 2330 2331 if v.Name != nil { 2332 ok := object.Key("name") 2333 ok.String(*v.Name) 2334 } 2335 2336 if v.Subscribers != nil { 2337 ok := object.Key("subscribers") 2338 if err := awsRestjson1_serializeDocument__listOf__string(v.Subscribers, ok); err != nil { 2339 return err 2340 } 2341 } 2342 2343 return nil 2344} 2345 2346func awsRestjson1_serializeDocumentSetSourceRequest(v *types.SetSourceRequest, value smithyjson.Value) error { 2347 object := value.Object() 2348 defer object.Close() 2349 2350 if v.Decryption != nil { 2351 ok := object.Key("decryption") 2352 if err := awsRestjson1_serializeDocumentEncryption(v.Decryption, ok); err != nil { 2353 return err 2354 } 2355 } 2356 2357 if v.Description != nil { 2358 ok := object.Key("description") 2359 ok.String(*v.Description) 2360 } 2361 2362 if v.EntitlementArn != nil { 2363 ok := object.Key("entitlementArn") 2364 ok.String(*v.EntitlementArn) 2365 } 2366 2367 if v.IngestPort != 0 { 2368 ok := object.Key("ingestPort") 2369 ok.Integer(v.IngestPort) 2370 } 2371 2372 if v.MaxBitrate != 0 { 2373 ok := object.Key("maxBitrate") 2374 ok.Integer(v.MaxBitrate) 2375 } 2376 2377 if v.MaxLatency != 0 { 2378 ok := object.Key("maxLatency") 2379 ok.Integer(v.MaxLatency) 2380 } 2381 2382 if v.MinLatency != 0 { 2383 ok := object.Key("minLatency") 2384 ok.Integer(v.MinLatency) 2385 } 2386 2387 if v.Name != nil { 2388 ok := object.Key("name") 2389 ok.String(*v.Name) 2390 } 2391 2392 if len(v.Protocol) > 0 { 2393 ok := object.Key("protocol") 2394 ok.String(string(v.Protocol)) 2395 } 2396 2397 if v.StreamId != nil { 2398 ok := object.Key("streamId") 2399 ok.String(*v.StreamId) 2400 } 2401 2402 if v.VpcInterfaceName != nil { 2403 ok := object.Key("vpcInterfaceName") 2404 ok.String(*v.VpcInterfaceName) 2405 } 2406 2407 if v.WhitelistCidr != nil { 2408 ok := object.Key("whitelistCidr") 2409 ok.String(*v.WhitelistCidr) 2410 } 2411 2412 return nil 2413} 2414 2415func awsRestjson1_serializeDocumentUpdateEncryption(v *types.UpdateEncryption, value smithyjson.Value) error { 2416 object := value.Object() 2417 defer object.Close() 2418 2419 if len(v.Algorithm) > 0 { 2420 ok := object.Key("algorithm") 2421 ok.String(string(v.Algorithm)) 2422 } 2423 2424 if v.ConstantInitializationVector != nil { 2425 ok := object.Key("constantInitializationVector") 2426 ok.String(*v.ConstantInitializationVector) 2427 } 2428 2429 if v.DeviceId != nil { 2430 ok := object.Key("deviceId") 2431 ok.String(*v.DeviceId) 2432 } 2433 2434 if len(v.KeyType) > 0 { 2435 ok := object.Key("keyType") 2436 ok.String(string(v.KeyType)) 2437 } 2438 2439 if v.Region != nil { 2440 ok := object.Key("region") 2441 ok.String(*v.Region) 2442 } 2443 2444 if v.ResourceId != nil { 2445 ok := object.Key("resourceId") 2446 ok.String(*v.ResourceId) 2447 } 2448 2449 if v.RoleArn != nil { 2450 ok := object.Key("roleArn") 2451 ok.String(*v.RoleArn) 2452 } 2453 2454 if v.SecretArn != nil { 2455 ok := object.Key("secretArn") 2456 ok.String(*v.SecretArn) 2457 } 2458 2459 if v.Url != nil { 2460 ok := object.Key("url") 2461 ok.String(*v.Url) 2462 } 2463 2464 return nil 2465} 2466 2467func awsRestjson1_serializeDocumentUpdateFailoverConfig(v *types.UpdateFailoverConfig, value smithyjson.Value) error { 2468 object := value.Object() 2469 defer object.Close() 2470 2471 if v.RecoveryWindow != 0 { 2472 ok := object.Key("recoveryWindow") 2473 ok.Integer(v.RecoveryWindow) 2474 } 2475 2476 if len(v.State) > 0 { 2477 ok := object.Key("state") 2478 ok.String(string(v.State)) 2479 } 2480 2481 return nil 2482} 2483 2484func awsRestjson1_serializeDocumentVpcInterfaceAttachment(v *types.VpcInterfaceAttachment, value smithyjson.Value) error { 2485 object := value.Object() 2486 defer object.Close() 2487 2488 if v.VpcInterfaceName != nil { 2489 ok := object.Key("vpcInterfaceName") 2490 ok.String(*v.VpcInterfaceName) 2491 } 2492 2493 return nil 2494} 2495 2496func awsRestjson1_serializeDocumentVpcInterfaceRequest(v *types.VpcInterfaceRequest, value smithyjson.Value) error { 2497 object := value.Object() 2498 defer object.Close() 2499 2500 if v.Name != nil { 2501 ok := object.Key("name") 2502 ok.String(*v.Name) 2503 } 2504 2505 if v.RoleArn != nil { 2506 ok := object.Key("roleArn") 2507 ok.String(*v.RoleArn) 2508 } 2509 2510 if v.SecurityGroupIds != nil { 2511 ok := object.Key("securityGroupIds") 2512 if err := awsRestjson1_serializeDocument__listOf__string(v.SecurityGroupIds, ok); err != nil { 2513 return err 2514 } 2515 } 2516 2517 if v.SubnetId != nil { 2518 ok := object.Key("subnetId") 2519 ok.String(*v.SubnetId) 2520 } 2521 2522 return nil 2523} 2524