1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package appflow 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/appflow/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 smithytime "github.com/aws/smithy-go/time" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16) 17 18type awsRestjson1_serializeOpCreateConnectorProfile struct { 19} 20 21func (*awsRestjson1_serializeOpCreateConnectorProfile) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpCreateConnectorProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27) { 28 request, ok := in.Request.(*smithyhttp.Request) 29 if !ok { 30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 31 } 32 33 input, ok := in.Parameters.(*CreateConnectorProfileInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 opPath, opQuery := httpbinding.SplitURI("/create-connector-profile") 40 request.URL.Path = opPath 41 if len(request.URL.RawQuery) > 0 { 42 request.URL.RawQuery = "&" + opQuery 43 } else { 44 request.URL.RawQuery = opQuery 45 } 46 47 request.Method = "POST" 48 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 49 if err != nil { 50 return out, metadata, &smithy.SerializationError{Err: err} 51 } 52 53 restEncoder.SetHeader("Content-Type").String("application/json") 54 55 jsonEncoder := smithyjson.NewEncoder() 56 if err := awsRestjson1_serializeOpDocumentCreateConnectorProfileInput(input, jsonEncoder.Value); err != nil { 57 return out, metadata, &smithy.SerializationError{Err: err} 58 } 59 60 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 61 return out, metadata, &smithy.SerializationError{Err: err} 62 } 63 64 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 65 return out, metadata, &smithy.SerializationError{Err: err} 66 } 67 in.Request = request 68 69 return next.HandleSerialize(ctx, in) 70} 71func awsRestjson1_serializeOpHttpBindingsCreateConnectorProfileInput(v *CreateConnectorProfileInput, encoder *httpbinding.Encoder) error { 72 if v == nil { 73 return fmt.Errorf("unsupported serialization of nil %T", v) 74 } 75 76 return nil 77} 78 79func awsRestjson1_serializeOpDocumentCreateConnectorProfileInput(v *CreateConnectorProfileInput, value smithyjson.Value) error { 80 object := value.Object() 81 defer object.Close() 82 83 if len(v.ConnectionMode) > 0 { 84 ok := object.Key("connectionMode") 85 ok.String(string(v.ConnectionMode)) 86 } 87 88 if v.ConnectorProfileConfig != nil { 89 ok := object.Key("connectorProfileConfig") 90 if err := awsRestjson1_serializeDocumentConnectorProfileConfig(v.ConnectorProfileConfig, ok); err != nil { 91 return err 92 } 93 } 94 95 if v.ConnectorProfileName != nil { 96 ok := object.Key("connectorProfileName") 97 ok.String(*v.ConnectorProfileName) 98 } 99 100 if len(v.ConnectorType) > 0 { 101 ok := object.Key("connectorType") 102 ok.String(string(v.ConnectorType)) 103 } 104 105 if v.KmsArn != nil { 106 ok := object.Key("kmsArn") 107 ok.String(*v.KmsArn) 108 } 109 110 return nil 111} 112 113type awsRestjson1_serializeOpCreateFlow struct { 114} 115 116func (*awsRestjson1_serializeOpCreateFlow) ID() string { 117 return "OperationSerializer" 118} 119 120func (m *awsRestjson1_serializeOpCreateFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 121 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 122) { 123 request, ok := in.Request.(*smithyhttp.Request) 124 if !ok { 125 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 126 } 127 128 input, ok := in.Parameters.(*CreateFlowInput) 129 _ = input 130 if !ok { 131 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 132 } 133 134 opPath, opQuery := httpbinding.SplitURI("/create-flow") 135 request.URL.Path = opPath 136 if len(request.URL.RawQuery) > 0 { 137 request.URL.RawQuery = "&" + opQuery 138 } else { 139 request.URL.RawQuery = opQuery 140 } 141 142 request.Method = "POST" 143 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 144 if err != nil { 145 return out, metadata, &smithy.SerializationError{Err: err} 146 } 147 148 restEncoder.SetHeader("Content-Type").String("application/json") 149 150 jsonEncoder := smithyjson.NewEncoder() 151 if err := awsRestjson1_serializeOpDocumentCreateFlowInput(input, jsonEncoder.Value); err != nil { 152 return out, metadata, &smithy.SerializationError{Err: err} 153 } 154 155 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 156 return out, metadata, &smithy.SerializationError{Err: err} 157 } 158 159 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 160 return out, metadata, &smithy.SerializationError{Err: err} 161 } 162 in.Request = request 163 164 return next.HandleSerialize(ctx, in) 165} 166func awsRestjson1_serializeOpHttpBindingsCreateFlowInput(v *CreateFlowInput, encoder *httpbinding.Encoder) error { 167 if v == nil { 168 return fmt.Errorf("unsupported serialization of nil %T", v) 169 } 170 171 return nil 172} 173 174func awsRestjson1_serializeOpDocumentCreateFlowInput(v *CreateFlowInput, value smithyjson.Value) error { 175 object := value.Object() 176 defer object.Close() 177 178 if v.Description != nil { 179 ok := object.Key("description") 180 ok.String(*v.Description) 181 } 182 183 if v.DestinationFlowConfigList != nil { 184 ok := object.Key("destinationFlowConfigList") 185 if err := awsRestjson1_serializeDocumentDestinationFlowConfigList(v.DestinationFlowConfigList, ok); err != nil { 186 return err 187 } 188 } 189 190 if v.FlowName != nil { 191 ok := object.Key("flowName") 192 ok.String(*v.FlowName) 193 } 194 195 if v.KmsArn != nil { 196 ok := object.Key("kmsArn") 197 ok.String(*v.KmsArn) 198 } 199 200 if v.SourceFlowConfig != nil { 201 ok := object.Key("sourceFlowConfig") 202 if err := awsRestjson1_serializeDocumentSourceFlowConfig(v.SourceFlowConfig, ok); err != nil { 203 return err 204 } 205 } 206 207 if v.Tags != nil { 208 ok := object.Key("tags") 209 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 210 return err 211 } 212 } 213 214 if v.Tasks != nil { 215 ok := object.Key("tasks") 216 if err := awsRestjson1_serializeDocumentTasks(v.Tasks, ok); err != nil { 217 return err 218 } 219 } 220 221 if v.TriggerConfig != nil { 222 ok := object.Key("triggerConfig") 223 if err := awsRestjson1_serializeDocumentTriggerConfig(v.TriggerConfig, ok); err != nil { 224 return err 225 } 226 } 227 228 return nil 229} 230 231type awsRestjson1_serializeOpDeleteConnectorProfile struct { 232} 233 234func (*awsRestjson1_serializeOpDeleteConnectorProfile) ID() string { 235 return "OperationSerializer" 236} 237 238func (m *awsRestjson1_serializeOpDeleteConnectorProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 239 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 240) { 241 request, ok := in.Request.(*smithyhttp.Request) 242 if !ok { 243 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 244 } 245 246 input, ok := in.Parameters.(*DeleteConnectorProfileInput) 247 _ = input 248 if !ok { 249 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 250 } 251 252 opPath, opQuery := httpbinding.SplitURI("/delete-connector-profile") 253 request.URL.Path = opPath 254 if len(request.URL.RawQuery) > 0 { 255 request.URL.RawQuery = "&" + opQuery 256 } else { 257 request.URL.RawQuery = opQuery 258 } 259 260 request.Method = "POST" 261 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 262 if err != nil { 263 return out, metadata, &smithy.SerializationError{Err: err} 264 } 265 266 restEncoder.SetHeader("Content-Type").String("application/json") 267 268 jsonEncoder := smithyjson.NewEncoder() 269 if err := awsRestjson1_serializeOpDocumentDeleteConnectorProfileInput(input, jsonEncoder.Value); err != nil { 270 return out, metadata, &smithy.SerializationError{Err: err} 271 } 272 273 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 274 return out, metadata, &smithy.SerializationError{Err: err} 275 } 276 277 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 278 return out, metadata, &smithy.SerializationError{Err: err} 279 } 280 in.Request = request 281 282 return next.HandleSerialize(ctx, in) 283} 284func awsRestjson1_serializeOpHttpBindingsDeleteConnectorProfileInput(v *DeleteConnectorProfileInput, encoder *httpbinding.Encoder) error { 285 if v == nil { 286 return fmt.Errorf("unsupported serialization of nil %T", v) 287 } 288 289 return nil 290} 291 292func awsRestjson1_serializeOpDocumentDeleteConnectorProfileInput(v *DeleteConnectorProfileInput, value smithyjson.Value) error { 293 object := value.Object() 294 defer object.Close() 295 296 if v.ConnectorProfileName != nil { 297 ok := object.Key("connectorProfileName") 298 ok.String(*v.ConnectorProfileName) 299 } 300 301 if v.ForceDelete { 302 ok := object.Key("forceDelete") 303 ok.Boolean(v.ForceDelete) 304 } 305 306 return nil 307} 308 309type awsRestjson1_serializeOpDeleteFlow struct { 310} 311 312func (*awsRestjson1_serializeOpDeleteFlow) ID() string { 313 return "OperationSerializer" 314} 315 316func (m *awsRestjson1_serializeOpDeleteFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 317 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 318) { 319 request, ok := in.Request.(*smithyhttp.Request) 320 if !ok { 321 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 322 } 323 324 input, ok := in.Parameters.(*DeleteFlowInput) 325 _ = input 326 if !ok { 327 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 328 } 329 330 opPath, opQuery := httpbinding.SplitURI("/delete-flow") 331 request.URL.Path = opPath 332 if len(request.URL.RawQuery) > 0 { 333 request.URL.RawQuery = "&" + opQuery 334 } else { 335 request.URL.RawQuery = opQuery 336 } 337 338 request.Method = "POST" 339 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 340 if err != nil { 341 return out, metadata, &smithy.SerializationError{Err: err} 342 } 343 344 restEncoder.SetHeader("Content-Type").String("application/json") 345 346 jsonEncoder := smithyjson.NewEncoder() 347 if err := awsRestjson1_serializeOpDocumentDeleteFlowInput(input, jsonEncoder.Value); err != nil { 348 return out, metadata, &smithy.SerializationError{Err: err} 349 } 350 351 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 352 return out, metadata, &smithy.SerializationError{Err: err} 353 } 354 355 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 356 return out, metadata, &smithy.SerializationError{Err: err} 357 } 358 in.Request = request 359 360 return next.HandleSerialize(ctx, in) 361} 362func awsRestjson1_serializeOpHttpBindingsDeleteFlowInput(v *DeleteFlowInput, encoder *httpbinding.Encoder) error { 363 if v == nil { 364 return fmt.Errorf("unsupported serialization of nil %T", v) 365 } 366 367 return nil 368} 369 370func awsRestjson1_serializeOpDocumentDeleteFlowInput(v *DeleteFlowInput, value smithyjson.Value) error { 371 object := value.Object() 372 defer object.Close() 373 374 if v.FlowName != nil { 375 ok := object.Key("flowName") 376 ok.String(*v.FlowName) 377 } 378 379 if v.ForceDelete { 380 ok := object.Key("forceDelete") 381 ok.Boolean(v.ForceDelete) 382 } 383 384 return nil 385} 386 387type awsRestjson1_serializeOpDescribeConnectorEntity struct { 388} 389 390func (*awsRestjson1_serializeOpDescribeConnectorEntity) ID() string { 391 return "OperationSerializer" 392} 393 394func (m *awsRestjson1_serializeOpDescribeConnectorEntity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 395 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 396) { 397 request, ok := in.Request.(*smithyhttp.Request) 398 if !ok { 399 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 400 } 401 402 input, ok := in.Parameters.(*DescribeConnectorEntityInput) 403 _ = input 404 if !ok { 405 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 406 } 407 408 opPath, opQuery := httpbinding.SplitURI("/describe-connector-entity") 409 request.URL.Path = opPath 410 if len(request.URL.RawQuery) > 0 { 411 request.URL.RawQuery = "&" + opQuery 412 } else { 413 request.URL.RawQuery = opQuery 414 } 415 416 request.Method = "POST" 417 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 418 if err != nil { 419 return out, metadata, &smithy.SerializationError{Err: err} 420 } 421 422 restEncoder.SetHeader("Content-Type").String("application/json") 423 424 jsonEncoder := smithyjson.NewEncoder() 425 if err := awsRestjson1_serializeOpDocumentDescribeConnectorEntityInput(input, jsonEncoder.Value); err != nil { 426 return out, metadata, &smithy.SerializationError{Err: err} 427 } 428 429 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 430 return out, metadata, &smithy.SerializationError{Err: err} 431 } 432 433 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 434 return out, metadata, &smithy.SerializationError{Err: err} 435 } 436 in.Request = request 437 438 return next.HandleSerialize(ctx, in) 439} 440func awsRestjson1_serializeOpHttpBindingsDescribeConnectorEntityInput(v *DescribeConnectorEntityInput, encoder *httpbinding.Encoder) error { 441 if v == nil { 442 return fmt.Errorf("unsupported serialization of nil %T", v) 443 } 444 445 return nil 446} 447 448func awsRestjson1_serializeOpDocumentDescribeConnectorEntityInput(v *DescribeConnectorEntityInput, value smithyjson.Value) error { 449 object := value.Object() 450 defer object.Close() 451 452 if v.ConnectorEntityName != nil { 453 ok := object.Key("connectorEntityName") 454 ok.String(*v.ConnectorEntityName) 455 } 456 457 if v.ConnectorProfileName != nil { 458 ok := object.Key("connectorProfileName") 459 ok.String(*v.ConnectorProfileName) 460 } 461 462 if len(v.ConnectorType) > 0 { 463 ok := object.Key("connectorType") 464 ok.String(string(v.ConnectorType)) 465 } 466 467 return nil 468} 469 470type awsRestjson1_serializeOpDescribeConnectorProfiles struct { 471} 472 473func (*awsRestjson1_serializeOpDescribeConnectorProfiles) ID() string { 474 return "OperationSerializer" 475} 476 477func (m *awsRestjson1_serializeOpDescribeConnectorProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 478 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 479) { 480 request, ok := in.Request.(*smithyhttp.Request) 481 if !ok { 482 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 483 } 484 485 input, ok := in.Parameters.(*DescribeConnectorProfilesInput) 486 _ = input 487 if !ok { 488 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 489 } 490 491 opPath, opQuery := httpbinding.SplitURI("/describe-connector-profiles") 492 request.URL.Path = opPath 493 if len(request.URL.RawQuery) > 0 { 494 request.URL.RawQuery = "&" + opQuery 495 } else { 496 request.URL.RawQuery = opQuery 497 } 498 499 request.Method = "POST" 500 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 501 if err != nil { 502 return out, metadata, &smithy.SerializationError{Err: err} 503 } 504 505 restEncoder.SetHeader("Content-Type").String("application/json") 506 507 jsonEncoder := smithyjson.NewEncoder() 508 if err := awsRestjson1_serializeOpDocumentDescribeConnectorProfilesInput(input, jsonEncoder.Value); err != nil { 509 return out, metadata, &smithy.SerializationError{Err: err} 510 } 511 512 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 513 return out, metadata, &smithy.SerializationError{Err: err} 514 } 515 516 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 517 return out, metadata, &smithy.SerializationError{Err: err} 518 } 519 in.Request = request 520 521 return next.HandleSerialize(ctx, in) 522} 523func awsRestjson1_serializeOpHttpBindingsDescribeConnectorProfilesInput(v *DescribeConnectorProfilesInput, encoder *httpbinding.Encoder) error { 524 if v == nil { 525 return fmt.Errorf("unsupported serialization of nil %T", v) 526 } 527 528 return nil 529} 530 531func awsRestjson1_serializeOpDocumentDescribeConnectorProfilesInput(v *DescribeConnectorProfilesInput, value smithyjson.Value) error { 532 object := value.Object() 533 defer object.Close() 534 535 if v.ConnectorProfileNames != nil { 536 ok := object.Key("connectorProfileNames") 537 if err := awsRestjson1_serializeDocumentConnectorProfileNameList(v.ConnectorProfileNames, ok); err != nil { 538 return err 539 } 540 } 541 542 if len(v.ConnectorType) > 0 { 543 ok := object.Key("connectorType") 544 ok.String(string(v.ConnectorType)) 545 } 546 547 if v.MaxResults != nil { 548 ok := object.Key("maxResults") 549 ok.Integer(*v.MaxResults) 550 } 551 552 if v.NextToken != nil { 553 ok := object.Key("nextToken") 554 ok.String(*v.NextToken) 555 } 556 557 return nil 558} 559 560type awsRestjson1_serializeOpDescribeConnectors struct { 561} 562 563func (*awsRestjson1_serializeOpDescribeConnectors) ID() string { 564 return "OperationSerializer" 565} 566 567func (m *awsRestjson1_serializeOpDescribeConnectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 568 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 569) { 570 request, ok := in.Request.(*smithyhttp.Request) 571 if !ok { 572 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 573 } 574 575 input, ok := in.Parameters.(*DescribeConnectorsInput) 576 _ = input 577 if !ok { 578 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 579 } 580 581 opPath, opQuery := httpbinding.SplitURI("/describe-connectors") 582 request.URL.Path = opPath 583 if len(request.URL.RawQuery) > 0 { 584 request.URL.RawQuery = "&" + opQuery 585 } else { 586 request.URL.RawQuery = opQuery 587 } 588 589 request.Method = "POST" 590 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 591 if err != nil { 592 return out, metadata, &smithy.SerializationError{Err: err} 593 } 594 595 restEncoder.SetHeader("Content-Type").String("application/json") 596 597 jsonEncoder := smithyjson.NewEncoder() 598 if err := awsRestjson1_serializeOpDocumentDescribeConnectorsInput(input, jsonEncoder.Value); err != nil { 599 return out, metadata, &smithy.SerializationError{Err: err} 600 } 601 602 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 603 return out, metadata, &smithy.SerializationError{Err: err} 604 } 605 606 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 607 return out, metadata, &smithy.SerializationError{Err: err} 608 } 609 in.Request = request 610 611 return next.HandleSerialize(ctx, in) 612} 613func awsRestjson1_serializeOpHttpBindingsDescribeConnectorsInput(v *DescribeConnectorsInput, encoder *httpbinding.Encoder) error { 614 if v == nil { 615 return fmt.Errorf("unsupported serialization of nil %T", v) 616 } 617 618 return nil 619} 620 621func awsRestjson1_serializeOpDocumentDescribeConnectorsInput(v *DescribeConnectorsInput, value smithyjson.Value) error { 622 object := value.Object() 623 defer object.Close() 624 625 if v.ConnectorTypes != nil { 626 ok := object.Key("connectorTypes") 627 if err := awsRestjson1_serializeDocumentConnectorTypeList(v.ConnectorTypes, ok); err != nil { 628 return err 629 } 630 } 631 632 if v.NextToken != nil { 633 ok := object.Key("nextToken") 634 ok.String(*v.NextToken) 635 } 636 637 return nil 638} 639 640type awsRestjson1_serializeOpDescribeFlow struct { 641} 642 643func (*awsRestjson1_serializeOpDescribeFlow) ID() string { 644 return "OperationSerializer" 645} 646 647func (m *awsRestjson1_serializeOpDescribeFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 648 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 649) { 650 request, ok := in.Request.(*smithyhttp.Request) 651 if !ok { 652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 653 } 654 655 input, ok := in.Parameters.(*DescribeFlowInput) 656 _ = input 657 if !ok { 658 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 659 } 660 661 opPath, opQuery := httpbinding.SplitURI("/describe-flow") 662 request.URL.Path = opPath 663 if len(request.URL.RawQuery) > 0 { 664 request.URL.RawQuery = "&" + opQuery 665 } else { 666 request.URL.RawQuery = opQuery 667 } 668 669 request.Method = "POST" 670 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 671 if err != nil { 672 return out, metadata, &smithy.SerializationError{Err: err} 673 } 674 675 restEncoder.SetHeader("Content-Type").String("application/json") 676 677 jsonEncoder := smithyjson.NewEncoder() 678 if err := awsRestjson1_serializeOpDocumentDescribeFlowInput(input, jsonEncoder.Value); err != nil { 679 return out, metadata, &smithy.SerializationError{Err: err} 680 } 681 682 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 683 return out, metadata, &smithy.SerializationError{Err: err} 684 } 685 686 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 687 return out, metadata, &smithy.SerializationError{Err: err} 688 } 689 in.Request = request 690 691 return next.HandleSerialize(ctx, in) 692} 693func awsRestjson1_serializeOpHttpBindingsDescribeFlowInput(v *DescribeFlowInput, encoder *httpbinding.Encoder) error { 694 if v == nil { 695 return fmt.Errorf("unsupported serialization of nil %T", v) 696 } 697 698 return nil 699} 700 701func awsRestjson1_serializeOpDocumentDescribeFlowInput(v *DescribeFlowInput, value smithyjson.Value) error { 702 object := value.Object() 703 defer object.Close() 704 705 if v.FlowName != nil { 706 ok := object.Key("flowName") 707 ok.String(*v.FlowName) 708 } 709 710 return nil 711} 712 713type awsRestjson1_serializeOpDescribeFlowExecutionRecords struct { 714} 715 716func (*awsRestjson1_serializeOpDescribeFlowExecutionRecords) ID() string { 717 return "OperationSerializer" 718} 719 720func (m *awsRestjson1_serializeOpDescribeFlowExecutionRecords) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 721 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 722) { 723 request, ok := in.Request.(*smithyhttp.Request) 724 if !ok { 725 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 726 } 727 728 input, ok := in.Parameters.(*DescribeFlowExecutionRecordsInput) 729 _ = input 730 if !ok { 731 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 732 } 733 734 opPath, opQuery := httpbinding.SplitURI("/describe-flow-execution-records") 735 request.URL.Path = opPath 736 if len(request.URL.RawQuery) > 0 { 737 request.URL.RawQuery = "&" + opQuery 738 } else { 739 request.URL.RawQuery = opQuery 740 } 741 742 request.Method = "POST" 743 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 744 if err != nil { 745 return out, metadata, &smithy.SerializationError{Err: err} 746 } 747 748 restEncoder.SetHeader("Content-Type").String("application/json") 749 750 jsonEncoder := smithyjson.NewEncoder() 751 if err := awsRestjson1_serializeOpDocumentDescribeFlowExecutionRecordsInput(input, jsonEncoder.Value); err != nil { 752 return out, metadata, &smithy.SerializationError{Err: err} 753 } 754 755 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 756 return out, metadata, &smithy.SerializationError{Err: err} 757 } 758 759 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 760 return out, metadata, &smithy.SerializationError{Err: err} 761 } 762 in.Request = request 763 764 return next.HandleSerialize(ctx, in) 765} 766func awsRestjson1_serializeOpHttpBindingsDescribeFlowExecutionRecordsInput(v *DescribeFlowExecutionRecordsInput, encoder *httpbinding.Encoder) error { 767 if v == nil { 768 return fmt.Errorf("unsupported serialization of nil %T", v) 769 } 770 771 return nil 772} 773 774func awsRestjson1_serializeOpDocumentDescribeFlowExecutionRecordsInput(v *DescribeFlowExecutionRecordsInput, value smithyjson.Value) error { 775 object := value.Object() 776 defer object.Close() 777 778 if v.FlowName != nil { 779 ok := object.Key("flowName") 780 ok.String(*v.FlowName) 781 } 782 783 if v.MaxResults != nil { 784 ok := object.Key("maxResults") 785 ok.Integer(*v.MaxResults) 786 } 787 788 if v.NextToken != nil { 789 ok := object.Key("nextToken") 790 ok.String(*v.NextToken) 791 } 792 793 return nil 794} 795 796type awsRestjson1_serializeOpListConnectorEntities struct { 797} 798 799func (*awsRestjson1_serializeOpListConnectorEntities) ID() string { 800 return "OperationSerializer" 801} 802 803func (m *awsRestjson1_serializeOpListConnectorEntities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 804 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 805) { 806 request, ok := in.Request.(*smithyhttp.Request) 807 if !ok { 808 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 809 } 810 811 input, ok := in.Parameters.(*ListConnectorEntitiesInput) 812 _ = input 813 if !ok { 814 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 815 } 816 817 opPath, opQuery := httpbinding.SplitURI("/list-connector-entities") 818 request.URL.Path = opPath 819 if len(request.URL.RawQuery) > 0 { 820 request.URL.RawQuery = "&" + opQuery 821 } else { 822 request.URL.RawQuery = opQuery 823 } 824 825 request.Method = "POST" 826 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 827 if err != nil { 828 return out, metadata, &smithy.SerializationError{Err: err} 829 } 830 831 restEncoder.SetHeader("Content-Type").String("application/json") 832 833 jsonEncoder := smithyjson.NewEncoder() 834 if err := awsRestjson1_serializeOpDocumentListConnectorEntitiesInput(input, jsonEncoder.Value); err != nil { 835 return out, metadata, &smithy.SerializationError{Err: err} 836 } 837 838 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 839 return out, metadata, &smithy.SerializationError{Err: err} 840 } 841 842 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 843 return out, metadata, &smithy.SerializationError{Err: err} 844 } 845 in.Request = request 846 847 return next.HandleSerialize(ctx, in) 848} 849func awsRestjson1_serializeOpHttpBindingsListConnectorEntitiesInput(v *ListConnectorEntitiesInput, encoder *httpbinding.Encoder) error { 850 if v == nil { 851 return fmt.Errorf("unsupported serialization of nil %T", v) 852 } 853 854 return nil 855} 856 857func awsRestjson1_serializeOpDocumentListConnectorEntitiesInput(v *ListConnectorEntitiesInput, value smithyjson.Value) error { 858 object := value.Object() 859 defer object.Close() 860 861 if v.ConnectorProfileName != nil { 862 ok := object.Key("connectorProfileName") 863 ok.String(*v.ConnectorProfileName) 864 } 865 866 if len(v.ConnectorType) > 0 { 867 ok := object.Key("connectorType") 868 ok.String(string(v.ConnectorType)) 869 } 870 871 if v.EntitiesPath != nil { 872 ok := object.Key("entitiesPath") 873 ok.String(*v.EntitiesPath) 874 } 875 876 return nil 877} 878 879type awsRestjson1_serializeOpListFlows struct { 880} 881 882func (*awsRestjson1_serializeOpListFlows) ID() string { 883 return "OperationSerializer" 884} 885 886func (m *awsRestjson1_serializeOpListFlows) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 887 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 888) { 889 request, ok := in.Request.(*smithyhttp.Request) 890 if !ok { 891 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 892 } 893 894 input, ok := in.Parameters.(*ListFlowsInput) 895 _ = input 896 if !ok { 897 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 898 } 899 900 opPath, opQuery := httpbinding.SplitURI("/list-flows") 901 request.URL.Path = opPath 902 if len(request.URL.RawQuery) > 0 { 903 request.URL.RawQuery = "&" + opQuery 904 } else { 905 request.URL.RawQuery = opQuery 906 } 907 908 request.Method = "POST" 909 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 910 if err != nil { 911 return out, metadata, &smithy.SerializationError{Err: err} 912 } 913 914 restEncoder.SetHeader("Content-Type").String("application/json") 915 916 jsonEncoder := smithyjson.NewEncoder() 917 if err := awsRestjson1_serializeOpDocumentListFlowsInput(input, jsonEncoder.Value); err != nil { 918 return out, metadata, &smithy.SerializationError{Err: err} 919 } 920 921 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 922 return out, metadata, &smithy.SerializationError{Err: err} 923 } 924 925 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 926 return out, metadata, &smithy.SerializationError{Err: err} 927 } 928 in.Request = request 929 930 return next.HandleSerialize(ctx, in) 931} 932func awsRestjson1_serializeOpHttpBindingsListFlowsInput(v *ListFlowsInput, encoder *httpbinding.Encoder) error { 933 if v == nil { 934 return fmt.Errorf("unsupported serialization of nil %T", v) 935 } 936 937 return nil 938} 939 940func awsRestjson1_serializeOpDocumentListFlowsInput(v *ListFlowsInput, value smithyjson.Value) error { 941 object := value.Object() 942 defer object.Close() 943 944 if v.MaxResults != nil { 945 ok := object.Key("maxResults") 946 ok.Integer(*v.MaxResults) 947 } 948 949 if v.NextToken != nil { 950 ok := object.Key("nextToken") 951 ok.String(*v.NextToken) 952 } 953 954 return nil 955} 956 957type awsRestjson1_serializeOpListTagsForResource struct { 958} 959 960func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 961 return "OperationSerializer" 962} 963 964func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 965 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 966) { 967 request, ok := in.Request.(*smithyhttp.Request) 968 if !ok { 969 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 970 } 971 972 input, ok := in.Parameters.(*ListTagsForResourceInput) 973 _ = input 974 if !ok { 975 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 976 } 977 978 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 979 request.URL.Path = opPath 980 if len(request.URL.RawQuery) > 0 { 981 request.URL.RawQuery = "&" + opQuery 982 } else { 983 request.URL.RawQuery = opQuery 984 } 985 986 request.Method = "GET" 987 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 988 if err != nil { 989 return out, metadata, &smithy.SerializationError{Err: err} 990 } 991 992 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 993 return out, metadata, &smithy.SerializationError{Err: err} 994 } 995 996 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 997 return out, metadata, &smithy.SerializationError{Err: err} 998 } 999 in.Request = request 1000 1001 return next.HandleSerialize(ctx, in) 1002} 1003func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1004 if v == nil { 1005 return fmt.Errorf("unsupported serialization of nil %T", v) 1006 } 1007 1008 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1009 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 1010 } 1011 if v.ResourceArn != nil { 1012 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 1013 return err 1014 } 1015 } 1016 1017 return nil 1018} 1019 1020type awsRestjson1_serializeOpStartFlow struct { 1021} 1022 1023func (*awsRestjson1_serializeOpStartFlow) ID() string { 1024 return "OperationSerializer" 1025} 1026 1027func (m *awsRestjson1_serializeOpStartFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1028 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1029) { 1030 request, ok := in.Request.(*smithyhttp.Request) 1031 if !ok { 1032 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1033 } 1034 1035 input, ok := in.Parameters.(*StartFlowInput) 1036 _ = input 1037 if !ok { 1038 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1039 } 1040 1041 opPath, opQuery := httpbinding.SplitURI("/start-flow") 1042 request.URL.Path = opPath 1043 if len(request.URL.RawQuery) > 0 { 1044 request.URL.RawQuery = "&" + opQuery 1045 } else { 1046 request.URL.RawQuery = opQuery 1047 } 1048 1049 request.Method = "POST" 1050 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1051 if err != nil { 1052 return out, metadata, &smithy.SerializationError{Err: err} 1053 } 1054 1055 restEncoder.SetHeader("Content-Type").String("application/json") 1056 1057 jsonEncoder := smithyjson.NewEncoder() 1058 if err := awsRestjson1_serializeOpDocumentStartFlowInput(input, jsonEncoder.Value); err != nil { 1059 return out, metadata, &smithy.SerializationError{Err: err} 1060 } 1061 1062 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1063 return out, metadata, &smithy.SerializationError{Err: err} 1064 } 1065 1066 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1067 return out, metadata, &smithy.SerializationError{Err: err} 1068 } 1069 in.Request = request 1070 1071 return next.HandleSerialize(ctx, in) 1072} 1073func awsRestjson1_serializeOpHttpBindingsStartFlowInput(v *StartFlowInput, encoder *httpbinding.Encoder) error { 1074 if v == nil { 1075 return fmt.Errorf("unsupported serialization of nil %T", v) 1076 } 1077 1078 return nil 1079} 1080 1081func awsRestjson1_serializeOpDocumentStartFlowInput(v *StartFlowInput, value smithyjson.Value) error { 1082 object := value.Object() 1083 defer object.Close() 1084 1085 if v.FlowName != nil { 1086 ok := object.Key("flowName") 1087 ok.String(*v.FlowName) 1088 } 1089 1090 return nil 1091} 1092 1093type awsRestjson1_serializeOpStopFlow struct { 1094} 1095 1096func (*awsRestjson1_serializeOpStopFlow) ID() string { 1097 return "OperationSerializer" 1098} 1099 1100func (m *awsRestjson1_serializeOpStopFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1101 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1102) { 1103 request, ok := in.Request.(*smithyhttp.Request) 1104 if !ok { 1105 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1106 } 1107 1108 input, ok := in.Parameters.(*StopFlowInput) 1109 _ = input 1110 if !ok { 1111 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1112 } 1113 1114 opPath, opQuery := httpbinding.SplitURI("/stop-flow") 1115 request.URL.Path = opPath 1116 if len(request.URL.RawQuery) > 0 { 1117 request.URL.RawQuery = "&" + opQuery 1118 } else { 1119 request.URL.RawQuery = opQuery 1120 } 1121 1122 request.Method = "POST" 1123 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1124 if err != nil { 1125 return out, metadata, &smithy.SerializationError{Err: err} 1126 } 1127 1128 restEncoder.SetHeader("Content-Type").String("application/json") 1129 1130 jsonEncoder := smithyjson.NewEncoder() 1131 if err := awsRestjson1_serializeOpDocumentStopFlowInput(input, jsonEncoder.Value); err != nil { 1132 return out, metadata, &smithy.SerializationError{Err: err} 1133 } 1134 1135 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1136 return out, metadata, &smithy.SerializationError{Err: err} 1137 } 1138 1139 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1140 return out, metadata, &smithy.SerializationError{Err: err} 1141 } 1142 in.Request = request 1143 1144 return next.HandleSerialize(ctx, in) 1145} 1146func awsRestjson1_serializeOpHttpBindingsStopFlowInput(v *StopFlowInput, encoder *httpbinding.Encoder) error { 1147 if v == nil { 1148 return fmt.Errorf("unsupported serialization of nil %T", v) 1149 } 1150 1151 return nil 1152} 1153 1154func awsRestjson1_serializeOpDocumentStopFlowInput(v *StopFlowInput, value smithyjson.Value) error { 1155 object := value.Object() 1156 defer object.Close() 1157 1158 if v.FlowName != nil { 1159 ok := object.Key("flowName") 1160 ok.String(*v.FlowName) 1161 } 1162 1163 return nil 1164} 1165 1166type awsRestjson1_serializeOpTagResource struct { 1167} 1168 1169func (*awsRestjson1_serializeOpTagResource) ID() string { 1170 return "OperationSerializer" 1171} 1172 1173func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1174 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1175) { 1176 request, ok := in.Request.(*smithyhttp.Request) 1177 if !ok { 1178 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1179 } 1180 1181 input, ok := in.Parameters.(*TagResourceInput) 1182 _ = input 1183 if !ok { 1184 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1185 } 1186 1187 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 1188 request.URL.Path = opPath 1189 if len(request.URL.RawQuery) > 0 { 1190 request.URL.RawQuery = "&" + opQuery 1191 } else { 1192 request.URL.RawQuery = opQuery 1193 } 1194 1195 request.Method = "POST" 1196 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1197 if err != nil { 1198 return out, metadata, &smithy.SerializationError{Err: err} 1199 } 1200 1201 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 1202 return out, metadata, &smithy.SerializationError{Err: err} 1203 } 1204 1205 restEncoder.SetHeader("Content-Type").String("application/json") 1206 1207 jsonEncoder := smithyjson.NewEncoder() 1208 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1209 return out, metadata, &smithy.SerializationError{Err: err} 1210 } 1211 1212 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1213 return out, metadata, &smithy.SerializationError{Err: err} 1214 } 1215 1216 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1217 return out, metadata, &smithy.SerializationError{Err: err} 1218 } 1219 in.Request = request 1220 1221 return next.HandleSerialize(ctx, in) 1222} 1223func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 1224 if v == nil { 1225 return fmt.Errorf("unsupported serialization of nil %T", v) 1226 } 1227 1228 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1229 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 1230 } 1231 if v.ResourceArn != nil { 1232 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 1233 return err 1234 } 1235 } 1236 1237 return nil 1238} 1239 1240func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 1241 object := value.Object() 1242 defer object.Close() 1243 1244 if v.Tags != nil { 1245 ok := object.Key("tags") 1246 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1247 return err 1248 } 1249 } 1250 1251 return nil 1252} 1253 1254type awsRestjson1_serializeOpUntagResource struct { 1255} 1256 1257func (*awsRestjson1_serializeOpUntagResource) ID() string { 1258 return "OperationSerializer" 1259} 1260 1261func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1262 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1263) { 1264 request, ok := in.Request.(*smithyhttp.Request) 1265 if !ok { 1266 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1267 } 1268 1269 input, ok := in.Parameters.(*UntagResourceInput) 1270 _ = input 1271 if !ok { 1272 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1273 } 1274 1275 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 1276 request.URL.Path = opPath 1277 if len(request.URL.RawQuery) > 0 { 1278 request.URL.RawQuery = "&" + opQuery 1279 } else { 1280 request.URL.RawQuery = opQuery 1281 } 1282 1283 request.Method = "DELETE" 1284 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1285 if err != nil { 1286 return out, metadata, &smithy.SerializationError{Err: err} 1287 } 1288 1289 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 1290 return out, metadata, &smithy.SerializationError{Err: err} 1291 } 1292 1293 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1294 return out, metadata, &smithy.SerializationError{Err: err} 1295 } 1296 in.Request = request 1297 1298 return next.HandleSerialize(ctx, in) 1299} 1300func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 1301 if v == nil { 1302 return fmt.Errorf("unsupported serialization of nil %T", v) 1303 } 1304 1305 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1306 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 1307 } 1308 if v.ResourceArn != nil { 1309 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 1310 return err 1311 } 1312 } 1313 1314 if v.TagKeys != nil { 1315 for i := range v.TagKeys { 1316 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 1317 } 1318 } 1319 1320 return nil 1321} 1322 1323type awsRestjson1_serializeOpUpdateConnectorProfile struct { 1324} 1325 1326func (*awsRestjson1_serializeOpUpdateConnectorProfile) ID() string { 1327 return "OperationSerializer" 1328} 1329 1330func (m *awsRestjson1_serializeOpUpdateConnectorProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1331 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1332) { 1333 request, ok := in.Request.(*smithyhttp.Request) 1334 if !ok { 1335 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1336 } 1337 1338 input, ok := in.Parameters.(*UpdateConnectorProfileInput) 1339 _ = input 1340 if !ok { 1341 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1342 } 1343 1344 opPath, opQuery := httpbinding.SplitURI("/update-connector-profile") 1345 request.URL.Path = opPath 1346 if len(request.URL.RawQuery) > 0 { 1347 request.URL.RawQuery = "&" + opQuery 1348 } else { 1349 request.URL.RawQuery = opQuery 1350 } 1351 1352 request.Method = "POST" 1353 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1354 if err != nil { 1355 return out, metadata, &smithy.SerializationError{Err: err} 1356 } 1357 1358 restEncoder.SetHeader("Content-Type").String("application/json") 1359 1360 jsonEncoder := smithyjson.NewEncoder() 1361 if err := awsRestjson1_serializeOpDocumentUpdateConnectorProfileInput(input, jsonEncoder.Value); err != nil { 1362 return out, metadata, &smithy.SerializationError{Err: err} 1363 } 1364 1365 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1366 return out, metadata, &smithy.SerializationError{Err: err} 1367 } 1368 1369 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1370 return out, metadata, &smithy.SerializationError{Err: err} 1371 } 1372 in.Request = request 1373 1374 return next.HandleSerialize(ctx, in) 1375} 1376func awsRestjson1_serializeOpHttpBindingsUpdateConnectorProfileInput(v *UpdateConnectorProfileInput, encoder *httpbinding.Encoder) error { 1377 if v == nil { 1378 return fmt.Errorf("unsupported serialization of nil %T", v) 1379 } 1380 1381 return nil 1382} 1383 1384func awsRestjson1_serializeOpDocumentUpdateConnectorProfileInput(v *UpdateConnectorProfileInput, value smithyjson.Value) error { 1385 object := value.Object() 1386 defer object.Close() 1387 1388 if len(v.ConnectionMode) > 0 { 1389 ok := object.Key("connectionMode") 1390 ok.String(string(v.ConnectionMode)) 1391 } 1392 1393 if v.ConnectorProfileConfig != nil { 1394 ok := object.Key("connectorProfileConfig") 1395 if err := awsRestjson1_serializeDocumentConnectorProfileConfig(v.ConnectorProfileConfig, ok); err != nil { 1396 return err 1397 } 1398 } 1399 1400 if v.ConnectorProfileName != nil { 1401 ok := object.Key("connectorProfileName") 1402 ok.String(*v.ConnectorProfileName) 1403 } 1404 1405 return nil 1406} 1407 1408type awsRestjson1_serializeOpUpdateFlow struct { 1409} 1410 1411func (*awsRestjson1_serializeOpUpdateFlow) ID() string { 1412 return "OperationSerializer" 1413} 1414 1415func (m *awsRestjson1_serializeOpUpdateFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1416 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1417) { 1418 request, ok := in.Request.(*smithyhttp.Request) 1419 if !ok { 1420 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1421 } 1422 1423 input, ok := in.Parameters.(*UpdateFlowInput) 1424 _ = input 1425 if !ok { 1426 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1427 } 1428 1429 opPath, opQuery := httpbinding.SplitURI("/update-flow") 1430 request.URL.Path = opPath 1431 if len(request.URL.RawQuery) > 0 { 1432 request.URL.RawQuery = "&" + opQuery 1433 } else { 1434 request.URL.RawQuery = opQuery 1435 } 1436 1437 request.Method = "POST" 1438 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1439 if err != nil { 1440 return out, metadata, &smithy.SerializationError{Err: err} 1441 } 1442 1443 restEncoder.SetHeader("Content-Type").String("application/json") 1444 1445 jsonEncoder := smithyjson.NewEncoder() 1446 if err := awsRestjson1_serializeOpDocumentUpdateFlowInput(input, jsonEncoder.Value); err != nil { 1447 return out, metadata, &smithy.SerializationError{Err: err} 1448 } 1449 1450 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1451 return out, metadata, &smithy.SerializationError{Err: err} 1452 } 1453 1454 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1455 return out, metadata, &smithy.SerializationError{Err: err} 1456 } 1457 in.Request = request 1458 1459 return next.HandleSerialize(ctx, in) 1460} 1461func awsRestjson1_serializeOpHttpBindingsUpdateFlowInput(v *UpdateFlowInput, encoder *httpbinding.Encoder) error { 1462 if v == nil { 1463 return fmt.Errorf("unsupported serialization of nil %T", v) 1464 } 1465 1466 return nil 1467} 1468 1469func awsRestjson1_serializeOpDocumentUpdateFlowInput(v *UpdateFlowInput, value smithyjson.Value) error { 1470 object := value.Object() 1471 defer object.Close() 1472 1473 if v.Description != nil { 1474 ok := object.Key("description") 1475 ok.String(*v.Description) 1476 } 1477 1478 if v.DestinationFlowConfigList != nil { 1479 ok := object.Key("destinationFlowConfigList") 1480 if err := awsRestjson1_serializeDocumentDestinationFlowConfigList(v.DestinationFlowConfigList, ok); err != nil { 1481 return err 1482 } 1483 } 1484 1485 if v.FlowName != nil { 1486 ok := object.Key("flowName") 1487 ok.String(*v.FlowName) 1488 } 1489 1490 if v.SourceFlowConfig != nil { 1491 ok := object.Key("sourceFlowConfig") 1492 if err := awsRestjson1_serializeDocumentSourceFlowConfig(v.SourceFlowConfig, ok); err != nil { 1493 return err 1494 } 1495 } 1496 1497 if v.Tasks != nil { 1498 ok := object.Key("tasks") 1499 if err := awsRestjson1_serializeDocumentTasks(v.Tasks, ok); err != nil { 1500 return err 1501 } 1502 } 1503 1504 if v.TriggerConfig != nil { 1505 ok := object.Key("triggerConfig") 1506 if err := awsRestjson1_serializeDocumentTriggerConfig(v.TriggerConfig, ok); err != nil { 1507 return err 1508 } 1509 } 1510 1511 return nil 1512} 1513 1514func awsRestjson1_serializeDocumentAggregationConfig(v *types.AggregationConfig, value smithyjson.Value) error { 1515 object := value.Object() 1516 defer object.Close() 1517 1518 if len(v.AggregationType) > 0 { 1519 ok := object.Key("aggregationType") 1520 ok.String(string(v.AggregationType)) 1521 } 1522 1523 return nil 1524} 1525 1526func awsRestjson1_serializeDocumentAmplitudeConnectorProfileCredentials(v *types.AmplitudeConnectorProfileCredentials, value smithyjson.Value) error { 1527 object := value.Object() 1528 defer object.Close() 1529 1530 if v.ApiKey != nil { 1531 ok := object.Key("apiKey") 1532 ok.String(*v.ApiKey) 1533 } 1534 1535 if v.SecretKey != nil { 1536 ok := object.Key("secretKey") 1537 ok.String(*v.SecretKey) 1538 } 1539 1540 return nil 1541} 1542 1543func awsRestjson1_serializeDocumentAmplitudeConnectorProfileProperties(v *types.AmplitudeConnectorProfileProperties, value smithyjson.Value) error { 1544 object := value.Object() 1545 defer object.Close() 1546 1547 return nil 1548} 1549 1550func awsRestjson1_serializeDocumentAmplitudeSourceProperties(v *types.AmplitudeSourceProperties, value smithyjson.Value) error { 1551 object := value.Object() 1552 defer object.Close() 1553 1554 if v.Object != nil { 1555 ok := object.Key("object") 1556 ok.String(*v.Object) 1557 } 1558 1559 return nil 1560} 1561 1562func awsRestjson1_serializeDocumentConnectorOAuthRequest(v *types.ConnectorOAuthRequest, value smithyjson.Value) error { 1563 object := value.Object() 1564 defer object.Close() 1565 1566 if v.AuthCode != nil { 1567 ok := object.Key("authCode") 1568 ok.String(*v.AuthCode) 1569 } 1570 1571 if v.RedirectUri != nil { 1572 ok := object.Key("redirectUri") 1573 ok.String(*v.RedirectUri) 1574 } 1575 1576 return nil 1577} 1578 1579func awsRestjson1_serializeDocumentConnectorOperator(v *types.ConnectorOperator, value smithyjson.Value) error { 1580 object := value.Object() 1581 defer object.Close() 1582 1583 if len(v.Amplitude) > 0 { 1584 ok := object.Key("Amplitude") 1585 ok.String(string(v.Amplitude)) 1586 } 1587 1588 if len(v.Datadog) > 0 { 1589 ok := object.Key("Datadog") 1590 ok.String(string(v.Datadog)) 1591 } 1592 1593 if len(v.Dynatrace) > 0 { 1594 ok := object.Key("Dynatrace") 1595 ok.String(string(v.Dynatrace)) 1596 } 1597 1598 if len(v.GoogleAnalytics) > 0 { 1599 ok := object.Key("GoogleAnalytics") 1600 ok.String(string(v.GoogleAnalytics)) 1601 } 1602 1603 if len(v.InforNexus) > 0 { 1604 ok := object.Key("InforNexus") 1605 ok.String(string(v.InforNexus)) 1606 } 1607 1608 if len(v.Marketo) > 0 { 1609 ok := object.Key("Marketo") 1610 ok.String(string(v.Marketo)) 1611 } 1612 1613 if len(v.S3) > 0 { 1614 ok := object.Key("S3") 1615 ok.String(string(v.S3)) 1616 } 1617 1618 if len(v.Salesforce) > 0 { 1619 ok := object.Key("Salesforce") 1620 ok.String(string(v.Salesforce)) 1621 } 1622 1623 if len(v.ServiceNow) > 0 { 1624 ok := object.Key("ServiceNow") 1625 ok.String(string(v.ServiceNow)) 1626 } 1627 1628 if len(v.Singular) > 0 { 1629 ok := object.Key("Singular") 1630 ok.String(string(v.Singular)) 1631 } 1632 1633 if len(v.Slack) > 0 { 1634 ok := object.Key("Slack") 1635 ok.String(string(v.Slack)) 1636 } 1637 1638 if len(v.Trendmicro) > 0 { 1639 ok := object.Key("Trendmicro") 1640 ok.String(string(v.Trendmicro)) 1641 } 1642 1643 if len(v.Veeva) > 0 { 1644 ok := object.Key("Veeva") 1645 ok.String(string(v.Veeva)) 1646 } 1647 1648 if len(v.Zendesk) > 0 { 1649 ok := object.Key("Zendesk") 1650 ok.String(string(v.Zendesk)) 1651 } 1652 1653 return nil 1654} 1655 1656func awsRestjson1_serializeDocumentConnectorProfileConfig(v *types.ConnectorProfileConfig, value smithyjson.Value) error { 1657 object := value.Object() 1658 defer object.Close() 1659 1660 if v.ConnectorProfileCredentials != nil { 1661 ok := object.Key("connectorProfileCredentials") 1662 if err := awsRestjson1_serializeDocumentConnectorProfileCredentials(v.ConnectorProfileCredentials, ok); err != nil { 1663 return err 1664 } 1665 } 1666 1667 if v.ConnectorProfileProperties != nil { 1668 ok := object.Key("connectorProfileProperties") 1669 if err := awsRestjson1_serializeDocumentConnectorProfileProperties(v.ConnectorProfileProperties, ok); err != nil { 1670 return err 1671 } 1672 } 1673 1674 return nil 1675} 1676 1677func awsRestjson1_serializeDocumentConnectorProfileCredentials(v *types.ConnectorProfileCredentials, value smithyjson.Value) error { 1678 object := value.Object() 1679 defer object.Close() 1680 1681 if v.Amplitude != nil { 1682 ok := object.Key("Amplitude") 1683 if err := awsRestjson1_serializeDocumentAmplitudeConnectorProfileCredentials(v.Amplitude, ok); err != nil { 1684 return err 1685 } 1686 } 1687 1688 if v.Datadog != nil { 1689 ok := object.Key("Datadog") 1690 if err := awsRestjson1_serializeDocumentDatadogConnectorProfileCredentials(v.Datadog, ok); err != nil { 1691 return err 1692 } 1693 } 1694 1695 if v.Dynatrace != nil { 1696 ok := object.Key("Dynatrace") 1697 if err := awsRestjson1_serializeDocumentDynatraceConnectorProfileCredentials(v.Dynatrace, ok); err != nil { 1698 return err 1699 } 1700 } 1701 1702 if v.GoogleAnalytics != nil { 1703 ok := object.Key("GoogleAnalytics") 1704 if err := awsRestjson1_serializeDocumentGoogleAnalyticsConnectorProfileCredentials(v.GoogleAnalytics, ok); err != nil { 1705 return err 1706 } 1707 } 1708 1709 if v.InforNexus != nil { 1710 ok := object.Key("InforNexus") 1711 if err := awsRestjson1_serializeDocumentInforNexusConnectorProfileCredentials(v.InforNexus, ok); err != nil { 1712 return err 1713 } 1714 } 1715 1716 if v.Marketo != nil { 1717 ok := object.Key("Marketo") 1718 if err := awsRestjson1_serializeDocumentMarketoConnectorProfileCredentials(v.Marketo, ok); err != nil { 1719 return err 1720 } 1721 } 1722 1723 if v.Redshift != nil { 1724 ok := object.Key("Redshift") 1725 if err := awsRestjson1_serializeDocumentRedshiftConnectorProfileCredentials(v.Redshift, ok); err != nil { 1726 return err 1727 } 1728 } 1729 1730 if v.Salesforce != nil { 1731 ok := object.Key("Salesforce") 1732 if err := awsRestjson1_serializeDocumentSalesforceConnectorProfileCredentials(v.Salesforce, ok); err != nil { 1733 return err 1734 } 1735 } 1736 1737 if v.ServiceNow != nil { 1738 ok := object.Key("ServiceNow") 1739 if err := awsRestjson1_serializeDocumentServiceNowConnectorProfileCredentials(v.ServiceNow, ok); err != nil { 1740 return err 1741 } 1742 } 1743 1744 if v.Singular != nil { 1745 ok := object.Key("Singular") 1746 if err := awsRestjson1_serializeDocumentSingularConnectorProfileCredentials(v.Singular, ok); err != nil { 1747 return err 1748 } 1749 } 1750 1751 if v.Slack != nil { 1752 ok := object.Key("Slack") 1753 if err := awsRestjson1_serializeDocumentSlackConnectorProfileCredentials(v.Slack, ok); err != nil { 1754 return err 1755 } 1756 } 1757 1758 if v.Snowflake != nil { 1759 ok := object.Key("Snowflake") 1760 if err := awsRestjson1_serializeDocumentSnowflakeConnectorProfileCredentials(v.Snowflake, ok); err != nil { 1761 return err 1762 } 1763 } 1764 1765 if v.Trendmicro != nil { 1766 ok := object.Key("Trendmicro") 1767 if err := awsRestjson1_serializeDocumentTrendmicroConnectorProfileCredentials(v.Trendmicro, ok); err != nil { 1768 return err 1769 } 1770 } 1771 1772 if v.Veeva != nil { 1773 ok := object.Key("Veeva") 1774 if err := awsRestjson1_serializeDocumentVeevaConnectorProfileCredentials(v.Veeva, ok); err != nil { 1775 return err 1776 } 1777 } 1778 1779 if v.Zendesk != nil { 1780 ok := object.Key("Zendesk") 1781 if err := awsRestjson1_serializeDocumentZendeskConnectorProfileCredentials(v.Zendesk, ok); err != nil { 1782 return err 1783 } 1784 } 1785 1786 return nil 1787} 1788 1789func awsRestjson1_serializeDocumentConnectorProfileNameList(v []string, value smithyjson.Value) error { 1790 array := value.Array() 1791 defer array.Close() 1792 1793 for i := range v { 1794 av := array.Value() 1795 av.String(v[i]) 1796 } 1797 return nil 1798} 1799 1800func awsRestjson1_serializeDocumentConnectorProfileProperties(v *types.ConnectorProfileProperties, value smithyjson.Value) error { 1801 object := value.Object() 1802 defer object.Close() 1803 1804 if v.Amplitude != nil { 1805 ok := object.Key("Amplitude") 1806 if err := awsRestjson1_serializeDocumentAmplitudeConnectorProfileProperties(v.Amplitude, ok); err != nil { 1807 return err 1808 } 1809 } 1810 1811 if v.Datadog != nil { 1812 ok := object.Key("Datadog") 1813 if err := awsRestjson1_serializeDocumentDatadogConnectorProfileProperties(v.Datadog, ok); err != nil { 1814 return err 1815 } 1816 } 1817 1818 if v.Dynatrace != nil { 1819 ok := object.Key("Dynatrace") 1820 if err := awsRestjson1_serializeDocumentDynatraceConnectorProfileProperties(v.Dynatrace, ok); err != nil { 1821 return err 1822 } 1823 } 1824 1825 if v.GoogleAnalytics != nil { 1826 ok := object.Key("GoogleAnalytics") 1827 if err := awsRestjson1_serializeDocumentGoogleAnalyticsConnectorProfileProperties(v.GoogleAnalytics, ok); err != nil { 1828 return err 1829 } 1830 } 1831 1832 if v.InforNexus != nil { 1833 ok := object.Key("InforNexus") 1834 if err := awsRestjson1_serializeDocumentInforNexusConnectorProfileProperties(v.InforNexus, ok); err != nil { 1835 return err 1836 } 1837 } 1838 1839 if v.Marketo != nil { 1840 ok := object.Key("Marketo") 1841 if err := awsRestjson1_serializeDocumentMarketoConnectorProfileProperties(v.Marketo, ok); err != nil { 1842 return err 1843 } 1844 } 1845 1846 if v.Redshift != nil { 1847 ok := object.Key("Redshift") 1848 if err := awsRestjson1_serializeDocumentRedshiftConnectorProfileProperties(v.Redshift, ok); err != nil { 1849 return err 1850 } 1851 } 1852 1853 if v.Salesforce != nil { 1854 ok := object.Key("Salesforce") 1855 if err := awsRestjson1_serializeDocumentSalesforceConnectorProfileProperties(v.Salesforce, ok); err != nil { 1856 return err 1857 } 1858 } 1859 1860 if v.ServiceNow != nil { 1861 ok := object.Key("ServiceNow") 1862 if err := awsRestjson1_serializeDocumentServiceNowConnectorProfileProperties(v.ServiceNow, ok); err != nil { 1863 return err 1864 } 1865 } 1866 1867 if v.Singular != nil { 1868 ok := object.Key("Singular") 1869 if err := awsRestjson1_serializeDocumentSingularConnectorProfileProperties(v.Singular, ok); err != nil { 1870 return err 1871 } 1872 } 1873 1874 if v.Slack != nil { 1875 ok := object.Key("Slack") 1876 if err := awsRestjson1_serializeDocumentSlackConnectorProfileProperties(v.Slack, ok); err != nil { 1877 return err 1878 } 1879 } 1880 1881 if v.Snowflake != nil { 1882 ok := object.Key("Snowflake") 1883 if err := awsRestjson1_serializeDocumentSnowflakeConnectorProfileProperties(v.Snowflake, ok); err != nil { 1884 return err 1885 } 1886 } 1887 1888 if v.Trendmicro != nil { 1889 ok := object.Key("Trendmicro") 1890 if err := awsRestjson1_serializeDocumentTrendmicroConnectorProfileProperties(v.Trendmicro, ok); err != nil { 1891 return err 1892 } 1893 } 1894 1895 if v.Veeva != nil { 1896 ok := object.Key("Veeva") 1897 if err := awsRestjson1_serializeDocumentVeevaConnectorProfileProperties(v.Veeva, ok); err != nil { 1898 return err 1899 } 1900 } 1901 1902 if v.Zendesk != nil { 1903 ok := object.Key("Zendesk") 1904 if err := awsRestjson1_serializeDocumentZendeskConnectorProfileProperties(v.Zendesk, ok); err != nil { 1905 return err 1906 } 1907 } 1908 1909 return nil 1910} 1911 1912func awsRestjson1_serializeDocumentConnectorTypeList(v []types.ConnectorType, value smithyjson.Value) error { 1913 array := value.Array() 1914 defer array.Close() 1915 1916 for i := range v { 1917 av := array.Value() 1918 av.String(string(v[i])) 1919 } 1920 return nil 1921} 1922 1923func awsRestjson1_serializeDocumentDatadogConnectorProfileCredentials(v *types.DatadogConnectorProfileCredentials, value smithyjson.Value) error { 1924 object := value.Object() 1925 defer object.Close() 1926 1927 if v.ApiKey != nil { 1928 ok := object.Key("apiKey") 1929 ok.String(*v.ApiKey) 1930 } 1931 1932 if v.ApplicationKey != nil { 1933 ok := object.Key("applicationKey") 1934 ok.String(*v.ApplicationKey) 1935 } 1936 1937 return nil 1938} 1939 1940func awsRestjson1_serializeDocumentDatadogConnectorProfileProperties(v *types.DatadogConnectorProfileProperties, value smithyjson.Value) error { 1941 object := value.Object() 1942 defer object.Close() 1943 1944 if v.InstanceUrl != nil { 1945 ok := object.Key("instanceUrl") 1946 ok.String(*v.InstanceUrl) 1947 } 1948 1949 return nil 1950} 1951 1952func awsRestjson1_serializeDocumentDatadogSourceProperties(v *types.DatadogSourceProperties, value smithyjson.Value) error { 1953 object := value.Object() 1954 defer object.Close() 1955 1956 if v.Object != nil { 1957 ok := object.Key("object") 1958 ok.String(*v.Object) 1959 } 1960 1961 return nil 1962} 1963 1964func awsRestjson1_serializeDocumentDestinationConnectorProperties(v *types.DestinationConnectorProperties, value smithyjson.Value) error { 1965 object := value.Object() 1966 defer object.Close() 1967 1968 if v.EventBridge != nil { 1969 ok := object.Key("EventBridge") 1970 if err := awsRestjson1_serializeDocumentEventBridgeDestinationProperties(v.EventBridge, ok); err != nil { 1971 return err 1972 } 1973 } 1974 1975 if v.Redshift != nil { 1976 ok := object.Key("Redshift") 1977 if err := awsRestjson1_serializeDocumentRedshiftDestinationProperties(v.Redshift, ok); err != nil { 1978 return err 1979 } 1980 } 1981 1982 if v.S3 != nil { 1983 ok := object.Key("S3") 1984 if err := awsRestjson1_serializeDocumentS3DestinationProperties(v.S3, ok); err != nil { 1985 return err 1986 } 1987 } 1988 1989 if v.Salesforce != nil { 1990 ok := object.Key("Salesforce") 1991 if err := awsRestjson1_serializeDocumentSalesforceDestinationProperties(v.Salesforce, ok); err != nil { 1992 return err 1993 } 1994 } 1995 1996 if v.Snowflake != nil { 1997 ok := object.Key("Snowflake") 1998 if err := awsRestjson1_serializeDocumentSnowflakeDestinationProperties(v.Snowflake, ok); err != nil { 1999 return err 2000 } 2001 } 2002 2003 if v.Upsolver != nil { 2004 ok := object.Key("Upsolver") 2005 if err := awsRestjson1_serializeDocumentUpsolverDestinationProperties(v.Upsolver, ok); err != nil { 2006 return err 2007 } 2008 } 2009 2010 return nil 2011} 2012 2013func awsRestjson1_serializeDocumentDestinationFlowConfig(v *types.DestinationFlowConfig, value smithyjson.Value) error { 2014 object := value.Object() 2015 defer object.Close() 2016 2017 if v.ConnectorProfileName != nil { 2018 ok := object.Key("connectorProfileName") 2019 ok.String(*v.ConnectorProfileName) 2020 } 2021 2022 if len(v.ConnectorType) > 0 { 2023 ok := object.Key("connectorType") 2024 ok.String(string(v.ConnectorType)) 2025 } 2026 2027 if v.DestinationConnectorProperties != nil { 2028 ok := object.Key("destinationConnectorProperties") 2029 if err := awsRestjson1_serializeDocumentDestinationConnectorProperties(v.DestinationConnectorProperties, ok); err != nil { 2030 return err 2031 } 2032 } 2033 2034 return nil 2035} 2036 2037func awsRestjson1_serializeDocumentDestinationFlowConfigList(v []types.DestinationFlowConfig, value smithyjson.Value) error { 2038 array := value.Array() 2039 defer array.Close() 2040 2041 for i := range v { 2042 av := array.Value() 2043 if err := awsRestjson1_serializeDocumentDestinationFlowConfig(&v[i], av); err != nil { 2044 return err 2045 } 2046 } 2047 return nil 2048} 2049 2050func awsRestjson1_serializeDocumentDynatraceConnectorProfileCredentials(v *types.DynatraceConnectorProfileCredentials, value smithyjson.Value) error { 2051 object := value.Object() 2052 defer object.Close() 2053 2054 if v.ApiToken != nil { 2055 ok := object.Key("apiToken") 2056 ok.String(*v.ApiToken) 2057 } 2058 2059 return nil 2060} 2061 2062func awsRestjson1_serializeDocumentDynatraceConnectorProfileProperties(v *types.DynatraceConnectorProfileProperties, value smithyjson.Value) error { 2063 object := value.Object() 2064 defer object.Close() 2065 2066 if v.InstanceUrl != nil { 2067 ok := object.Key("instanceUrl") 2068 ok.String(*v.InstanceUrl) 2069 } 2070 2071 return nil 2072} 2073 2074func awsRestjson1_serializeDocumentDynatraceSourceProperties(v *types.DynatraceSourceProperties, value smithyjson.Value) error { 2075 object := value.Object() 2076 defer object.Close() 2077 2078 if v.Object != nil { 2079 ok := object.Key("object") 2080 ok.String(*v.Object) 2081 } 2082 2083 return nil 2084} 2085 2086func awsRestjson1_serializeDocumentErrorHandlingConfig(v *types.ErrorHandlingConfig, value smithyjson.Value) error { 2087 object := value.Object() 2088 defer object.Close() 2089 2090 if v.BucketName != nil { 2091 ok := object.Key("bucketName") 2092 ok.String(*v.BucketName) 2093 } 2094 2095 if v.BucketPrefix != nil { 2096 ok := object.Key("bucketPrefix") 2097 ok.String(*v.BucketPrefix) 2098 } 2099 2100 if v.FailOnFirstDestinationError { 2101 ok := object.Key("failOnFirstDestinationError") 2102 ok.Boolean(v.FailOnFirstDestinationError) 2103 } 2104 2105 return nil 2106} 2107 2108func awsRestjson1_serializeDocumentEventBridgeDestinationProperties(v *types.EventBridgeDestinationProperties, value smithyjson.Value) error { 2109 object := value.Object() 2110 defer object.Close() 2111 2112 if v.ErrorHandlingConfig != nil { 2113 ok := object.Key("errorHandlingConfig") 2114 if err := awsRestjson1_serializeDocumentErrorHandlingConfig(v.ErrorHandlingConfig, ok); err != nil { 2115 return err 2116 } 2117 } 2118 2119 if v.Object != nil { 2120 ok := object.Key("object") 2121 ok.String(*v.Object) 2122 } 2123 2124 return nil 2125} 2126 2127func awsRestjson1_serializeDocumentGoogleAnalyticsConnectorProfileCredentials(v *types.GoogleAnalyticsConnectorProfileCredentials, value smithyjson.Value) error { 2128 object := value.Object() 2129 defer object.Close() 2130 2131 if v.AccessToken != nil { 2132 ok := object.Key("accessToken") 2133 ok.String(*v.AccessToken) 2134 } 2135 2136 if v.ClientId != nil { 2137 ok := object.Key("clientId") 2138 ok.String(*v.ClientId) 2139 } 2140 2141 if v.ClientSecret != nil { 2142 ok := object.Key("clientSecret") 2143 ok.String(*v.ClientSecret) 2144 } 2145 2146 if v.OAuthRequest != nil { 2147 ok := object.Key("oAuthRequest") 2148 if err := awsRestjson1_serializeDocumentConnectorOAuthRequest(v.OAuthRequest, ok); err != nil { 2149 return err 2150 } 2151 } 2152 2153 if v.RefreshToken != nil { 2154 ok := object.Key("refreshToken") 2155 ok.String(*v.RefreshToken) 2156 } 2157 2158 return nil 2159} 2160 2161func awsRestjson1_serializeDocumentGoogleAnalyticsConnectorProfileProperties(v *types.GoogleAnalyticsConnectorProfileProperties, value smithyjson.Value) error { 2162 object := value.Object() 2163 defer object.Close() 2164 2165 return nil 2166} 2167 2168func awsRestjson1_serializeDocumentGoogleAnalyticsSourceProperties(v *types.GoogleAnalyticsSourceProperties, value smithyjson.Value) error { 2169 object := value.Object() 2170 defer object.Close() 2171 2172 if v.Object != nil { 2173 ok := object.Key("object") 2174 ok.String(*v.Object) 2175 } 2176 2177 return nil 2178} 2179 2180func awsRestjson1_serializeDocumentIdFieldNameList(v []string, value smithyjson.Value) error { 2181 array := value.Array() 2182 defer array.Close() 2183 2184 for i := range v { 2185 av := array.Value() 2186 av.String(v[i]) 2187 } 2188 return nil 2189} 2190 2191func awsRestjson1_serializeDocumentIncrementalPullConfig(v *types.IncrementalPullConfig, value smithyjson.Value) error { 2192 object := value.Object() 2193 defer object.Close() 2194 2195 if v.DatetimeTypeFieldName != nil { 2196 ok := object.Key("datetimeTypeFieldName") 2197 ok.String(*v.DatetimeTypeFieldName) 2198 } 2199 2200 return nil 2201} 2202 2203func awsRestjson1_serializeDocumentInforNexusConnectorProfileCredentials(v *types.InforNexusConnectorProfileCredentials, value smithyjson.Value) error { 2204 object := value.Object() 2205 defer object.Close() 2206 2207 if v.AccessKeyId != nil { 2208 ok := object.Key("accessKeyId") 2209 ok.String(*v.AccessKeyId) 2210 } 2211 2212 if v.Datakey != nil { 2213 ok := object.Key("datakey") 2214 ok.String(*v.Datakey) 2215 } 2216 2217 if v.SecretAccessKey != nil { 2218 ok := object.Key("secretAccessKey") 2219 ok.String(*v.SecretAccessKey) 2220 } 2221 2222 if v.UserId != nil { 2223 ok := object.Key("userId") 2224 ok.String(*v.UserId) 2225 } 2226 2227 return nil 2228} 2229 2230func awsRestjson1_serializeDocumentInforNexusConnectorProfileProperties(v *types.InforNexusConnectorProfileProperties, value smithyjson.Value) error { 2231 object := value.Object() 2232 defer object.Close() 2233 2234 if v.InstanceUrl != nil { 2235 ok := object.Key("instanceUrl") 2236 ok.String(*v.InstanceUrl) 2237 } 2238 2239 return nil 2240} 2241 2242func awsRestjson1_serializeDocumentInforNexusSourceProperties(v *types.InforNexusSourceProperties, value smithyjson.Value) error { 2243 object := value.Object() 2244 defer object.Close() 2245 2246 if v.Object != nil { 2247 ok := object.Key("object") 2248 ok.String(*v.Object) 2249 } 2250 2251 return nil 2252} 2253 2254func awsRestjson1_serializeDocumentMarketoConnectorProfileCredentials(v *types.MarketoConnectorProfileCredentials, value smithyjson.Value) error { 2255 object := value.Object() 2256 defer object.Close() 2257 2258 if v.AccessToken != nil { 2259 ok := object.Key("accessToken") 2260 ok.String(*v.AccessToken) 2261 } 2262 2263 if v.ClientId != nil { 2264 ok := object.Key("clientId") 2265 ok.String(*v.ClientId) 2266 } 2267 2268 if v.ClientSecret != nil { 2269 ok := object.Key("clientSecret") 2270 ok.String(*v.ClientSecret) 2271 } 2272 2273 if v.OAuthRequest != nil { 2274 ok := object.Key("oAuthRequest") 2275 if err := awsRestjson1_serializeDocumentConnectorOAuthRequest(v.OAuthRequest, ok); err != nil { 2276 return err 2277 } 2278 } 2279 2280 return nil 2281} 2282 2283func awsRestjson1_serializeDocumentMarketoConnectorProfileProperties(v *types.MarketoConnectorProfileProperties, value smithyjson.Value) error { 2284 object := value.Object() 2285 defer object.Close() 2286 2287 if v.InstanceUrl != nil { 2288 ok := object.Key("instanceUrl") 2289 ok.String(*v.InstanceUrl) 2290 } 2291 2292 return nil 2293} 2294 2295func awsRestjson1_serializeDocumentMarketoSourceProperties(v *types.MarketoSourceProperties, value smithyjson.Value) error { 2296 object := value.Object() 2297 defer object.Close() 2298 2299 if v.Object != nil { 2300 ok := object.Key("object") 2301 ok.String(*v.Object) 2302 } 2303 2304 return nil 2305} 2306 2307func awsRestjson1_serializeDocumentPrefixConfig(v *types.PrefixConfig, value smithyjson.Value) error { 2308 object := value.Object() 2309 defer object.Close() 2310 2311 if len(v.PrefixFormat) > 0 { 2312 ok := object.Key("prefixFormat") 2313 ok.String(string(v.PrefixFormat)) 2314 } 2315 2316 if len(v.PrefixType) > 0 { 2317 ok := object.Key("prefixType") 2318 ok.String(string(v.PrefixType)) 2319 } 2320 2321 return nil 2322} 2323 2324func awsRestjson1_serializeDocumentRedshiftConnectorProfileCredentials(v *types.RedshiftConnectorProfileCredentials, value smithyjson.Value) error { 2325 object := value.Object() 2326 defer object.Close() 2327 2328 if v.Password != nil { 2329 ok := object.Key("password") 2330 ok.String(*v.Password) 2331 } 2332 2333 if v.Username != nil { 2334 ok := object.Key("username") 2335 ok.String(*v.Username) 2336 } 2337 2338 return nil 2339} 2340 2341func awsRestjson1_serializeDocumentRedshiftConnectorProfileProperties(v *types.RedshiftConnectorProfileProperties, value smithyjson.Value) error { 2342 object := value.Object() 2343 defer object.Close() 2344 2345 if v.BucketName != nil { 2346 ok := object.Key("bucketName") 2347 ok.String(*v.BucketName) 2348 } 2349 2350 if v.BucketPrefix != nil { 2351 ok := object.Key("bucketPrefix") 2352 ok.String(*v.BucketPrefix) 2353 } 2354 2355 if v.DatabaseUrl != nil { 2356 ok := object.Key("databaseUrl") 2357 ok.String(*v.DatabaseUrl) 2358 } 2359 2360 if v.RoleArn != nil { 2361 ok := object.Key("roleArn") 2362 ok.String(*v.RoleArn) 2363 } 2364 2365 return nil 2366} 2367 2368func awsRestjson1_serializeDocumentRedshiftDestinationProperties(v *types.RedshiftDestinationProperties, value smithyjson.Value) error { 2369 object := value.Object() 2370 defer object.Close() 2371 2372 if v.BucketPrefix != nil { 2373 ok := object.Key("bucketPrefix") 2374 ok.String(*v.BucketPrefix) 2375 } 2376 2377 if v.ErrorHandlingConfig != nil { 2378 ok := object.Key("errorHandlingConfig") 2379 if err := awsRestjson1_serializeDocumentErrorHandlingConfig(v.ErrorHandlingConfig, ok); err != nil { 2380 return err 2381 } 2382 } 2383 2384 if v.IntermediateBucketName != nil { 2385 ok := object.Key("intermediateBucketName") 2386 ok.String(*v.IntermediateBucketName) 2387 } 2388 2389 if v.Object != nil { 2390 ok := object.Key("object") 2391 ok.String(*v.Object) 2392 } 2393 2394 return nil 2395} 2396 2397func awsRestjson1_serializeDocumentS3DestinationProperties(v *types.S3DestinationProperties, value smithyjson.Value) error { 2398 object := value.Object() 2399 defer object.Close() 2400 2401 if v.BucketName != nil { 2402 ok := object.Key("bucketName") 2403 ok.String(*v.BucketName) 2404 } 2405 2406 if v.BucketPrefix != nil { 2407 ok := object.Key("bucketPrefix") 2408 ok.String(*v.BucketPrefix) 2409 } 2410 2411 if v.S3OutputFormatConfig != nil { 2412 ok := object.Key("s3OutputFormatConfig") 2413 if err := awsRestjson1_serializeDocumentS3OutputFormatConfig(v.S3OutputFormatConfig, ok); err != nil { 2414 return err 2415 } 2416 } 2417 2418 return nil 2419} 2420 2421func awsRestjson1_serializeDocumentS3OutputFormatConfig(v *types.S3OutputFormatConfig, value smithyjson.Value) error { 2422 object := value.Object() 2423 defer object.Close() 2424 2425 if v.AggregationConfig != nil { 2426 ok := object.Key("aggregationConfig") 2427 if err := awsRestjson1_serializeDocumentAggregationConfig(v.AggregationConfig, ok); err != nil { 2428 return err 2429 } 2430 } 2431 2432 if len(v.FileType) > 0 { 2433 ok := object.Key("fileType") 2434 ok.String(string(v.FileType)) 2435 } 2436 2437 if v.PrefixConfig != nil { 2438 ok := object.Key("prefixConfig") 2439 if err := awsRestjson1_serializeDocumentPrefixConfig(v.PrefixConfig, ok); err != nil { 2440 return err 2441 } 2442 } 2443 2444 return nil 2445} 2446 2447func awsRestjson1_serializeDocumentS3SourceProperties(v *types.S3SourceProperties, value smithyjson.Value) error { 2448 object := value.Object() 2449 defer object.Close() 2450 2451 if v.BucketName != nil { 2452 ok := object.Key("bucketName") 2453 ok.String(*v.BucketName) 2454 } 2455 2456 if v.BucketPrefix != nil { 2457 ok := object.Key("bucketPrefix") 2458 ok.String(*v.BucketPrefix) 2459 } 2460 2461 return nil 2462} 2463 2464func awsRestjson1_serializeDocumentSalesforceConnectorProfileCredentials(v *types.SalesforceConnectorProfileCredentials, value smithyjson.Value) error { 2465 object := value.Object() 2466 defer object.Close() 2467 2468 if v.AccessToken != nil { 2469 ok := object.Key("accessToken") 2470 ok.String(*v.AccessToken) 2471 } 2472 2473 if v.ClientCredentialsArn != nil { 2474 ok := object.Key("clientCredentialsArn") 2475 ok.String(*v.ClientCredentialsArn) 2476 } 2477 2478 if v.OAuthRequest != nil { 2479 ok := object.Key("oAuthRequest") 2480 if err := awsRestjson1_serializeDocumentConnectorOAuthRequest(v.OAuthRequest, ok); err != nil { 2481 return err 2482 } 2483 } 2484 2485 if v.RefreshToken != nil { 2486 ok := object.Key("refreshToken") 2487 ok.String(*v.RefreshToken) 2488 } 2489 2490 return nil 2491} 2492 2493func awsRestjson1_serializeDocumentSalesforceConnectorProfileProperties(v *types.SalesforceConnectorProfileProperties, value smithyjson.Value) error { 2494 object := value.Object() 2495 defer object.Close() 2496 2497 if v.InstanceUrl != nil { 2498 ok := object.Key("instanceUrl") 2499 ok.String(*v.InstanceUrl) 2500 } 2501 2502 if v.IsSandboxEnvironment { 2503 ok := object.Key("isSandboxEnvironment") 2504 ok.Boolean(v.IsSandboxEnvironment) 2505 } 2506 2507 return nil 2508} 2509 2510func awsRestjson1_serializeDocumentSalesforceDestinationProperties(v *types.SalesforceDestinationProperties, value smithyjson.Value) error { 2511 object := value.Object() 2512 defer object.Close() 2513 2514 if v.ErrorHandlingConfig != nil { 2515 ok := object.Key("errorHandlingConfig") 2516 if err := awsRestjson1_serializeDocumentErrorHandlingConfig(v.ErrorHandlingConfig, ok); err != nil { 2517 return err 2518 } 2519 } 2520 2521 if v.IdFieldNames != nil { 2522 ok := object.Key("idFieldNames") 2523 if err := awsRestjson1_serializeDocumentIdFieldNameList(v.IdFieldNames, ok); err != nil { 2524 return err 2525 } 2526 } 2527 2528 if v.Object != nil { 2529 ok := object.Key("object") 2530 ok.String(*v.Object) 2531 } 2532 2533 if len(v.WriteOperationType) > 0 { 2534 ok := object.Key("writeOperationType") 2535 ok.String(string(v.WriteOperationType)) 2536 } 2537 2538 return nil 2539} 2540 2541func awsRestjson1_serializeDocumentSalesforceSourceProperties(v *types.SalesforceSourceProperties, value smithyjson.Value) error { 2542 object := value.Object() 2543 defer object.Close() 2544 2545 if v.EnableDynamicFieldUpdate { 2546 ok := object.Key("enableDynamicFieldUpdate") 2547 ok.Boolean(v.EnableDynamicFieldUpdate) 2548 } 2549 2550 if v.IncludeDeletedRecords { 2551 ok := object.Key("includeDeletedRecords") 2552 ok.Boolean(v.IncludeDeletedRecords) 2553 } 2554 2555 if v.Object != nil { 2556 ok := object.Key("object") 2557 ok.String(*v.Object) 2558 } 2559 2560 return nil 2561} 2562 2563func awsRestjson1_serializeDocumentScheduledTriggerProperties(v *types.ScheduledTriggerProperties, value smithyjson.Value) error { 2564 object := value.Object() 2565 defer object.Close() 2566 2567 if len(v.DataPullMode) > 0 { 2568 ok := object.Key("dataPullMode") 2569 ok.String(string(v.DataPullMode)) 2570 } 2571 2572 if v.ScheduleEndTime != nil { 2573 ok := object.Key("scheduleEndTime") 2574 ok.Double(smithytime.FormatEpochSeconds(*v.ScheduleEndTime)) 2575 } 2576 2577 if v.ScheduleExpression != nil { 2578 ok := object.Key("scheduleExpression") 2579 ok.String(*v.ScheduleExpression) 2580 } 2581 2582 if v.ScheduleStartTime != nil { 2583 ok := object.Key("scheduleStartTime") 2584 ok.Double(smithytime.FormatEpochSeconds(*v.ScheduleStartTime)) 2585 } 2586 2587 if v.Timezone != nil { 2588 ok := object.Key("timezone") 2589 ok.String(*v.Timezone) 2590 } 2591 2592 return nil 2593} 2594 2595func awsRestjson1_serializeDocumentServiceNowConnectorProfileCredentials(v *types.ServiceNowConnectorProfileCredentials, value smithyjson.Value) error { 2596 object := value.Object() 2597 defer object.Close() 2598 2599 if v.Password != nil { 2600 ok := object.Key("password") 2601 ok.String(*v.Password) 2602 } 2603 2604 if v.Username != nil { 2605 ok := object.Key("username") 2606 ok.String(*v.Username) 2607 } 2608 2609 return nil 2610} 2611 2612func awsRestjson1_serializeDocumentServiceNowConnectorProfileProperties(v *types.ServiceNowConnectorProfileProperties, value smithyjson.Value) error { 2613 object := value.Object() 2614 defer object.Close() 2615 2616 if v.InstanceUrl != nil { 2617 ok := object.Key("instanceUrl") 2618 ok.String(*v.InstanceUrl) 2619 } 2620 2621 return nil 2622} 2623 2624func awsRestjson1_serializeDocumentServiceNowSourceProperties(v *types.ServiceNowSourceProperties, value smithyjson.Value) error { 2625 object := value.Object() 2626 defer object.Close() 2627 2628 if v.Object != nil { 2629 ok := object.Key("object") 2630 ok.String(*v.Object) 2631 } 2632 2633 return nil 2634} 2635 2636func awsRestjson1_serializeDocumentSingularConnectorProfileCredentials(v *types.SingularConnectorProfileCredentials, value smithyjson.Value) error { 2637 object := value.Object() 2638 defer object.Close() 2639 2640 if v.ApiKey != nil { 2641 ok := object.Key("apiKey") 2642 ok.String(*v.ApiKey) 2643 } 2644 2645 return nil 2646} 2647 2648func awsRestjson1_serializeDocumentSingularConnectorProfileProperties(v *types.SingularConnectorProfileProperties, value smithyjson.Value) error { 2649 object := value.Object() 2650 defer object.Close() 2651 2652 return nil 2653} 2654 2655func awsRestjson1_serializeDocumentSingularSourceProperties(v *types.SingularSourceProperties, value smithyjson.Value) error { 2656 object := value.Object() 2657 defer object.Close() 2658 2659 if v.Object != nil { 2660 ok := object.Key("object") 2661 ok.String(*v.Object) 2662 } 2663 2664 return nil 2665} 2666 2667func awsRestjson1_serializeDocumentSlackConnectorProfileCredentials(v *types.SlackConnectorProfileCredentials, value smithyjson.Value) error { 2668 object := value.Object() 2669 defer object.Close() 2670 2671 if v.AccessToken != nil { 2672 ok := object.Key("accessToken") 2673 ok.String(*v.AccessToken) 2674 } 2675 2676 if v.ClientId != nil { 2677 ok := object.Key("clientId") 2678 ok.String(*v.ClientId) 2679 } 2680 2681 if v.ClientSecret != nil { 2682 ok := object.Key("clientSecret") 2683 ok.String(*v.ClientSecret) 2684 } 2685 2686 if v.OAuthRequest != nil { 2687 ok := object.Key("oAuthRequest") 2688 if err := awsRestjson1_serializeDocumentConnectorOAuthRequest(v.OAuthRequest, ok); err != nil { 2689 return err 2690 } 2691 } 2692 2693 return nil 2694} 2695 2696func awsRestjson1_serializeDocumentSlackConnectorProfileProperties(v *types.SlackConnectorProfileProperties, value smithyjson.Value) error { 2697 object := value.Object() 2698 defer object.Close() 2699 2700 if v.InstanceUrl != nil { 2701 ok := object.Key("instanceUrl") 2702 ok.String(*v.InstanceUrl) 2703 } 2704 2705 return nil 2706} 2707 2708func awsRestjson1_serializeDocumentSlackSourceProperties(v *types.SlackSourceProperties, value smithyjson.Value) error { 2709 object := value.Object() 2710 defer object.Close() 2711 2712 if v.Object != nil { 2713 ok := object.Key("object") 2714 ok.String(*v.Object) 2715 } 2716 2717 return nil 2718} 2719 2720func awsRestjson1_serializeDocumentSnowflakeConnectorProfileCredentials(v *types.SnowflakeConnectorProfileCredentials, value smithyjson.Value) error { 2721 object := value.Object() 2722 defer object.Close() 2723 2724 if v.Password != nil { 2725 ok := object.Key("password") 2726 ok.String(*v.Password) 2727 } 2728 2729 if v.Username != nil { 2730 ok := object.Key("username") 2731 ok.String(*v.Username) 2732 } 2733 2734 return nil 2735} 2736 2737func awsRestjson1_serializeDocumentSnowflakeConnectorProfileProperties(v *types.SnowflakeConnectorProfileProperties, value smithyjson.Value) error { 2738 object := value.Object() 2739 defer object.Close() 2740 2741 if v.AccountName != nil { 2742 ok := object.Key("accountName") 2743 ok.String(*v.AccountName) 2744 } 2745 2746 if v.BucketName != nil { 2747 ok := object.Key("bucketName") 2748 ok.String(*v.BucketName) 2749 } 2750 2751 if v.BucketPrefix != nil { 2752 ok := object.Key("bucketPrefix") 2753 ok.String(*v.BucketPrefix) 2754 } 2755 2756 if v.PrivateLinkServiceName != nil { 2757 ok := object.Key("privateLinkServiceName") 2758 ok.String(*v.PrivateLinkServiceName) 2759 } 2760 2761 if v.Region != nil { 2762 ok := object.Key("region") 2763 ok.String(*v.Region) 2764 } 2765 2766 if v.Stage != nil { 2767 ok := object.Key("stage") 2768 ok.String(*v.Stage) 2769 } 2770 2771 if v.Warehouse != nil { 2772 ok := object.Key("warehouse") 2773 ok.String(*v.Warehouse) 2774 } 2775 2776 return nil 2777} 2778 2779func awsRestjson1_serializeDocumentSnowflakeDestinationProperties(v *types.SnowflakeDestinationProperties, value smithyjson.Value) error { 2780 object := value.Object() 2781 defer object.Close() 2782 2783 if v.BucketPrefix != nil { 2784 ok := object.Key("bucketPrefix") 2785 ok.String(*v.BucketPrefix) 2786 } 2787 2788 if v.ErrorHandlingConfig != nil { 2789 ok := object.Key("errorHandlingConfig") 2790 if err := awsRestjson1_serializeDocumentErrorHandlingConfig(v.ErrorHandlingConfig, ok); err != nil { 2791 return err 2792 } 2793 } 2794 2795 if v.IntermediateBucketName != nil { 2796 ok := object.Key("intermediateBucketName") 2797 ok.String(*v.IntermediateBucketName) 2798 } 2799 2800 if v.Object != nil { 2801 ok := object.Key("object") 2802 ok.String(*v.Object) 2803 } 2804 2805 return nil 2806} 2807 2808func awsRestjson1_serializeDocumentSourceConnectorProperties(v *types.SourceConnectorProperties, value smithyjson.Value) error { 2809 object := value.Object() 2810 defer object.Close() 2811 2812 if v.Amplitude != nil { 2813 ok := object.Key("Amplitude") 2814 if err := awsRestjson1_serializeDocumentAmplitudeSourceProperties(v.Amplitude, ok); err != nil { 2815 return err 2816 } 2817 } 2818 2819 if v.Datadog != nil { 2820 ok := object.Key("Datadog") 2821 if err := awsRestjson1_serializeDocumentDatadogSourceProperties(v.Datadog, ok); err != nil { 2822 return err 2823 } 2824 } 2825 2826 if v.Dynatrace != nil { 2827 ok := object.Key("Dynatrace") 2828 if err := awsRestjson1_serializeDocumentDynatraceSourceProperties(v.Dynatrace, ok); err != nil { 2829 return err 2830 } 2831 } 2832 2833 if v.GoogleAnalytics != nil { 2834 ok := object.Key("GoogleAnalytics") 2835 if err := awsRestjson1_serializeDocumentGoogleAnalyticsSourceProperties(v.GoogleAnalytics, ok); err != nil { 2836 return err 2837 } 2838 } 2839 2840 if v.InforNexus != nil { 2841 ok := object.Key("InforNexus") 2842 if err := awsRestjson1_serializeDocumentInforNexusSourceProperties(v.InforNexus, ok); err != nil { 2843 return err 2844 } 2845 } 2846 2847 if v.Marketo != nil { 2848 ok := object.Key("Marketo") 2849 if err := awsRestjson1_serializeDocumentMarketoSourceProperties(v.Marketo, ok); err != nil { 2850 return err 2851 } 2852 } 2853 2854 if v.S3 != nil { 2855 ok := object.Key("S3") 2856 if err := awsRestjson1_serializeDocumentS3SourceProperties(v.S3, ok); err != nil { 2857 return err 2858 } 2859 } 2860 2861 if v.Salesforce != nil { 2862 ok := object.Key("Salesforce") 2863 if err := awsRestjson1_serializeDocumentSalesforceSourceProperties(v.Salesforce, ok); err != nil { 2864 return err 2865 } 2866 } 2867 2868 if v.ServiceNow != nil { 2869 ok := object.Key("ServiceNow") 2870 if err := awsRestjson1_serializeDocumentServiceNowSourceProperties(v.ServiceNow, ok); err != nil { 2871 return err 2872 } 2873 } 2874 2875 if v.Singular != nil { 2876 ok := object.Key("Singular") 2877 if err := awsRestjson1_serializeDocumentSingularSourceProperties(v.Singular, ok); err != nil { 2878 return err 2879 } 2880 } 2881 2882 if v.Slack != nil { 2883 ok := object.Key("Slack") 2884 if err := awsRestjson1_serializeDocumentSlackSourceProperties(v.Slack, ok); err != nil { 2885 return err 2886 } 2887 } 2888 2889 if v.Trendmicro != nil { 2890 ok := object.Key("Trendmicro") 2891 if err := awsRestjson1_serializeDocumentTrendmicroSourceProperties(v.Trendmicro, ok); err != nil { 2892 return err 2893 } 2894 } 2895 2896 if v.Veeva != nil { 2897 ok := object.Key("Veeva") 2898 if err := awsRestjson1_serializeDocumentVeevaSourceProperties(v.Veeva, ok); err != nil { 2899 return err 2900 } 2901 } 2902 2903 if v.Zendesk != nil { 2904 ok := object.Key("Zendesk") 2905 if err := awsRestjson1_serializeDocumentZendeskSourceProperties(v.Zendesk, ok); err != nil { 2906 return err 2907 } 2908 } 2909 2910 return nil 2911} 2912 2913func awsRestjson1_serializeDocumentSourceFields(v []string, value smithyjson.Value) error { 2914 array := value.Array() 2915 defer array.Close() 2916 2917 for i := range v { 2918 av := array.Value() 2919 av.String(v[i]) 2920 } 2921 return nil 2922} 2923 2924func awsRestjson1_serializeDocumentSourceFlowConfig(v *types.SourceFlowConfig, value smithyjson.Value) error { 2925 object := value.Object() 2926 defer object.Close() 2927 2928 if v.ConnectorProfileName != nil { 2929 ok := object.Key("connectorProfileName") 2930 ok.String(*v.ConnectorProfileName) 2931 } 2932 2933 if len(v.ConnectorType) > 0 { 2934 ok := object.Key("connectorType") 2935 ok.String(string(v.ConnectorType)) 2936 } 2937 2938 if v.IncrementalPullConfig != nil { 2939 ok := object.Key("incrementalPullConfig") 2940 if err := awsRestjson1_serializeDocumentIncrementalPullConfig(v.IncrementalPullConfig, ok); err != nil { 2941 return err 2942 } 2943 } 2944 2945 if v.SourceConnectorProperties != nil { 2946 ok := object.Key("sourceConnectorProperties") 2947 if err := awsRestjson1_serializeDocumentSourceConnectorProperties(v.SourceConnectorProperties, ok); err != nil { 2948 return err 2949 } 2950 } 2951 2952 return nil 2953} 2954 2955func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 2956 object := value.Object() 2957 defer object.Close() 2958 2959 for key := range v { 2960 om := object.Key(key) 2961 om.String(v[key]) 2962 } 2963 return nil 2964} 2965 2966func awsRestjson1_serializeDocumentTask(v *types.Task, value smithyjson.Value) error { 2967 object := value.Object() 2968 defer object.Close() 2969 2970 if v.ConnectorOperator != nil { 2971 ok := object.Key("connectorOperator") 2972 if err := awsRestjson1_serializeDocumentConnectorOperator(v.ConnectorOperator, ok); err != nil { 2973 return err 2974 } 2975 } 2976 2977 if v.DestinationField != nil { 2978 ok := object.Key("destinationField") 2979 ok.String(*v.DestinationField) 2980 } 2981 2982 if v.SourceFields != nil { 2983 ok := object.Key("sourceFields") 2984 if err := awsRestjson1_serializeDocumentSourceFields(v.SourceFields, ok); err != nil { 2985 return err 2986 } 2987 } 2988 2989 if v.TaskProperties != nil { 2990 ok := object.Key("taskProperties") 2991 if err := awsRestjson1_serializeDocumentTaskPropertiesMap(v.TaskProperties, ok); err != nil { 2992 return err 2993 } 2994 } 2995 2996 if len(v.TaskType) > 0 { 2997 ok := object.Key("taskType") 2998 ok.String(string(v.TaskType)) 2999 } 3000 3001 return nil 3002} 3003 3004func awsRestjson1_serializeDocumentTaskPropertiesMap(v map[string]string, value smithyjson.Value) error { 3005 object := value.Object() 3006 defer object.Close() 3007 3008 for key := range v { 3009 om := object.Key(key) 3010 om.String(v[key]) 3011 } 3012 return nil 3013} 3014 3015func awsRestjson1_serializeDocumentTasks(v []types.Task, value smithyjson.Value) error { 3016 array := value.Array() 3017 defer array.Close() 3018 3019 for i := range v { 3020 av := array.Value() 3021 if err := awsRestjson1_serializeDocumentTask(&v[i], av); err != nil { 3022 return err 3023 } 3024 } 3025 return nil 3026} 3027 3028func awsRestjson1_serializeDocumentTrendmicroConnectorProfileCredentials(v *types.TrendmicroConnectorProfileCredentials, value smithyjson.Value) error { 3029 object := value.Object() 3030 defer object.Close() 3031 3032 if v.ApiSecretKey != nil { 3033 ok := object.Key("apiSecretKey") 3034 ok.String(*v.ApiSecretKey) 3035 } 3036 3037 return nil 3038} 3039 3040func awsRestjson1_serializeDocumentTrendmicroConnectorProfileProperties(v *types.TrendmicroConnectorProfileProperties, value smithyjson.Value) error { 3041 object := value.Object() 3042 defer object.Close() 3043 3044 return nil 3045} 3046 3047func awsRestjson1_serializeDocumentTrendmicroSourceProperties(v *types.TrendmicroSourceProperties, value smithyjson.Value) error { 3048 object := value.Object() 3049 defer object.Close() 3050 3051 if v.Object != nil { 3052 ok := object.Key("object") 3053 ok.String(*v.Object) 3054 } 3055 3056 return nil 3057} 3058 3059func awsRestjson1_serializeDocumentTriggerConfig(v *types.TriggerConfig, value smithyjson.Value) error { 3060 object := value.Object() 3061 defer object.Close() 3062 3063 if v.TriggerProperties != nil { 3064 ok := object.Key("triggerProperties") 3065 if err := awsRestjson1_serializeDocumentTriggerProperties(v.TriggerProperties, ok); err != nil { 3066 return err 3067 } 3068 } 3069 3070 if len(v.TriggerType) > 0 { 3071 ok := object.Key("triggerType") 3072 ok.String(string(v.TriggerType)) 3073 } 3074 3075 return nil 3076} 3077 3078func awsRestjson1_serializeDocumentTriggerProperties(v *types.TriggerProperties, value smithyjson.Value) error { 3079 object := value.Object() 3080 defer object.Close() 3081 3082 if v.Scheduled != nil { 3083 ok := object.Key("Scheduled") 3084 if err := awsRestjson1_serializeDocumentScheduledTriggerProperties(v.Scheduled, ok); err != nil { 3085 return err 3086 } 3087 } 3088 3089 return nil 3090} 3091 3092func awsRestjson1_serializeDocumentUpsolverDestinationProperties(v *types.UpsolverDestinationProperties, value smithyjson.Value) error { 3093 object := value.Object() 3094 defer object.Close() 3095 3096 if v.BucketName != nil { 3097 ok := object.Key("bucketName") 3098 ok.String(*v.BucketName) 3099 } 3100 3101 if v.BucketPrefix != nil { 3102 ok := object.Key("bucketPrefix") 3103 ok.String(*v.BucketPrefix) 3104 } 3105 3106 if v.S3OutputFormatConfig != nil { 3107 ok := object.Key("s3OutputFormatConfig") 3108 if err := awsRestjson1_serializeDocumentUpsolverS3OutputFormatConfig(v.S3OutputFormatConfig, ok); err != nil { 3109 return err 3110 } 3111 } 3112 3113 return nil 3114} 3115 3116func awsRestjson1_serializeDocumentUpsolverS3OutputFormatConfig(v *types.UpsolverS3OutputFormatConfig, value smithyjson.Value) error { 3117 object := value.Object() 3118 defer object.Close() 3119 3120 if v.AggregationConfig != nil { 3121 ok := object.Key("aggregationConfig") 3122 if err := awsRestjson1_serializeDocumentAggregationConfig(v.AggregationConfig, ok); err != nil { 3123 return err 3124 } 3125 } 3126 3127 if len(v.FileType) > 0 { 3128 ok := object.Key("fileType") 3129 ok.String(string(v.FileType)) 3130 } 3131 3132 if v.PrefixConfig != nil { 3133 ok := object.Key("prefixConfig") 3134 if err := awsRestjson1_serializeDocumentPrefixConfig(v.PrefixConfig, ok); err != nil { 3135 return err 3136 } 3137 } 3138 3139 return nil 3140} 3141 3142func awsRestjson1_serializeDocumentVeevaConnectorProfileCredentials(v *types.VeevaConnectorProfileCredentials, value smithyjson.Value) error { 3143 object := value.Object() 3144 defer object.Close() 3145 3146 if v.Password != nil { 3147 ok := object.Key("password") 3148 ok.String(*v.Password) 3149 } 3150 3151 if v.Username != nil { 3152 ok := object.Key("username") 3153 ok.String(*v.Username) 3154 } 3155 3156 return nil 3157} 3158 3159func awsRestjson1_serializeDocumentVeevaConnectorProfileProperties(v *types.VeevaConnectorProfileProperties, value smithyjson.Value) error { 3160 object := value.Object() 3161 defer object.Close() 3162 3163 if v.InstanceUrl != nil { 3164 ok := object.Key("instanceUrl") 3165 ok.String(*v.InstanceUrl) 3166 } 3167 3168 return nil 3169} 3170 3171func awsRestjson1_serializeDocumentVeevaSourceProperties(v *types.VeevaSourceProperties, value smithyjson.Value) error { 3172 object := value.Object() 3173 defer object.Close() 3174 3175 if v.Object != nil { 3176 ok := object.Key("object") 3177 ok.String(*v.Object) 3178 } 3179 3180 return nil 3181} 3182 3183func awsRestjson1_serializeDocumentZendeskConnectorProfileCredentials(v *types.ZendeskConnectorProfileCredentials, value smithyjson.Value) error { 3184 object := value.Object() 3185 defer object.Close() 3186 3187 if v.AccessToken != nil { 3188 ok := object.Key("accessToken") 3189 ok.String(*v.AccessToken) 3190 } 3191 3192 if v.ClientId != nil { 3193 ok := object.Key("clientId") 3194 ok.String(*v.ClientId) 3195 } 3196 3197 if v.ClientSecret != nil { 3198 ok := object.Key("clientSecret") 3199 ok.String(*v.ClientSecret) 3200 } 3201 3202 if v.OAuthRequest != nil { 3203 ok := object.Key("oAuthRequest") 3204 if err := awsRestjson1_serializeDocumentConnectorOAuthRequest(v.OAuthRequest, ok); err != nil { 3205 return err 3206 } 3207 } 3208 3209 return nil 3210} 3211 3212func awsRestjson1_serializeDocumentZendeskConnectorProfileProperties(v *types.ZendeskConnectorProfileProperties, value smithyjson.Value) error { 3213 object := value.Object() 3214 defer object.Close() 3215 3216 if v.InstanceUrl != nil { 3217 ok := object.Key("instanceUrl") 3218 ok.String(*v.InstanceUrl) 3219 } 3220 3221 return nil 3222} 3223 3224func awsRestjson1_serializeDocumentZendeskSourceProperties(v *types.ZendeskSourceProperties, value smithyjson.Value) error { 3225 object := value.Object() 3226 defer object.Close() 3227 3228 if v.Object != nil { 3229 ok := object.Key("object") 3230 ok.String(*v.Object) 3231 } 3232 3233 return nil 3234} 3235