1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package quicksight 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/quicksight/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 "time" 17) 18 19type awsRestjson1_serializeOpCancelIngestion struct { 20} 21 22func (*awsRestjson1_serializeOpCancelIngestion) ID() string { 23 return "OperationSerializer" 24} 25 26func (m *awsRestjson1_serializeOpCancelIngestion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 27 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 28) { 29 request, ok := in.Request.(*smithyhttp.Request) 30 if !ok { 31 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 32 } 33 34 input, ok := in.Parameters.(*CancelIngestionInput) 35 _ = input 36 if !ok { 37 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 38 } 39 40 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}") 41 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 42 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 43 request.Method = "DELETE" 44 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 45 if err != nil { 46 return out, metadata, &smithy.SerializationError{Err: err} 47 } 48 49 if err := awsRestjson1_serializeOpHttpBindingsCancelIngestionInput(input, restEncoder); err != nil { 50 return out, metadata, &smithy.SerializationError{Err: err} 51 } 52 53 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 54 return out, metadata, &smithy.SerializationError{Err: err} 55 } 56 in.Request = request 57 58 return next.HandleSerialize(ctx, in) 59} 60func awsRestjson1_serializeOpHttpBindingsCancelIngestionInput(v *CancelIngestionInput, encoder *httpbinding.Encoder) error { 61 if v == nil { 62 return fmt.Errorf("unsupported serialization of nil %T", v) 63 } 64 65 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 66 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 67 } 68 if v.AwsAccountId != nil { 69 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 70 return err 71 } 72 } 73 74 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 75 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 76 } 77 if v.DataSetId != nil { 78 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 79 return err 80 } 81 } 82 83 if v.IngestionId == nil || len(*v.IngestionId) == 0 { 84 return &smithy.SerializationError{Err: fmt.Errorf("input member IngestionId must not be empty")} 85 } 86 if v.IngestionId != nil { 87 if err := encoder.SetURI("IngestionId").String(*v.IngestionId); err != nil { 88 return err 89 } 90 } 91 92 return nil 93} 94 95type awsRestjson1_serializeOpCreateAccountCustomization struct { 96} 97 98func (*awsRestjson1_serializeOpCreateAccountCustomization) ID() string { 99 return "OperationSerializer" 100} 101 102func (m *awsRestjson1_serializeOpCreateAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 103 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 104) { 105 request, ok := in.Request.(*smithyhttp.Request) 106 if !ok { 107 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 108 } 109 110 input, ok := in.Parameters.(*CreateAccountCustomizationInput) 111 _ = input 112 if !ok { 113 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 114 } 115 116 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations") 117 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 118 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 119 request.Method = "POST" 120 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 121 if err != nil { 122 return out, metadata, &smithy.SerializationError{Err: err} 123 } 124 125 if err := awsRestjson1_serializeOpHttpBindingsCreateAccountCustomizationInput(input, restEncoder); err != nil { 126 return out, metadata, &smithy.SerializationError{Err: err} 127 } 128 129 restEncoder.SetHeader("Content-Type").String("application/json") 130 131 jsonEncoder := smithyjson.NewEncoder() 132 if err := awsRestjson1_serializeOpDocumentCreateAccountCustomizationInput(input, jsonEncoder.Value); err != nil { 133 return out, metadata, &smithy.SerializationError{Err: err} 134 } 135 136 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 137 return out, metadata, &smithy.SerializationError{Err: err} 138 } 139 140 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 141 return out, metadata, &smithy.SerializationError{Err: err} 142 } 143 in.Request = request 144 145 return next.HandleSerialize(ctx, in) 146} 147func awsRestjson1_serializeOpHttpBindingsCreateAccountCustomizationInput(v *CreateAccountCustomizationInput, encoder *httpbinding.Encoder) error { 148 if v == nil { 149 return fmt.Errorf("unsupported serialization of nil %T", v) 150 } 151 152 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 153 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 154 } 155 if v.AwsAccountId != nil { 156 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 157 return err 158 } 159 } 160 161 if v.Namespace != nil { 162 encoder.SetQuery("namespace").String(*v.Namespace) 163 } 164 165 return nil 166} 167 168func awsRestjson1_serializeOpDocumentCreateAccountCustomizationInput(v *CreateAccountCustomizationInput, value smithyjson.Value) error { 169 object := value.Object() 170 defer object.Close() 171 172 if v.AccountCustomization != nil { 173 ok := object.Key("AccountCustomization") 174 if err := awsRestjson1_serializeDocumentAccountCustomization(v.AccountCustomization, ok); err != nil { 175 return err 176 } 177 } 178 179 if v.Tags != nil { 180 ok := object.Key("Tags") 181 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 182 return err 183 } 184 } 185 186 return nil 187} 188 189type awsRestjson1_serializeOpCreateAnalysis struct { 190} 191 192func (*awsRestjson1_serializeOpCreateAnalysis) ID() string { 193 return "OperationSerializer" 194} 195 196func (m *awsRestjson1_serializeOpCreateAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 197 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 198) { 199 request, ok := in.Request.(*smithyhttp.Request) 200 if !ok { 201 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 202 } 203 204 input, ok := in.Parameters.(*CreateAnalysisInput) 205 _ = input 206 if !ok { 207 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 208 } 209 210 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}") 211 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 212 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 213 request.Method = "POST" 214 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 215 if err != nil { 216 return out, metadata, &smithy.SerializationError{Err: err} 217 } 218 219 if err := awsRestjson1_serializeOpHttpBindingsCreateAnalysisInput(input, restEncoder); err != nil { 220 return out, metadata, &smithy.SerializationError{Err: err} 221 } 222 223 restEncoder.SetHeader("Content-Type").String("application/json") 224 225 jsonEncoder := smithyjson.NewEncoder() 226 if err := awsRestjson1_serializeOpDocumentCreateAnalysisInput(input, jsonEncoder.Value); err != nil { 227 return out, metadata, &smithy.SerializationError{Err: err} 228 } 229 230 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 231 return out, metadata, &smithy.SerializationError{Err: err} 232 } 233 234 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 235 return out, metadata, &smithy.SerializationError{Err: err} 236 } 237 in.Request = request 238 239 return next.HandleSerialize(ctx, in) 240} 241func awsRestjson1_serializeOpHttpBindingsCreateAnalysisInput(v *CreateAnalysisInput, encoder *httpbinding.Encoder) error { 242 if v == nil { 243 return fmt.Errorf("unsupported serialization of nil %T", v) 244 } 245 246 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 247 return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")} 248 } 249 if v.AnalysisId != nil { 250 if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil { 251 return err 252 } 253 } 254 255 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 256 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 257 } 258 if v.AwsAccountId != nil { 259 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 260 return err 261 } 262 } 263 264 return nil 265} 266 267func awsRestjson1_serializeOpDocumentCreateAnalysisInput(v *CreateAnalysisInput, value smithyjson.Value) error { 268 object := value.Object() 269 defer object.Close() 270 271 if v.Name != nil { 272 ok := object.Key("Name") 273 ok.String(*v.Name) 274 } 275 276 if v.Parameters != nil { 277 ok := object.Key("Parameters") 278 if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil { 279 return err 280 } 281 } 282 283 if v.Permissions != nil { 284 ok := object.Key("Permissions") 285 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil { 286 return err 287 } 288 } 289 290 if v.SourceEntity != nil { 291 ok := object.Key("SourceEntity") 292 if err := awsRestjson1_serializeDocumentAnalysisSourceEntity(v.SourceEntity, ok); err != nil { 293 return err 294 } 295 } 296 297 if v.Tags != nil { 298 ok := object.Key("Tags") 299 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 300 return err 301 } 302 } 303 304 if v.ThemeArn != nil { 305 ok := object.Key("ThemeArn") 306 ok.String(*v.ThemeArn) 307 } 308 309 return nil 310} 311 312type awsRestjson1_serializeOpCreateDashboard struct { 313} 314 315func (*awsRestjson1_serializeOpCreateDashboard) ID() string { 316 return "OperationSerializer" 317} 318 319func (m *awsRestjson1_serializeOpCreateDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 320 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 321) { 322 request, ok := in.Request.(*smithyhttp.Request) 323 if !ok { 324 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 325 } 326 327 input, ok := in.Parameters.(*CreateDashboardInput) 328 _ = input 329 if !ok { 330 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 331 } 332 333 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}") 334 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 335 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 336 request.Method = "POST" 337 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 338 if err != nil { 339 return out, metadata, &smithy.SerializationError{Err: err} 340 } 341 342 if err := awsRestjson1_serializeOpHttpBindingsCreateDashboardInput(input, restEncoder); err != nil { 343 return out, metadata, &smithy.SerializationError{Err: err} 344 } 345 346 restEncoder.SetHeader("Content-Type").String("application/json") 347 348 jsonEncoder := smithyjson.NewEncoder() 349 if err := awsRestjson1_serializeOpDocumentCreateDashboardInput(input, jsonEncoder.Value); err != nil { 350 return out, metadata, &smithy.SerializationError{Err: err} 351 } 352 353 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 354 return out, metadata, &smithy.SerializationError{Err: err} 355 } 356 357 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 358 return out, metadata, &smithy.SerializationError{Err: err} 359 } 360 in.Request = request 361 362 return next.HandleSerialize(ctx, in) 363} 364func awsRestjson1_serializeOpHttpBindingsCreateDashboardInput(v *CreateDashboardInput, encoder *httpbinding.Encoder) error { 365 if v == nil { 366 return fmt.Errorf("unsupported serialization of nil %T", v) 367 } 368 369 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 370 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 371 } 372 if v.AwsAccountId != nil { 373 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 374 return err 375 } 376 } 377 378 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 379 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 380 } 381 if v.DashboardId != nil { 382 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 383 return err 384 } 385 } 386 387 return nil 388} 389 390func awsRestjson1_serializeOpDocumentCreateDashboardInput(v *CreateDashboardInput, value smithyjson.Value) error { 391 object := value.Object() 392 defer object.Close() 393 394 if v.DashboardPublishOptions != nil { 395 ok := object.Key("DashboardPublishOptions") 396 if err := awsRestjson1_serializeDocumentDashboardPublishOptions(v.DashboardPublishOptions, ok); err != nil { 397 return err 398 } 399 } 400 401 if v.Name != nil { 402 ok := object.Key("Name") 403 ok.String(*v.Name) 404 } 405 406 if v.Parameters != nil { 407 ok := object.Key("Parameters") 408 if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil { 409 return err 410 } 411 } 412 413 if v.Permissions != nil { 414 ok := object.Key("Permissions") 415 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil { 416 return err 417 } 418 } 419 420 if v.SourceEntity != nil { 421 ok := object.Key("SourceEntity") 422 if err := awsRestjson1_serializeDocumentDashboardSourceEntity(v.SourceEntity, ok); err != nil { 423 return err 424 } 425 } 426 427 if v.Tags != nil { 428 ok := object.Key("Tags") 429 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 430 return err 431 } 432 } 433 434 if v.ThemeArn != nil { 435 ok := object.Key("ThemeArn") 436 ok.String(*v.ThemeArn) 437 } 438 439 if v.VersionDescription != nil { 440 ok := object.Key("VersionDescription") 441 ok.String(*v.VersionDescription) 442 } 443 444 return nil 445} 446 447type awsRestjson1_serializeOpCreateDataSet struct { 448} 449 450func (*awsRestjson1_serializeOpCreateDataSet) ID() string { 451 return "OperationSerializer" 452} 453 454func (m *awsRestjson1_serializeOpCreateDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 455 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 456) { 457 request, ok := in.Request.(*smithyhttp.Request) 458 if !ok { 459 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 460 } 461 462 input, ok := in.Parameters.(*CreateDataSetInput) 463 _ = input 464 if !ok { 465 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 466 } 467 468 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets") 469 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 470 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 471 request.Method = "POST" 472 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 473 if err != nil { 474 return out, metadata, &smithy.SerializationError{Err: err} 475 } 476 477 if err := awsRestjson1_serializeOpHttpBindingsCreateDataSetInput(input, restEncoder); err != nil { 478 return out, metadata, &smithy.SerializationError{Err: err} 479 } 480 481 restEncoder.SetHeader("Content-Type").String("application/json") 482 483 jsonEncoder := smithyjson.NewEncoder() 484 if err := awsRestjson1_serializeOpDocumentCreateDataSetInput(input, jsonEncoder.Value); err != nil { 485 return out, metadata, &smithy.SerializationError{Err: err} 486 } 487 488 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 489 return out, metadata, &smithy.SerializationError{Err: err} 490 } 491 492 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 493 return out, metadata, &smithy.SerializationError{Err: err} 494 } 495 in.Request = request 496 497 return next.HandleSerialize(ctx, in) 498} 499func awsRestjson1_serializeOpHttpBindingsCreateDataSetInput(v *CreateDataSetInput, encoder *httpbinding.Encoder) error { 500 if v == nil { 501 return fmt.Errorf("unsupported serialization of nil %T", v) 502 } 503 504 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 505 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 506 } 507 if v.AwsAccountId != nil { 508 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 509 return err 510 } 511 } 512 513 return nil 514} 515 516func awsRestjson1_serializeOpDocumentCreateDataSetInput(v *CreateDataSetInput, value smithyjson.Value) error { 517 object := value.Object() 518 defer object.Close() 519 520 if v.ColumnGroups != nil { 521 ok := object.Key("ColumnGroups") 522 if err := awsRestjson1_serializeDocumentColumnGroupList(v.ColumnGroups, ok); err != nil { 523 return err 524 } 525 } 526 527 if v.ColumnLevelPermissionRules != nil { 528 ok := object.Key("ColumnLevelPermissionRules") 529 if err := awsRestjson1_serializeDocumentColumnLevelPermissionRuleList(v.ColumnLevelPermissionRules, ok); err != nil { 530 return err 531 } 532 } 533 534 if v.DataSetId != nil { 535 ok := object.Key("DataSetId") 536 ok.String(*v.DataSetId) 537 } 538 539 if v.FieldFolders != nil { 540 ok := object.Key("FieldFolders") 541 if err := awsRestjson1_serializeDocumentFieldFolderMap(v.FieldFolders, ok); err != nil { 542 return err 543 } 544 } 545 546 if len(v.ImportMode) > 0 { 547 ok := object.Key("ImportMode") 548 ok.String(string(v.ImportMode)) 549 } 550 551 if v.LogicalTableMap != nil { 552 ok := object.Key("LogicalTableMap") 553 if err := awsRestjson1_serializeDocumentLogicalTableMap(v.LogicalTableMap, ok); err != nil { 554 return err 555 } 556 } 557 558 if v.Name != nil { 559 ok := object.Key("Name") 560 ok.String(*v.Name) 561 } 562 563 if v.Permissions != nil { 564 ok := object.Key("Permissions") 565 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil { 566 return err 567 } 568 } 569 570 if v.PhysicalTableMap != nil { 571 ok := object.Key("PhysicalTableMap") 572 if err := awsRestjson1_serializeDocumentPhysicalTableMap(v.PhysicalTableMap, ok); err != nil { 573 return err 574 } 575 } 576 577 if v.RowLevelPermissionDataSet != nil { 578 ok := object.Key("RowLevelPermissionDataSet") 579 if err := awsRestjson1_serializeDocumentRowLevelPermissionDataSet(v.RowLevelPermissionDataSet, ok); err != nil { 580 return err 581 } 582 } 583 584 if v.Tags != nil { 585 ok := object.Key("Tags") 586 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 587 return err 588 } 589 } 590 591 return nil 592} 593 594type awsRestjson1_serializeOpCreateDataSource struct { 595} 596 597func (*awsRestjson1_serializeOpCreateDataSource) ID() string { 598 return "OperationSerializer" 599} 600 601func (m *awsRestjson1_serializeOpCreateDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 602 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 603) { 604 request, ok := in.Request.(*smithyhttp.Request) 605 if !ok { 606 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 607 } 608 609 input, ok := in.Parameters.(*CreateDataSourceInput) 610 _ = input 611 if !ok { 612 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 613 } 614 615 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources") 616 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 617 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 618 request.Method = "POST" 619 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 620 if err != nil { 621 return out, metadata, &smithy.SerializationError{Err: err} 622 } 623 624 if err := awsRestjson1_serializeOpHttpBindingsCreateDataSourceInput(input, restEncoder); err != nil { 625 return out, metadata, &smithy.SerializationError{Err: err} 626 } 627 628 restEncoder.SetHeader("Content-Type").String("application/json") 629 630 jsonEncoder := smithyjson.NewEncoder() 631 if err := awsRestjson1_serializeOpDocumentCreateDataSourceInput(input, jsonEncoder.Value); err != nil { 632 return out, metadata, &smithy.SerializationError{Err: err} 633 } 634 635 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 636 return out, metadata, &smithy.SerializationError{Err: err} 637 } 638 639 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 640 return out, metadata, &smithy.SerializationError{Err: err} 641 } 642 in.Request = request 643 644 return next.HandleSerialize(ctx, in) 645} 646func awsRestjson1_serializeOpHttpBindingsCreateDataSourceInput(v *CreateDataSourceInput, encoder *httpbinding.Encoder) error { 647 if v == nil { 648 return fmt.Errorf("unsupported serialization of nil %T", v) 649 } 650 651 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 652 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 653 } 654 if v.AwsAccountId != nil { 655 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 656 return err 657 } 658 } 659 660 return nil 661} 662 663func awsRestjson1_serializeOpDocumentCreateDataSourceInput(v *CreateDataSourceInput, value smithyjson.Value) error { 664 object := value.Object() 665 defer object.Close() 666 667 if v.Credentials != nil { 668 ok := object.Key("Credentials") 669 if err := awsRestjson1_serializeDocumentDataSourceCredentials(v.Credentials, ok); err != nil { 670 return err 671 } 672 } 673 674 if v.DataSourceId != nil { 675 ok := object.Key("DataSourceId") 676 ok.String(*v.DataSourceId) 677 } 678 679 if v.DataSourceParameters != nil { 680 ok := object.Key("DataSourceParameters") 681 if err := awsRestjson1_serializeDocumentDataSourceParameters(v.DataSourceParameters, ok); err != nil { 682 return err 683 } 684 } 685 686 if v.Name != nil { 687 ok := object.Key("Name") 688 ok.String(*v.Name) 689 } 690 691 if v.Permissions != nil { 692 ok := object.Key("Permissions") 693 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil { 694 return err 695 } 696 } 697 698 if v.SslProperties != nil { 699 ok := object.Key("SslProperties") 700 if err := awsRestjson1_serializeDocumentSslProperties(v.SslProperties, ok); err != nil { 701 return err 702 } 703 } 704 705 if v.Tags != nil { 706 ok := object.Key("Tags") 707 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 708 return err 709 } 710 } 711 712 if len(v.Type) > 0 { 713 ok := object.Key("Type") 714 ok.String(string(v.Type)) 715 } 716 717 if v.VpcConnectionProperties != nil { 718 ok := object.Key("VpcConnectionProperties") 719 if err := awsRestjson1_serializeDocumentVpcConnectionProperties(v.VpcConnectionProperties, ok); err != nil { 720 return err 721 } 722 } 723 724 return nil 725} 726 727type awsRestjson1_serializeOpCreateGroup struct { 728} 729 730func (*awsRestjson1_serializeOpCreateGroup) ID() string { 731 return "OperationSerializer" 732} 733 734func (m *awsRestjson1_serializeOpCreateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 735 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 736) { 737 request, ok := in.Request.(*smithyhttp.Request) 738 if !ok { 739 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 740 } 741 742 input, ok := in.Parameters.(*CreateGroupInput) 743 _ = input 744 if !ok { 745 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 746 } 747 748 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups") 749 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 750 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 751 request.Method = "POST" 752 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 753 if err != nil { 754 return out, metadata, &smithy.SerializationError{Err: err} 755 } 756 757 if err := awsRestjson1_serializeOpHttpBindingsCreateGroupInput(input, restEncoder); err != nil { 758 return out, metadata, &smithy.SerializationError{Err: err} 759 } 760 761 restEncoder.SetHeader("Content-Type").String("application/json") 762 763 jsonEncoder := smithyjson.NewEncoder() 764 if err := awsRestjson1_serializeOpDocumentCreateGroupInput(input, jsonEncoder.Value); err != nil { 765 return out, metadata, &smithy.SerializationError{Err: err} 766 } 767 768 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 769 return out, metadata, &smithy.SerializationError{Err: err} 770 } 771 772 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 773 return out, metadata, &smithy.SerializationError{Err: err} 774 } 775 in.Request = request 776 777 return next.HandleSerialize(ctx, in) 778} 779func awsRestjson1_serializeOpHttpBindingsCreateGroupInput(v *CreateGroupInput, encoder *httpbinding.Encoder) error { 780 if v == nil { 781 return fmt.Errorf("unsupported serialization of nil %T", v) 782 } 783 784 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 785 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 786 } 787 if v.AwsAccountId != nil { 788 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 789 return err 790 } 791 } 792 793 if v.Namespace == nil || len(*v.Namespace) == 0 { 794 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 795 } 796 if v.Namespace != nil { 797 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 798 return err 799 } 800 } 801 802 return nil 803} 804 805func awsRestjson1_serializeOpDocumentCreateGroupInput(v *CreateGroupInput, value smithyjson.Value) error { 806 object := value.Object() 807 defer object.Close() 808 809 if v.Description != nil { 810 ok := object.Key("Description") 811 ok.String(*v.Description) 812 } 813 814 if v.GroupName != nil { 815 ok := object.Key("GroupName") 816 ok.String(*v.GroupName) 817 } 818 819 return nil 820} 821 822type awsRestjson1_serializeOpCreateGroupMembership struct { 823} 824 825func (*awsRestjson1_serializeOpCreateGroupMembership) ID() string { 826 return "OperationSerializer" 827} 828 829func (m *awsRestjson1_serializeOpCreateGroupMembership) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 830 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 831) { 832 request, ok := in.Request.(*smithyhttp.Request) 833 if !ok { 834 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 835 } 836 837 input, ok := in.Parameters.(*CreateGroupMembershipInput) 838 _ = input 839 if !ok { 840 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 841 } 842 843 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members/{MemberName}") 844 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 845 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 846 request.Method = "PUT" 847 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 848 if err != nil { 849 return out, metadata, &smithy.SerializationError{Err: err} 850 } 851 852 if err := awsRestjson1_serializeOpHttpBindingsCreateGroupMembershipInput(input, restEncoder); err != nil { 853 return out, metadata, &smithy.SerializationError{Err: err} 854 } 855 856 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 857 return out, metadata, &smithy.SerializationError{Err: err} 858 } 859 in.Request = request 860 861 return next.HandleSerialize(ctx, in) 862} 863func awsRestjson1_serializeOpHttpBindingsCreateGroupMembershipInput(v *CreateGroupMembershipInput, encoder *httpbinding.Encoder) error { 864 if v == nil { 865 return fmt.Errorf("unsupported serialization of nil %T", v) 866 } 867 868 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 869 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 870 } 871 if v.AwsAccountId != nil { 872 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 873 return err 874 } 875 } 876 877 if v.GroupName == nil || len(*v.GroupName) == 0 { 878 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")} 879 } 880 if v.GroupName != nil { 881 if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil { 882 return err 883 } 884 } 885 886 if v.MemberName == nil || len(*v.MemberName) == 0 { 887 return &smithy.SerializationError{Err: fmt.Errorf("input member MemberName must not be empty")} 888 } 889 if v.MemberName != nil { 890 if err := encoder.SetURI("MemberName").String(*v.MemberName); err != nil { 891 return err 892 } 893 } 894 895 if v.Namespace == nil || len(*v.Namespace) == 0 { 896 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 897 } 898 if v.Namespace != nil { 899 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 900 return err 901 } 902 } 903 904 return nil 905} 906 907type awsRestjson1_serializeOpCreateIAMPolicyAssignment struct { 908} 909 910func (*awsRestjson1_serializeOpCreateIAMPolicyAssignment) ID() string { 911 return "OperationSerializer" 912} 913 914func (m *awsRestjson1_serializeOpCreateIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 915 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 916) { 917 request, ok := in.Request.(*smithyhttp.Request) 918 if !ok { 919 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 920 } 921 922 input, ok := in.Parameters.(*CreateIAMPolicyAssignmentInput) 923 _ = input 924 if !ok { 925 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 926 } 927 928 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments") 929 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 930 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 931 request.Method = "POST" 932 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 933 if err != nil { 934 return out, metadata, &smithy.SerializationError{Err: err} 935 } 936 937 if err := awsRestjson1_serializeOpHttpBindingsCreateIAMPolicyAssignmentInput(input, restEncoder); err != nil { 938 return out, metadata, &smithy.SerializationError{Err: err} 939 } 940 941 restEncoder.SetHeader("Content-Type").String("application/json") 942 943 jsonEncoder := smithyjson.NewEncoder() 944 if err := awsRestjson1_serializeOpDocumentCreateIAMPolicyAssignmentInput(input, jsonEncoder.Value); err != nil { 945 return out, metadata, &smithy.SerializationError{Err: err} 946 } 947 948 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 949 return out, metadata, &smithy.SerializationError{Err: err} 950 } 951 952 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 953 return out, metadata, &smithy.SerializationError{Err: err} 954 } 955 in.Request = request 956 957 return next.HandleSerialize(ctx, in) 958} 959func awsRestjson1_serializeOpHttpBindingsCreateIAMPolicyAssignmentInput(v *CreateIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error { 960 if v == nil { 961 return fmt.Errorf("unsupported serialization of nil %T", v) 962 } 963 964 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 965 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 966 } 967 if v.AwsAccountId != nil { 968 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 969 return err 970 } 971 } 972 973 if v.Namespace == nil || len(*v.Namespace) == 0 { 974 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 975 } 976 if v.Namespace != nil { 977 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 978 return err 979 } 980 } 981 982 return nil 983} 984 985func awsRestjson1_serializeOpDocumentCreateIAMPolicyAssignmentInput(v *CreateIAMPolicyAssignmentInput, value smithyjson.Value) error { 986 object := value.Object() 987 defer object.Close() 988 989 if v.AssignmentName != nil { 990 ok := object.Key("AssignmentName") 991 ok.String(*v.AssignmentName) 992 } 993 994 if len(v.AssignmentStatus) > 0 { 995 ok := object.Key("AssignmentStatus") 996 ok.String(string(v.AssignmentStatus)) 997 } 998 999 if v.Identities != nil { 1000 ok := object.Key("Identities") 1001 if err := awsRestjson1_serializeDocumentIdentityMap(v.Identities, ok); err != nil { 1002 return err 1003 } 1004 } 1005 1006 if v.PolicyArn != nil { 1007 ok := object.Key("PolicyArn") 1008 ok.String(*v.PolicyArn) 1009 } 1010 1011 return nil 1012} 1013 1014type awsRestjson1_serializeOpCreateIngestion struct { 1015} 1016 1017func (*awsRestjson1_serializeOpCreateIngestion) ID() string { 1018 return "OperationSerializer" 1019} 1020 1021func (m *awsRestjson1_serializeOpCreateIngestion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1022 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1023) { 1024 request, ok := in.Request.(*smithyhttp.Request) 1025 if !ok { 1026 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1027 } 1028 1029 input, ok := in.Parameters.(*CreateIngestionInput) 1030 _ = input 1031 if !ok { 1032 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1033 } 1034 1035 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}") 1036 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1037 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1038 request.Method = "PUT" 1039 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1040 if err != nil { 1041 return out, metadata, &smithy.SerializationError{Err: err} 1042 } 1043 1044 if err := awsRestjson1_serializeOpHttpBindingsCreateIngestionInput(input, restEncoder); err != nil { 1045 return out, metadata, &smithy.SerializationError{Err: err} 1046 } 1047 1048 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1049 return out, metadata, &smithy.SerializationError{Err: err} 1050 } 1051 in.Request = request 1052 1053 return next.HandleSerialize(ctx, in) 1054} 1055func awsRestjson1_serializeOpHttpBindingsCreateIngestionInput(v *CreateIngestionInput, encoder *httpbinding.Encoder) error { 1056 if v == nil { 1057 return fmt.Errorf("unsupported serialization of nil %T", v) 1058 } 1059 1060 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1061 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1062 } 1063 if v.AwsAccountId != nil { 1064 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1065 return err 1066 } 1067 } 1068 1069 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 1070 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 1071 } 1072 if v.DataSetId != nil { 1073 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 1074 return err 1075 } 1076 } 1077 1078 if v.IngestionId == nil || len(*v.IngestionId) == 0 { 1079 return &smithy.SerializationError{Err: fmt.Errorf("input member IngestionId must not be empty")} 1080 } 1081 if v.IngestionId != nil { 1082 if err := encoder.SetURI("IngestionId").String(*v.IngestionId); err != nil { 1083 return err 1084 } 1085 } 1086 1087 return nil 1088} 1089 1090type awsRestjson1_serializeOpCreateNamespace struct { 1091} 1092 1093func (*awsRestjson1_serializeOpCreateNamespace) ID() string { 1094 return "OperationSerializer" 1095} 1096 1097func (m *awsRestjson1_serializeOpCreateNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1098 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1099) { 1100 request, ok := in.Request.(*smithyhttp.Request) 1101 if !ok { 1102 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1103 } 1104 1105 input, ok := in.Parameters.(*CreateNamespaceInput) 1106 _ = input 1107 if !ok { 1108 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1109 } 1110 1111 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}") 1112 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1113 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1114 request.Method = "POST" 1115 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1116 if err != nil { 1117 return out, metadata, &smithy.SerializationError{Err: err} 1118 } 1119 1120 if err := awsRestjson1_serializeOpHttpBindingsCreateNamespaceInput(input, restEncoder); err != nil { 1121 return out, metadata, &smithy.SerializationError{Err: err} 1122 } 1123 1124 restEncoder.SetHeader("Content-Type").String("application/json") 1125 1126 jsonEncoder := smithyjson.NewEncoder() 1127 if err := awsRestjson1_serializeOpDocumentCreateNamespaceInput(input, jsonEncoder.Value); err != nil { 1128 return out, metadata, &smithy.SerializationError{Err: err} 1129 } 1130 1131 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1132 return out, metadata, &smithy.SerializationError{Err: err} 1133 } 1134 1135 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1136 return out, metadata, &smithy.SerializationError{Err: err} 1137 } 1138 in.Request = request 1139 1140 return next.HandleSerialize(ctx, in) 1141} 1142func awsRestjson1_serializeOpHttpBindingsCreateNamespaceInput(v *CreateNamespaceInput, encoder *httpbinding.Encoder) error { 1143 if v == nil { 1144 return fmt.Errorf("unsupported serialization of nil %T", v) 1145 } 1146 1147 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1148 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1149 } 1150 if v.AwsAccountId != nil { 1151 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1152 return err 1153 } 1154 } 1155 1156 return nil 1157} 1158 1159func awsRestjson1_serializeOpDocumentCreateNamespaceInput(v *CreateNamespaceInput, value smithyjson.Value) error { 1160 object := value.Object() 1161 defer object.Close() 1162 1163 if len(v.IdentityStore) > 0 { 1164 ok := object.Key("IdentityStore") 1165 ok.String(string(v.IdentityStore)) 1166 } 1167 1168 if v.Namespace != nil { 1169 ok := object.Key("Namespace") 1170 ok.String(*v.Namespace) 1171 } 1172 1173 if v.Tags != nil { 1174 ok := object.Key("Tags") 1175 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 1176 return err 1177 } 1178 } 1179 1180 return nil 1181} 1182 1183type awsRestjson1_serializeOpCreateTemplate struct { 1184} 1185 1186func (*awsRestjson1_serializeOpCreateTemplate) ID() string { 1187 return "OperationSerializer" 1188} 1189 1190func (m *awsRestjson1_serializeOpCreateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1191 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1192) { 1193 request, ok := in.Request.(*smithyhttp.Request) 1194 if !ok { 1195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1196 } 1197 1198 input, ok := in.Parameters.(*CreateTemplateInput) 1199 _ = input 1200 if !ok { 1201 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1202 } 1203 1204 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}") 1205 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1206 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1207 request.Method = "POST" 1208 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1209 if err != nil { 1210 return out, metadata, &smithy.SerializationError{Err: err} 1211 } 1212 1213 if err := awsRestjson1_serializeOpHttpBindingsCreateTemplateInput(input, restEncoder); err != nil { 1214 return out, metadata, &smithy.SerializationError{Err: err} 1215 } 1216 1217 restEncoder.SetHeader("Content-Type").String("application/json") 1218 1219 jsonEncoder := smithyjson.NewEncoder() 1220 if err := awsRestjson1_serializeOpDocumentCreateTemplateInput(input, jsonEncoder.Value); err != nil { 1221 return out, metadata, &smithy.SerializationError{Err: err} 1222 } 1223 1224 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1225 return out, metadata, &smithy.SerializationError{Err: err} 1226 } 1227 1228 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1229 return out, metadata, &smithy.SerializationError{Err: err} 1230 } 1231 in.Request = request 1232 1233 return next.HandleSerialize(ctx, in) 1234} 1235func awsRestjson1_serializeOpHttpBindingsCreateTemplateInput(v *CreateTemplateInput, encoder *httpbinding.Encoder) error { 1236 if v == nil { 1237 return fmt.Errorf("unsupported serialization of nil %T", v) 1238 } 1239 1240 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1241 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1242 } 1243 if v.AwsAccountId != nil { 1244 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1245 return err 1246 } 1247 } 1248 1249 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 1250 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 1251 } 1252 if v.TemplateId != nil { 1253 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 1254 return err 1255 } 1256 } 1257 1258 return nil 1259} 1260 1261func awsRestjson1_serializeOpDocumentCreateTemplateInput(v *CreateTemplateInput, value smithyjson.Value) error { 1262 object := value.Object() 1263 defer object.Close() 1264 1265 if v.Name != nil { 1266 ok := object.Key("Name") 1267 ok.String(*v.Name) 1268 } 1269 1270 if v.Permissions != nil { 1271 ok := object.Key("Permissions") 1272 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil { 1273 return err 1274 } 1275 } 1276 1277 if v.SourceEntity != nil { 1278 ok := object.Key("SourceEntity") 1279 if err := awsRestjson1_serializeDocumentTemplateSourceEntity(v.SourceEntity, ok); err != nil { 1280 return err 1281 } 1282 } 1283 1284 if v.Tags != nil { 1285 ok := object.Key("Tags") 1286 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 1287 return err 1288 } 1289 } 1290 1291 if v.VersionDescription != nil { 1292 ok := object.Key("VersionDescription") 1293 ok.String(*v.VersionDescription) 1294 } 1295 1296 return nil 1297} 1298 1299type awsRestjson1_serializeOpCreateTemplateAlias struct { 1300} 1301 1302func (*awsRestjson1_serializeOpCreateTemplateAlias) ID() string { 1303 return "OperationSerializer" 1304} 1305 1306func (m *awsRestjson1_serializeOpCreateTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1307 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1308) { 1309 request, ok := in.Request.(*smithyhttp.Request) 1310 if !ok { 1311 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1312 } 1313 1314 input, ok := in.Parameters.(*CreateTemplateAliasInput) 1315 _ = input 1316 if !ok { 1317 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1318 } 1319 1320 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}") 1321 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1322 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1323 request.Method = "POST" 1324 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1325 if err != nil { 1326 return out, metadata, &smithy.SerializationError{Err: err} 1327 } 1328 1329 if err := awsRestjson1_serializeOpHttpBindingsCreateTemplateAliasInput(input, restEncoder); err != nil { 1330 return out, metadata, &smithy.SerializationError{Err: err} 1331 } 1332 1333 restEncoder.SetHeader("Content-Type").String("application/json") 1334 1335 jsonEncoder := smithyjson.NewEncoder() 1336 if err := awsRestjson1_serializeOpDocumentCreateTemplateAliasInput(input, jsonEncoder.Value); err != nil { 1337 return out, metadata, &smithy.SerializationError{Err: err} 1338 } 1339 1340 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1341 return out, metadata, &smithy.SerializationError{Err: err} 1342 } 1343 1344 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1345 return out, metadata, &smithy.SerializationError{Err: err} 1346 } 1347 in.Request = request 1348 1349 return next.HandleSerialize(ctx, in) 1350} 1351func awsRestjson1_serializeOpHttpBindingsCreateTemplateAliasInput(v *CreateTemplateAliasInput, encoder *httpbinding.Encoder) error { 1352 if v == nil { 1353 return fmt.Errorf("unsupported serialization of nil %T", v) 1354 } 1355 1356 if v.AliasName == nil || len(*v.AliasName) == 0 { 1357 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 1358 } 1359 if v.AliasName != nil { 1360 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 1361 return err 1362 } 1363 } 1364 1365 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1366 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1367 } 1368 if v.AwsAccountId != nil { 1369 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1370 return err 1371 } 1372 } 1373 1374 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 1375 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 1376 } 1377 if v.TemplateId != nil { 1378 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 1379 return err 1380 } 1381 } 1382 1383 return nil 1384} 1385 1386func awsRestjson1_serializeOpDocumentCreateTemplateAliasInput(v *CreateTemplateAliasInput, value smithyjson.Value) error { 1387 object := value.Object() 1388 defer object.Close() 1389 1390 if v.TemplateVersionNumber != nil { 1391 ok := object.Key("TemplateVersionNumber") 1392 ok.Long(*v.TemplateVersionNumber) 1393 } 1394 1395 return nil 1396} 1397 1398type awsRestjson1_serializeOpCreateTheme struct { 1399} 1400 1401func (*awsRestjson1_serializeOpCreateTheme) ID() string { 1402 return "OperationSerializer" 1403} 1404 1405func (m *awsRestjson1_serializeOpCreateTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1406 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1407) { 1408 request, ok := in.Request.(*smithyhttp.Request) 1409 if !ok { 1410 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1411 } 1412 1413 input, ok := in.Parameters.(*CreateThemeInput) 1414 _ = input 1415 if !ok { 1416 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1417 } 1418 1419 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}") 1420 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1421 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1422 request.Method = "POST" 1423 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1424 if err != nil { 1425 return out, metadata, &smithy.SerializationError{Err: err} 1426 } 1427 1428 if err := awsRestjson1_serializeOpHttpBindingsCreateThemeInput(input, restEncoder); err != nil { 1429 return out, metadata, &smithy.SerializationError{Err: err} 1430 } 1431 1432 restEncoder.SetHeader("Content-Type").String("application/json") 1433 1434 jsonEncoder := smithyjson.NewEncoder() 1435 if err := awsRestjson1_serializeOpDocumentCreateThemeInput(input, jsonEncoder.Value); err != nil { 1436 return out, metadata, &smithy.SerializationError{Err: err} 1437 } 1438 1439 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1440 return out, metadata, &smithy.SerializationError{Err: err} 1441 } 1442 1443 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1444 return out, metadata, &smithy.SerializationError{Err: err} 1445 } 1446 in.Request = request 1447 1448 return next.HandleSerialize(ctx, in) 1449} 1450func awsRestjson1_serializeOpHttpBindingsCreateThemeInput(v *CreateThemeInput, encoder *httpbinding.Encoder) error { 1451 if v == nil { 1452 return fmt.Errorf("unsupported serialization of nil %T", v) 1453 } 1454 1455 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1456 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1457 } 1458 if v.AwsAccountId != nil { 1459 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1460 return err 1461 } 1462 } 1463 1464 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 1465 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 1466 } 1467 if v.ThemeId != nil { 1468 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 1469 return err 1470 } 1471 } 1472 1473 return nil 1474} 1475 1476func awsRestjson1_serializeOpDocumentCreateThemeInput(v *CreateThemeInput, value smithyjson.Value) error { 1477 object := value.Object() 1478 defer object.Close() 1479 1480 if v.BaseThemeId != nil { 1481 ok := object.Key("BaseThemeId") 1482 ok.String(*v.BaseThemeId) 1483 } 1484 1485 if v.Configuration != nil { 1486 ok := object.Key("Configuration") 1487 if err := awsRestjson1_serializeDocumentThemeConfiguration(v.Configuration, ok); err != nil { 1488 return err 1489 } 1490 } 1491 1492 if v.Name != nil { 1493 ok := object.Key("Name") 1494 ok.String(*v.Name) 1495 } 1496 1497 if v.Permissions != nil { 1498 ok := object.Key("Permissions") 1499 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil { 1500 return err 1501 } 1502 } 1503 1504 if v.Tags != nil { 1505 ok := object.Key("Tags") 1506 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 1507 return err 1508 } 1509 } 1510 1511 if v.VersionDescription != nil { 1512 ok := object.Key("VersionDescription") 1513 ok.String(*v.VersionDescription) 1514 } 1515 1516 return nil 1517} 1518 1519type awsRestjson1_serializeOpCreateThemeAlias struct { 1520} 1521 1522func (*awsRestjson1_serializeOpCreateThemeAlias) ID() string { 1523 return "OperationSerializer" 1524} 1525 1526func (m *awsRestjson1_serializeOpCreateThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1527 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1528) { 1529 request, ok := in.Request.(*smithyhttp.Request) 1530 if !ok { 1531 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1532 } 1533 1534 input, ok := in.Parameters.(*CreateThemeAliasInput) 1535 _ = input 1536 if !ok { 1537 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1538 } 1539 1540 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}") 1541 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1542 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1543 request.Method = "POST" 1544 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1545 if err != nil { 1546 return out, metadata, &smithy.SerializationError{Err: err} 1547 } 1548 1549 if err := awsRestjson1_serializeOpHttpBindingsCreateThemeAliasInput(input, restEncoder); err != nil { 1550 return out, metadata, &smithy.SerializationError{Err: err} 1551 } 1552 1553 restEncoder.SetHeader("Content-Type").String("application/json") 1554 1555 jsonEncoder := smithyjson.NewEncoder() 1556 if err := awsRestjson1_serializeOpDocumentCreateThemeAliasInput(input, jsonEncoder.Value); err != nil { 1557 return out, metadata, &smithy.SerializationError{Err: err} 1558 } 1559 1560 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1561 return out, metadata, &smithy.SerializationError{Err: err} 1562 } 1563 1564 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1565 return out, metadata, &smithy.SerializationError{Err: err} 1566 } 1567 in.Request = request 1568 1569 return next.HandleSerialize(ctx, in) 1570} 1571func awsRestjson1_serializeOpHttpBindingsCreateThemeAliasInput(v *CreateThemeAliasInput, encoder *httpbinding.Encoder) error { 1572 if v == nil { 1573 return fmt.Errorf("unsupported serialization of nil %T", v) 1574 } 1575 1576 if v.AliasName == nil || len(*v.AliasName) == 0 { 1577 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 1578 } 1579 if v.AliasName != nil { 1580 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 1581 return err 1582 } 1583 } 1584 1585 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1586 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1587 } 1588 if v.AwsAccountId != nil { 1589 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1590 return err 1591 } 1592 } 1593 1594 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 1595 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 1596 } 1597 if v.ThemeId != nil { 1598 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 1599 return err 1600 } 1601 } 1602 1603 return nil 1604} 1605 1606func awsRestjson1_serializeOpDocumentCreateThemeAliasInput(v *CreateThemeAliasInput, value smithyjson.Value) error { 1607 object := value.Object() 1608 defer object.Close() 1609 1610 if v.ThemeVersionNumber != nil { 1611 ok := object.Key("ThemeVersionNumber") 1612 ok.Long(*v.ThemeVersionNumber) 1613 } 1614 1615 return nil 1616} 1617 1618type awsRestjson1_serializeOpDeleteAccountCustomization struct { 1619} 1620 1621func (*awsRestjson1_serializeOpDeleteAccountCustomization) ID() string { 1622 return "OperationSerializer" 1623} 1624 1625func (m *awsRestjson1_serializeOpDeleteAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1626 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1627) { 1628 request, ok := in.Request.(*smithyhttp.Request) 1629 if !ok { 1630 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1631 } 1632 1633 input, ok := in.Parameters.(*DeleteAccountCustomizationInput) 1634 _ = input 1635 if !ok { 1636 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1637 } 1638 1639 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations") 1640 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1641 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1642 request.Method = "DELETE" 1643 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1644 if err != nil { 1645 return out, metadata, &smithy.SerializationError{Err: err} 1646 } 1647 1648 if err := awsRestjson1_serializeOpHttpBindingsDeleteAccountCustomizationInput(input, restEncoder); err != nil { 1649 return out, metadata, &smithy.SerializationError{Err: err} 1650 } 1651 1652 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1653 return out, metadata, &smithy.SerializationError{Err: err} 1654 } 1655 in.Request = request 1656 1657 return next.HandleSerialize(ctx, in) 1658} 1659func awsRestjson1_serializeOpHttpBindingsDeleteAccountCustomizationInput(v *DeleteAccountCustomizationInput, encoder *httpbinding.Encoder) error { 1660 if v == nil { 1661 return fmt.Errorf("unsupported serialization of nil %T", v) 1662 } 1663 1664 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1665 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1666 } 1667 if v.AwsAccountId != nil { 1668 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1669 return err 1670 } 1671 } 1672 1673 if v.Namespace != nil { 1674 encoder.SetQuery("namespace").String(*v.Namespace) 1675 } 1676 1677 return nil 1678} 1679 1680type awsRestjson1_serializeOpDeleteAnalysis struct { 1681} 1682 1683func (*awsRestjson1_serializeOpDeleteAnalysis) ID() string { 1684 return "OperationSerializer" 1685} 1686 1687func (m *awsRestjson1_serializeOpDeleteAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1688 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1689) { 1690 request, ok := in.Request.(*smithyhttp.Request) 1691 if !ok { 1692 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1693 } 1694 1695 input, ok := in.Parameters.(*DeleteAnalysisInput) 1696 _ = input 1697 if !ok { 1698 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1699 } 1700 1701 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}") 1702 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1703 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1704 request.Method = "DELETE" 1705 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1706 if err != nil { 1707 return out, metadata, &smithy.SerializationError{Err: err} 1708 } 1709 1710 if err := awsRestjson1_serializeOpHttpBindingsDeleteAnalysisInput(input, restEncoder); err != nil { 1711 return out, metadata, &smithy.SerializationError{Err: err} 1712 } 1713 1714 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1715 return out, metadata, &smithy.SerializationError{Err: err} 1716 } 1717 in.Request = request 1718 1719 return next.HandleSerialize(ctx, in) 1720} 1721func awsRestjson1_serializeOpHttpBindingsDeleteAnalysisInput(v *DeleteAnalysisInput, encoder *httpbinding.Encoder) error { 1722 if v == nil { 1723 return fmt.Errorf("unsupported serialization of nil %T", v) 1724 } 1725 1726 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 1727 return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")} 1728 } 1729 if v.AnalysisId != nil { 1730 if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil { 1731 return err 1732 } 1733 } 1734 1735 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1736 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1737 } 1738 if v.AwsAccountId != nil { 1739 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1740 return err 1741 } 1742 } 1743 1744 if v.ForceDeleteWithoutRecovery { 1745 encoder.SetQuery("force-delete-without-recovery").Boolean(v.ForceDeleteWithoutRecovery) 1746 } 1747 1748 if v.RecoveryWindowInDays != nil { 1749 encoder.SetQuery("recovery-window-in-days").Long(*v.RecoveryWindowInDays) 1750 } 1751 1752 return nil 1753} 1754 1755type awsRestjson1_serializeOpDeleteDashboard struct { 1756} 1757 1758func (*awsRestjson1_serializeOpDeleteDashboard) ID() string { 1759 return "OperationSerializer" 1760} 1761 1762func (m *awsRestjson1_serializeOpDeleteDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1763 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1764) { 1765 request, ok := in.Request.(*smithyhttp.Request) 1766 if !ok { 1767 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1768 } 1769 1770 input, ok := in.Parameters.(*DeleteDashboardInput) 1771 _ = input 1772 if !ok { 1773 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1774 } 1775 1776 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}") 1777 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1778 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1779 request.Method = "DELETE" 1780 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1781 if err != nil { 1782 return out, metadata, &smithy.SerializationError{Err: err} 1783 } 1784 1785 if err := awsRestjson1_serializeOpHttpBindingsDeleteDashboardInput(input, restEncoder); err != nil { 1786 return out, metadata, &smithy.SerializationError{Err: err} 1787 } 1788 1789 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1790 return out, metadata, &smithy.SerializationError{Err: err} 1791 } 1792 in.Request = request 1793 1794 return next.HandleSerialize(ctx, in) 1795} 1796func awsRestjson1_serializeOpHttpBindingsDeleteDashboardInput(v *DeleteDashboardInput, encoder *httpbinding.Encoder) error { 1797 if v == nil { 1798 return fmt.Errorf("unsupported serialization of nil %T", v) 1799 } 1800 1801 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1802 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1803 } 1804 if v.AwsAccountId != nil { 1805 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1806 return err 1807 } 1808 } 1809 1810 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 1811 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 1812 } 1813 if v.DashboardId != nil { 1814 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 1815 return err 1816 } 1817 } 1818 1819 if v.VersionNumber != nil { 1820 encoder.SetQuery("version-number").Long(*v.VersionNumber) 1821 } 1822 1823 return nil 1824} 1825 1826type awsRestjson1_serializeOpDeleteDataSet struct { 1827} 1828 1829func (*awsRestjson1_serializeOpDeleteDataSet) ID() string { 1830 return "OperationSerializer" 1831} 1832 1833func (m *awsRestjson1_serializeOpDeleteDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1834 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1835) { 1836 request, ok := in.Request.(*smithyhttp.Request) 1837 if !ok { 1838 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1839 } 1840 1841 input, ok := in.Parameters.(*DeleteDataSetInput) 1842 _ = input 1843 if !ok { 1844 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1845 } 1846 1847 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}") 1848 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1849 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1850 request.Method = "DELETE" 1851 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1852 if err != nil { 1853 return out, metadata, &smithy.SerializationError{Err: err} 1854 } 1855 1856 if err := awsRestjson1_serializeOpHttpBindingsDeleteDataSetInput(input, restEncoder); err != nil { 1857 return out, metadata, &smithy.SerializationError{Err: err} 1858 } 1859 1860 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1861 return out, metadata, &smithy.SerializationError{Err: err} 1862 } 1863 in.Request = request 1864 1865 return next.HandleSerialize(ctx, in) 1866} 1867func awsRestjson1_serializeOpHttpBindingsDeleteDataSetInput(v *DeleteDataSetInput, encoder *httpbinding.Encoder) error { 1868 if v == nil { 1869 return fmt.Errorf("unsupported serialization of nil %T", v) 1870 } 1871 1872 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1873 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1874 } 1875 if v.AwsAccountId != nil { 1876 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1877 return err 1878 } 1879 } 1880 1881 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 1882 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 1883 } 1884 if v.DataSetId != nil { 1885 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 1886 return err 1887 } 1888 } 1889 1890 return nil 1891} 1892 1893type awsRestjson1_serializeOpDeleteDataSource struct { 1894} 1895 1896func (*awsRestjson1_serializeOpDeleteDataSource) ID() string { 1897 return "OperationSerializer" 1898} 1899 1900func (m *awsRestjson1_serializeOpDeleteDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1901 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1902) { 1903 request, ok := in.Request.(*smithyhttp.Request) 1904 if !ok { 1905 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1906 } 1907 1908 input, ok := in.Parameters.(*DeleteDataSourceInput) 1909 _ = input 1910 if !ok { 1911 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1912 } 1913 1914 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}") 1915 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1916 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1917 request.Method = "DELETE" 1918 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1919 if err != nil { 1920 return out, metadata, &smithy.SerializationError{Err: err} 1921 } 1922 1923 if err := awsRestjson1_serializeOpHttpBindingsDeleteDataSourceInput(input, restEncoder); err != nil { 1924 return out, metadata, &smithy.SerializationError{Err: err} 1925 } 1926 1927 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1928 return out, metadata, &smithy.SerializationError{Err: err} 1929 } 1930 in.Request = request 1931 1932 return next.HandleSerialize(ctx, in) 1933} 1934func awsRestjson1_serializeOpHttpBindingsDeleteDataSourceInput(v *DeleteDataSourceInput, encoder *httpbinding.Encoder) error { 1935 if v == nil { 1936 return fmt.Errorf("unsupported serialization of nil %T", v) 1937 } 1938 1939 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 1940 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 1941 } 1942 if v.AwsAccountId != nil { 1943 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 1944 return err 1945 } 1946 } 1947 1948 if v.DataSourceId == nil || len(*v.DataSourceId) == 0 { 1949 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")} 1950 } 1951 if v.DataSourceId != nil { 1952 if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil { 1953 return err 1954 } 1955 } 1956 1957 return nil 1958} 1959 1960type awsRestjson1_serializeOpDeleteGroup struct { 1961} 1962 1963func (*awsRestjson1_serializeOpDeleteGroup) ID() string { 1964 return "OperationSerializer" 1965} 1966 1967func (m *awsRestjson1_serializeOpDeleteGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1968 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1969) { 1970 request, ok := in.Request.(*smithyhttp.Request) 1971 if !ok { 1972 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1973 } 1974 1975 input, ok := in.Parameters.(*DeleteGroupInput) 1976 _ = input 1977 if !ok { 1978 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1979 } 1980 1981 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}") 1982 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1983 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1984 request.Method = "DELETE" 1985 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1986 if err != nil { 1987 return out, metadata, &smithy.SerializationError{Err: err} 1988 } 1989 1990 if err := awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(input, restEncoder); err != nil { 1991 return out, metadata, &smithy.SerializationError{Err: err} 1992 } 1993 1994 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1995 return out, metadata, &smithy.SerializationError{Err: err} 1996 } 1997 in.Request = request 1998 1999 return next.HandleSerialize(ctx, in) 2000} 2001func awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(v *DeleteGroupInput, encoder *httpbinding.Encoder) error { 2002 if v == nil { 2003 return fmt.Errorf("unsupported serialization of nil %T", v) 2004 } 2005 2006 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2007 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2008 } 2009 if v.AwsAccountId != nil { 2010 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2011 return err 2012 } 2013 } 2014 2015 if v.GroupName == nil || len(*v.GroupName) == 0 { 2016 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")} 2017 } 2018 if v.GroupName != nil { 2019 if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil { 2020 return err 2021 } 2022 } 2023 2024 if v.Namespace == nil || len(*v.Namespace) == 0 { 2025 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 2026 } 2027 if v.Namespace != nil { 2028 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 2029 return err 2030 } 2031 } 2032 2033 return nil 2034} 2035 2036type awsRestjson1_serializeOpDeleteGroupMembership struct { 2037} 2038 2039func (*awsRestjson1_serializeOpDeleteGroupMembership) ID() string { 2040 return "OperationSerializer" 2041} 2042 2043func (m *awsRestjson1_serializeOpDeleteGroupMembership) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2044 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2045) { 2046 request, ok := in.Request.(*smithyhttp.Request) 2047 if !ok { 2048 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2049 } 2050 2051 input, ok := in.Parameters.(*DeleteGroupMembershipInput) 2052 _ = input 2053 if !ok { 2054 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2055 } 2056 2057 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members/{MemberName}") 2058 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2059 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2060 request.Method = "DELETE" 2061 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2062 if err != nil { 2063 return out, metadata, &smithy.SerializationError{Err: err} 2064 } 2065 2066 if err := awsRestjson1_serializeOpHttpBindingsDeleteGroupMembershipInput(input, restEncoder); err != nil { 2067 return out, metadata, &smithy.SerializationError{Err: err} 2068 } 2069 2070 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2071 return out, metadata, &smithy.SerializationError{Err: err} 2072 } 2073 in.Request = request 2074 2075 return next.HandleSerialize(ctx, in) 2076} 2077func awsRestjson1_serializeOpHttpBindingsDeleteGroupMembershipInput(v *DeleteGroupMembershipInput, encoder *httpbinding.Encoder) error { 2078 if v == nil { 2079 return fmt.Errorf("unsupported serialization of nil %T", v) 2080 } 2081 2082 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2083 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2084 } 2085 if v.AwsAccountId != nil { 2086 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2087 return err 2088 } 2089 } 2090 2091 if v.GroupName == nil || len(*v.GroupName) == 0 { 2092 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")} 2093 } 2094 if v.GroupName != nil { 2095 if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil { 2096 return err 2097 } 2098 } 2099 2100 if v.MemberName == nil || len(*v.MemberName) == 0 { 2101 return &smithy.SerializationError{Err: fmt.Errorf("input member MemberName must not be empty")} 2102 } 2103 if v.MemberName != nil { 2104 if err := encoder.SetURI("MemberName").String(*v.MemberName); err != nil { 2105 return err 2106 } 2107 } 2108 2109 if v.Namespace == nil || len(*v.Namespace) == 0 { 2110 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 2111 } 2112 if v.Namespace != nil { 2113 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 2114 return err 2115 } 2116 } 2117 2118 return nil 2119} 2120 2121type awsRestjson1_serializeOpDeleteIAMPolicyAssignment struct { 2122} 2123 2124func (*awsRestjson1_serializeOpDeleteIAMPolicyAssignment) ID() string { 2125 return "OperationSerializer" 2126} 2127 2128func (m *awsRestjson1_serializeOpDeleteIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2129 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2130) { 2131 request, ok := in.Request.(*smithyhttp.Request) 2132 if !ok { 2133 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2134 } 2135 2136 input, ok := in.Parameters.(*DeleteIAMPolicyAssignmentInput) 2137 _ = input 2138 if !ok { 2139 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2140 } 2141 2142 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespace/{Namespace}/iam-policy-assignments/{AssignmentName}") 2143 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2144 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2145 request.Method = "DELETE" 2146 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2147 if err != nil { 2148 return out, metadata, &smithy.SerializationError{Err: err} 2149 } 2150 2151 if err := awsRestjson1_serializeOpHttpBindingsDeleteIAMPolicyAssignmentInput(input, restEncoder); err != nil { 2152 return out, metadata, &smithy.SerializationError{Err: err} 2153 } 2154 2155 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2156 return out, metadata, &smithy.SerializationError{Err: err} 2157 } 2158 in.Request = request 2159 2160 return next.HandleSerialize(ctx, in) 2161} 2162func awsRestjson1_serializeOpHttpBindingsDeleteIAMPolicyAssignmentInput(v *DeleteIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error { 2163 if v == nil { 2164 return fmt.Errorf("unsupported serialization of nil %T", v) 2165 } 2166 2167 if v.AssignmentName == nil || len(*v.AssignmentName) == 0 { 2168 return &smithy.SerializationError{Err: fmt.Errorf("input member AssignmentName must not be empty")} 2169 } 2170 if v.AssignmentName != nil { 2171 if err := encoder.SetURI("AssignmentName").String(*v.AssignmentName); err != nil { 2172 return err 2173 } 2174 } 2175 2176 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2177 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2178 } 2179 if v.AwsAccountId != nil { 2180 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2181 return err 2182 } 2183 } 2184 2185 if v.Namespace == nil || len(*v.Namespace) == 0 { 2186 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 2187 } 2188 if v.Namespace != nil { 2189 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 2190 return err 2191 } 2192 } 2193 2194 return nil 2195} 2196 2197type awsRestjson1_serializeOpDeleteNamespace struct { 2198} 2199 2200func (*awsRestjson1_serializeOpDeleteNamespace) ID() string { 2201 return "OperationSerializer" 2202} 2203 2204func (m *awsRestjson1_serializeOpDeleteNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2205 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2206) { 2207 request, ok := in.Request.(*smithyhttp.Request) 2208 if !ok { 2209 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2210 } 2211 2212 input, ok := in.Parameters.(*DeleteNamespaceInput) 2213 _ = input 2214 if !ok { 2215 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2216 } 2217 2218 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}") 2219 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2220 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2221 request.Method = "DELETE" 2222 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2223 if err != nil { 2224 return out, metadata, &smithy.SerializationError{Err: err} 2225 } 2226 2227 if err := awsRestjson1_serializeOpHttpBindingsDeleteNamespaceInput(input, restEncoder); err != nil { 2228 return out, metadata, &smithy.SerializationError{Err: err} 2229 } 2230 2231 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2232 return out, metadata, &smithy.SerializationError{Err: err} 2233 } 2234 in.Request = request 2235 2236 return next.HandleSerialize(ctx, in) 2237} 2238func awsRestjson1_serializeOpHttpBindingsDeleteNamespaceInput(v *DeleteNamespaceInput, encoder *httpbinding.Encoder) error { 2239 if v == nil { 2240 return fmt.Errorf("unsupported serialization of nil %T", v) 2241 } 2242 2243 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2244 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2245 } 2246 if v.AwsAccountId != nil { 2247 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2248 return err 2249 } 2250 } 2251 2252 if v.Namespace == nil || len(*v.Namespace) == 0 { 2253 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 2254 } 2255 if v.Namespace != nil { 2256 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 2257 return err 2258 } 2259 } 2260 2261 return nil 2262} 2263 2264type awsRestjson1_serializeOpDeleteTemplate struct { 2265} 2266 2267func (*awsRestjson1_serializeOpDeleteTemplate) ID() string { 2268 return "OperationSerializer" 2269} 2270 2271func (m *awsRestjson1_serializeOpDeleteTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2272 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2273) { 2274 request, ok := in.Request.(*smithyhttp.Request) 2275 if !ok { 2276 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2277 } 2278 2279 input, ok := in.Parameters.(*DeleteTemplateInput) 2280 _ = input 2281 if !ok { 2282 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2283 } 2284 2285 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}") 2286 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2287 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2288 request.Method = "DELETE" 2289 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2290 if err != nil { 2291 return out, metadata, &smithy.SerializationError{Err: err} 2292 } 2293 2294 if err := awsRestjson1_serializeOpHttpBindingsDeleteTemplateInput(input, restEncoder); err != nil { 2295 return out, metadata, &smithy.SerializationError{Err: err} 2296 } 2297 2298 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2299 return out, metadata, &smithy.SerializationError{Err: err} 2300 } 2301 in.Request = request 2302 2303 return next.HandleSerialize(ctx, in) 2304} 2305func awsRestjson1_serializeOpHttpBindingsDeleteTemplateInput(v *DeleteTemplateInput, encoder *httpbinding.Encoder) error { 2306 if v == nil { 2307 return fmt.Errorf("unsupported serialization of nil %T", v) 2308 } 2309 2310 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2311 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2312 } 2313 if v.AwsAccountId != nil { 2314 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2315 return err 2316 } 2317 } 2318 2319 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 2320 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 2321 } 2322 if v.TemplateId != nil { 2323 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 2324 return err 2325 } 2326 } 2327 2328 if v.VersionNumber != nil { 2329 encoder.SetQuery("version-number").Long(*v.VersionNumber) 2330 } 2331 2332 return nil 2333} 2334 2335type awsRestjson1_serializeOpDeleteTemplateAlias struct { 2336} 2337 2338func (*awsRestjson1_serializeOpDeleteTemplateAlias) ID() string { 2339 return "OperationSerializer" 2340} 2341 2342func (m *awsRestjson1_serializeOpDeleteTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2343 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2344) { 2345 request, ok := in.Request.(*smithyhttp.Request) 2346 if !ok { 2347 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2348 } 2349 2350 input, ok := in.Parameters.(*DeleteTemplateAliasInput) 2351 _ = input 2352 if !ok { 2353 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2354 } 2355 2356 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}") 2357 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2358 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2359 request.Method = "DELETE" 2360 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2361 if err != nil { 2362 return out, metadata, &smithy.SerializationError{Err: err} 2363 } 2364 2365 if err := awsRestjson1_serializeOpHttpBindingsDeleteTemplateAliasInput(input, restEncoder); err != nil { 2366 return out, metadata, &smithy.SerializationError{Err: err} 2367 } 2368 2369 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2370 return out, metadata, &smithy.SerializationError{Err: err} 2371 } 2372 in.Request = request 2373 2374 return next.HandleSerialize(ctx, in) 2375} 2376func awsRestjson1_serializeOpHttpBindingsDeleteTemplateAliasInput(v *DeleteTemplateAliasInput, encoder *httpbinding.Encoder) error { 2377 if v == nil { 2378 return fmt.Errorf("unsupported serialization of nil %T", v) 2379 } 2380 2381 if v.AliasName == nil || len(*v.AliasName) == 0 { 2382 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 2383 } 2384 if v.AliasName != nil { 2385 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 2386 return err 2387 } 2388 } 2389 2390 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2391 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2392 } 2393 if v.AwsAccountId != nil { 2394 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2395 return err 2396 } 2397 } 2398 2399 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 2400 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 2401 } 2402 if v.TemplateId != nil { 2403 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 2404 return err 2405 } 2406 } 2407 2408 return nil 2409} 2410 2411type awsRestjson1_serializeOpDeleteTheme struct { 2412} 2413 2414func (*awsRestjson1_serializeOpDeleteTheme) ID() string { 2415 return "OperationSerializer" 2416} 2417 2418func (m *awsRestjson1_serializeOpDeleteTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2419 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2420) { 2421 request, ok := in.Request.(*smithyhttp.Request) 2422 if !ok { 2423 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2424 } 2425 2426 input, ok := in.Parameters.(*DeleteThemeInput) 2427 _ = input 2428 if !ok { 2429 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2430 } 2431 2432 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}") 2433 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2434 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2435 request.Method = "DELETE" 2436 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2437 if err != nil { 2438 return out, metadata, &smithy.SerializationError{Err: err} 2439 } 2440 2441 if err := awsRestjson1_serializeOpHttpBindingsDeleteThemeInput(input, restEncoder); err != nil { 2442 return out, metadata, &smithy.SerializationError{Err: err} 2443 } 2444 2445 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2446 return out, metadata, &smithy.SerializationError{Err: err} 2447 } 2448 in.Request = request 2449 2450 return next.HandleSerialize(ctx, in) 2451} 2452func awsRestjson1_serializeOpHttpBindingsDeleteThemeInput(v *DeleteThemeInput, encoder *httpbinding.Encoder) error { 2453 if v == nil { 2454 return fmt.Errorf("unsupported serialization of nil %T", v) 2455 } 2456 2457 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2458 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2459 } 2460 if v.AwsAccountId != nil { 2461 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2462 return err 2463 } 2464 } 2465 2466 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 2467 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 2468 } 2469 if v.ThemeId != nil { 2470 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 2471 return err 2472 } 2473 } 2474 2475 if v.VersionNumber != nil { 2476 encoder.SetQuery("version-number").Long(*v.VersionNumber) 2477 } 2478 2479 return nil 2480} 2481 2482type awsRestjson1_serializeOpDeleteThemeAlias struct { 2483} 2484 2485func (*awsRestjson1_serializeOpDeleteThemeAlias) ID() string { 2486 return "OperationSerializer" 2487} 2488 2489func (m *awsRestjson1_serializeOpDeleteThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2490 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2491) { 2492 request, ok := in.Request.(*smithyhttp.Request) 2493 if !ok { 2494 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2495 } 2496 2497 input, ok := in.Parameters.(*DeleteThemeAliasInput) 2498 _ = input 2499 if !ok { 2500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2501 } 2502 2503 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}") 2504 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2505 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2506 request.Method = "DELETE" 2507 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2508 if err != nil { 2509 return out, metadata, &smithy.SerializationError{Err: err} 2510 } 2511 2512 if err := awsRestjson1_serializeOpHttpBindingsDeleteThemeAliasInput(input, restEncoder); err != nil { 2513 return out, metadata, &smithy.SerializationError{Err: err} 2514 } 2515 2516 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2517 return out, metadata, &smithy.SerializationError{Err: err} 2518 } 2519 in.Request = request 2520 2521 return next.HandleSerialize(ctx, in) 2522} 2523func awsRestjson1_serializeOpHttpBindingsDeleteThemeAliasInput(v *DeleteThemeAliasInput, encoder *httpbinding.Encoder) error { 2524 if v == nil { 2525 return fmt.Errorf("unsupported serialization of nil %T", v) 2526 } 2527 2528 if v.AliasName == nil || len(*v.AliasName) == 0 { 2529 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 2530 } 2531 if v.AliasName != nil { 2532 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 2533 return err 2534 } 2535 } 2536 2537 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2538 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2539 } 2540 if v.AwsAccountId != nil { 2541 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2542 return err 2543 } 2544 } 2545 2546 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 2547 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 2548 } 2549 if v.ThemeId != nil { 2550 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 2551 return err 2552 } 2553 } 2554 2555 return nil 2556} 2557 2558type awsRestjson1_serializeOpDeleteUser struct { 2559} 2560 2561func (*awsRestjson1_serializeOpDeleteUser) ID() string { 2562 return "OperationSerializer" 2563} 2564 2565func (m *awsRestjson1_serializeOpDeleteUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2566 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2567) { 2568 request, ok := in.Request.(*smithyhttp.Request) 2569 if !ok { 2570 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2571 } 2572 2573 input, ok := in.Parameters.(*DeleteUserInput) 2574 _ = input 2575 if !ok { 2576 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2577 } 2578 2579 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}") 2580 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2581 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2582 request.Method = "DELETE" 2583 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2584 if err != nil { 2585 return out, metadata, &smithy.SerializationError{Err: err} 2586 } 2587 2588 if err := awsRestjson1_serializeOpHttpBindingsDeleteUserInput(input, restEncoder); err != nil { 2589 return out, metadata, &smithy.SerializationError{Err: err} 2590 } 2591 2592 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2593 return out, metadata, &smithy.SerializationError{Err: err} 2594 } 2595 in.Request = request 2596 2597 return next.HandleSerialize(ctx, in) 2598} 2599func awsRestjson1_serializeOpHttpBindingsDeleteUserInput(v *DeleteUserInput, encoder *httpbinding.Encoder) error { 2600 if v == nil { 2601 return fmt.Errorf("unsupported serialization of nil %T", v) 2602 } 2603 2604 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2605 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2606 } 2607 if v.AwsAccountId != nil { 2608 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2609 return err 2610 } 2611 } 2612 2613 if v.Namespace == nil || len(*v.Namespace) == 0 { 2614 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 2615 } 2616 if v.Namespace != nil { 2617 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 2618 return err 2619 } 2620 } 2621 2622 if v.UserName == nil || len(*v.UserName) == 0 { 2623 return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")} 2624 } 2625 if v.UserName != nil { 2626 if err := encoder.SetURI("UserName").String(*v.UserName); err != nil { 2627 return err 2628 } 2629 } 2630 2631 return nil 2632} 2633 2634type awsRestjson1_serializeOpDeleteUserByPrincipalId struct { 2635} 2636 2637func (*awsRestjson1_serializeOpDeleteUserByPrincipalId) ID() string { 2638 return "OperationSerializer" 2639} 2640 2641func (m *awsRestjson1_serializeOpDeleteUserByPrincipalId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2642 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2643) { 2644 request, ok := in.Request.(*smithyhttp.Request) 2645 if !ok { 2646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2647 } 2648 2649 input, ok := in.Parameters.(*DeleteUserByPrincipalIdInput) 2650 _ = input 2651 if !ok { 2652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2653 } 2654 2655 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/user-principals/{PrincipalId}") 2656 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2657 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2658 request.Method = "DELETE" 2659 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2660 if err != nil { 2661 return out, metadata, &smithy.SerializationError{Err: err} 2662 } 2663 2664 if err := awsRestjson1_serializeOpHttpBindingsDeleteUserByPrincipalIdInput(input, restEncoder); err != nil { 2665 return out, metadata, &smithy.SerializationError{Err: err} 2666 } 2667 2668 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2669 return out, metadata, &smithy.SerializationError{Err: err} 2670 } 2671 in.Request = request 2672 2673 return next.HandleSerialize(ctx, in) 2674} 2675func awsRestjson1_serializeOpHttpBindingsDeleteUserByPrincipalIdInput(v *DeleteUserByPrincipalIdInput, encoder *httpbinding.Encoder) error { 2676 if v == nil { 2677 return fmt.Errorf("unsupported serialization of nil %T", v) 2678 } 2679 2680 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2681 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2682 } 2683 if v.AwsAccountId != nil { 2684 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2685 return err 2686 } 2687 } 2688 2689 if v.Namespace == nil || len(*v.Namespace) == 0 { 2690 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 2691 } 2692 if v.Namespace != nil { 2693 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 2694 return err 2695 } 2696 } 2697 2698 if v.PrincipalId == nil || len(*v.PrincipalId) == 0 { 2699 return &smithy.SerializationError{Err: fmt.Errorf("input member PrincipalId must not be empty")} 2700 } 2701 if v.PrincipalId != nil { 2702 if err := encoder.SetURI("PrincipalId").String(*v.PrincipalId); err != nil { 2703 return err 2704 } 2705 } 2706 2707 return nil 2708} 2709 2710type awsRestjson1_serializeOpDescribeAccountCustomization struct { 2711} 2712 2713func (*awsRestjson1_serializeOpDescribeAccountCustomization) ID() string { 2714 return "OperationSerializer" 2715} 2716 2717func (m *awsRestjson1_serializeOpDescribeAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2718 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2719) { 2720 request, ok := in.Request.(*smithyhttp.Request) 2721 if !ok { 2722 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2723 } 2724 2725 input, ok := in.Parameters.(*DescribeAccountCustomizationInput) 2726 _ = input 2727 if !ok { 2728 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2729 } 2730 2731 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations") 2732 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2733 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2734 request.Method = "GET" 2735 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2736 if err != nil { 2737 return out, metadata, &smithy.SerializationError{Err: err} 2738 } 2739 2740 if err := awsRestjson1_serializeOpHttpBindingsDescribeAccountCustomizationInput(input, restEncoder); err != nil { 2741 return out, metadata, &smithy.SerializationError{Err: err} 2742 } 2743 2744 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2745 return out, metadata, &smithy.SerializationError{Err: err} 2746 } 2747 in.Request = request 2748 2749 return next.HandleSerialize(ctx, in) 2750} 2751func awsRestjson1_serializeOpHttpBindingsDescribeAccountCustomizationInput(v *DescribeAccountCustomizationInput, encoder *httpbinding.Encoder) error { 2752 if v == nil { 2753 return fmt.Errorf("unsupported serialization of nil %T", v) 2754 } 2755 2756 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2757 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2758 } 2759 if v.AwsAccountId != nil { 2760 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2761 return err 2762 } 2763 } 2764 2765 if v.Namespace != nil { 2766 encoder.SetQuery("namespace").String(*v.Namespace) 2767 } 2768 2769 if v.Resolved { 2770 encoder.SetQuery("resolved").Boolean(v.Resolved) 2771 } 2772 2773 return nil 2774} 2775 2776type awsRestjson1_serializeOpDescribeAccountSettings struct { 2777} 2778 2779func (*awsRestjson1_serializeOpDescribeAccountSettings) ID() string { 2780 return "OperationSerializer" 2781} 2782 2783func (m *awsRestjson1_serializeOpDescribeAccountSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2784 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2785) { 2786 request, ok := in.Request.(*smithyhttp.Request) 2787 if !ok { 2788 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2789 } 2790 2791 input, ok := in.Parameters.(*DescribeAccountSettingsInput) 2792 _ = input 2793 if !ok { 2794 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2795 } 2796 2797 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/settings") 2798 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2799 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2800 request.Method = "GET" 2801 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2802 if err != nil { 2803 return out, metadata, &smithy.SerializationError{Err: err} 2804 } 2805 2806 if err := awsRestjson1_serializeOpHttpBindingsDescribeAccountSettingsInput(input, restEncoder); err != nil { 2807 return out, metadata, &smithy.SerializationError{Err: err} 2808 } 2809 2810 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2811 return out, metadata, &smithy.SerializationError{Err: err} 2812 } 2813 in.Request = request 2814 2815 return next.HandleSerialize(ctx, in) 2816} 2817func awsRestjson1_serializeOpHttpBindingsDescribeAccountSettingsInput(v *DescribeAccountSettingsInput, encoder *httpbinding.Encoder) error { 2818 if v == nil { 2819 return fmt.Errorf("unsupported serialization of nil %T", v) 2820 } 2821 2822 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2823 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2824 } 2825 if v.AwsAccountId != nil { 2826 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2827 return err 2828 } 2829 } 2830 2831 return nil 2832} 2833 2834type awsRestjson1_serializeOpDescribeAnalysis struct { 2835} 2836 2837func (*awsRestjson1_serializeOpDescribeAnalysis) ID() string { 2838 return "OperationSerializer" 2839} 2840 2841func (m *awsRestjson1_serializeOpDescribeAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2842 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2843) { 2844 request, ok := in.Request.(*smithyhttp.Request) 2845 if !ok { 2846 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2847 } 2848 2849 input, ok := in.Parameters.(*DescribeAnalysisInput) 2850 _ = input 2851 if !ok { 2852 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2853 } 2854 2855 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}") 2856 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2857 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2858 request.Method = "GET" 2859 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2860 if err != nil { 2861 return out, metadata, &smithy.SerializationError{Err: err} 2862 } 2863 2864 if err := awsRestjson1_serializeOpHttpBindingsDescribeAnalysisInput(input, restEncoder); err != nil { 2865 return out, metadata, &smithy.SerializationError{Err: err} 2866 } 2867 2868 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2869 return out, metadata, &smithy.SerializationError{Err: err} 2870 } 2871 in.Request = request 2872 2873 return next.HandleSerialize(ctx, in) 2874} 2875func awsRestjson1_serializeOpHttpBindingsDescribeAnalysisInput(v *DescribeAnalysisInput, encoder *httpbinding.Encoder) error { 2876 if v == nil { 2877 return fmt.Errorf("unsupported serialization of nil %T", v) 2878 } 2879 2880 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 2881 return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")} 2882 } 2883 if v.AnalysisId != nil { 2884 if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil { 2885 return err 2886 } 2887 } 2888 2889 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2890 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2891 } 2892 if v.AwsAccountId != nil { 2893 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2894 return err 2895 } 2896 } 2897 2898 return nil 2899} 2900 2901type awsRestjson1_serializeOpDescribeAnalysisPermissions struct { 2902} 2903 2904func (*awsRestjson1_serializeOpDescribeAnalysisPermissions) ID() string { 2905 return "OperationSerializer" 2906} 2907 2908func (m *awsRestjson1_serializeOpDescribeAnalysisPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2909 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2910) { 2911 request, ok := in.Request.(*smithyhttp.Request) 2912 if !ok { 2913 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2914 } 2915 2916 input, ok := in.Parameters.(*DescribeAnalysisPermissionsInput) 2917 _ = input 2918 if !ok { 2919 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2920 } 2921 2922 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}/permissions") 2923 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2924 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2925 request.Method = "GET" 2926 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2927 if err != nil { 2928 return out, metadata, &smithy.SerializationError{Err: err} 2929 } 2930 2931 if err := awsRestjson1_serializeOpHttpBindingsDescribeAnalysisPermissionsInput(input, restEncoder); err != nil { 2932 return out, metadata, &smithy.SerializationError{Err: err} 2933 } 2934 2935 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2936 return out, metadata, &smithy.SerializationError{Err: err} 2937 } 2938 in.Request = request 2939 2940 return next.HandleSerialize(ctx, in) 2941} 2942func awsRestjson1_serializeOpHttpBindingsDescribeAnalysisPermissionsInput(v *DescribeAnalysisPermissionsInput, encoder *httpbinding.Encoder) error { 2943 if v == nil { 2944 return fmt.Errorf("unsupported serialization of nil %T", v) 2945 } 2946 2947 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 2948 return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")} 2949 } 2950 if v.AnalysisId != nil { 2951 if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil { 2952 return err 2953 } 2954 } 2955 2956 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 2957 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 2958 } 2959 if v.AwsAccountId != nil { 2960 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 2961 return err 2962 } 2963 } 2964 2965 return nil 2966} 2967 2968type awsRestjson1_serializeOpDescribeDashboard struct { 2969} 2970 2971func (*awsRestjson1_serializeOpDescribeDashboard) ID() string { 2972 return "OperationSerializer" 2973} 2974 2975func (m *awsRestjson1_serializeOpDescribeDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2976 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2977) { 2978 request, ok := in.Request.(*smithyhttp.Request) 2979 if !ok { 2980 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2981 } 2982 2983 input, ok := in.Parameters.(*DescribeDashboardInput) 2984 _ = input 2985 if !ok { 2986 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2987 } 2988 2989 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}") 2990 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2991 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2992 request.Method = "GET" 2993 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2994 if err != nil { 2995 return out, metadata, &smithy.SerializationError{Err: err} 2996 } 2997 2998 if err := awsRestjson1_serializeOpHttpBindingsDescribeDashboardInput(input, restEncoder); err != nil { 2999 return out, metadata, &smithy.SerializationError{Err: err} 3000 } 3001 3002 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3003 return out, metadata, &smithy.SerializationError{Err: err} 3004 } 3005 in.Request = request 3006 3007 return next.HandleSerialize(ctx, in) 3008} 3009func awsRestjson1_serializeOpHttpBindingsDescribeDashboardInput(v *DescribeDashboardInput, encoder *httpbinding.Encoder) error { 3010 if v == nil { 3011 return fmt.Errorf("unsupported serialization of nil %T", v) 3012 } 3013 3014 if v.AliasName != nil { 3015 encoder.SetQuery("alias-name").String(*v.AliasName) 3016 } 3017 3018 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3019 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3020 } 3021 if v.AwsAccountId != nil { 3022 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3023 return err 3024 } 3025 } 3026 3027 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 3028 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 3029 } 3030 if v.DashboardId != nil { 3031 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 3032 return err 3033 } 3034 } 3035 3036 if v.VersionNumber != nil { 3037 encoder.SetQuery("version-number").Long(*v.VersionNumber) 3038 } 3039 3040 return nil 3041} 3042 3043type awsRestjson1_serializeOpDescribeDashboardPermissions struct { 3044} 3045 3046func (*awsRestjson1_serializeOpDescribeDashboardPermissions) ID() string { 3047 return "OperationSerializer" 3048} 3049 3050func (m *awsRestjson1_serializeOpDescribeDashboardPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3051 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3052) { 3053 request, ok := in.Request.(*smithyhttp.Request) 3054 if !ok { 3055 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3056 } 3057 3058 input, ok := in.Parameters.(*DescribeDashboardPermissionsInput) 3059 _ = input 3060 if !ok { 3061 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3062 } 3063 3064 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/permissions") 3065 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3066 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3067 request.Method = "GET" 3068 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3069 if err != nil { 3070 return out, metadata, &smithy.SerializationError{Err: err} 3071 } 3072 3073 if err := awsRestjson1_serializeOpHttpBindingsDescribeDashboardPermissionsInput(input, restEncoder); err != nil { 3074 return out, metadata, &smithy.SerializationError{Err: err} 3075 } 3076 3077 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3078 return out, metadata, &smithy.SerializationError{Err: err} 3079 } 3080 in.Request = request 3081 3082 return next.HandleSerialize(ctx, in) 3083} 3084func awsRestjson1_serializeOpHttpBindingsDescribeDashboardPermissionsInput(v *DescribeDashboardPermissionsInput, encoder *httpbinding.Encoder) error { 3085 if v == nil { 3086 return fmt.Errorf("unsupported serialization of nil %T", v) 3087 } 3088 3089 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3090 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3091 } 3092 if v.AwsAccountId != nil { 3093 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3094 return err 3095 } 3096 } 3097 3098 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 3099 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 3100 } 3101 if v.DashboardId != nil { 3102 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 3103 return err 3104 } 3105 } 3106 3107 return nil 3108} 3109 3110type awsRestjson1_serializeOpDescribeDataSet struct { 3111} 3112 3113func (*awsRestjson1_serializeOpDescribeDataSet) ID() string { 3114 return "OperationSerializer" 3115} 3116 3117func (m *awsRestjson1_serializeOpDescribeDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3118 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3119) { 3120 request, ok := in.Request.(*smithyhttp.Request) 3121 if !ok { 3122 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3123 } 3124 3125 input, ok := in.Parameters.(*DescribeDataSetInput) 3126 _ = input 3127 if !ok { 3128 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3129 } 3130 3131 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}") 3132 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3133 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3134 request.Method = "GET" 3135 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3136 if err != nil { 3137 return out, metadata, &smithy.SerializationError{Err: err} 3138 } 3139 3140 if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSetInput(input, restEncoder); err != nil { 3141 return out, metadata, &smithy.SerializationError{Err: err} 3142 } 3143 3144 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3145 return out, metadata, &smithy.SerializationError{Err: err} 3146 } 3147 in.Request = request 3148 3149 return next.HandleSerialize(ctx, in) 3150} 3151func awsRestjson1_serializeOpHttpBindingsDescribeDataSetInput(v *DescribeDataSetInput, encoder *httpbinding.Encoder) error { 3152 if v == nil { 3153 return fmt.Errorf("unsupported serialization of nil %T", v) 3154 } 3155 3156 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3157 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3158 } 3159 if v.AwsAccountId != nil { 3160 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3161 return err 3162 } 3163 } 3164 3165 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 3166 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 3167 } 3168 if v.DataSetId != nil { 3169 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 3170 return err 3171 } 3172 } 3173 3174 return nil 3175} 3176 3177type awsRestjson1_serializeOpDescribeDataSetPermissions struct { 3178} 3179 3180func (*awsRestjson1_serializeOpDescribeDataSetPermissions) ID() string { 3181 return "OperationSerializer" 3182} 3183 3184func (m *awsRestjson1_serializeOpDescribeDataSetPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3185 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3186) { 3187 request, ok := in.Request.(*smithyhttp.Request) 3188 if !ok { 3189 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3190 } 3191 3192 input, ok := in.Parameters.(*DescribeDataSetPermissionsInput) 3193 _ = input 3194 if !ok { 3195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3196 } 3197 3198 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/permissions") 3199 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3200 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3201 request.Method = "GET" 3202 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3203 if err != nil { 3204 return out, metadata, &smithy.SerializationError{Err: err} 3205 } 3206 3207 if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSetPermissionsInput(input, restEncoder); err != nil { 3208 return out, metadata, &smithy.SerializationError{Err: err} 3209 } 3210 3211 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3212 return out, metadata, &smithy.SerializationError{Err: err} 3213 } 3214 in.Request = request 3215 3216 return next.HandleSerialize(ctx, in) 3217} 3218func awsRestjson1_serializeOpHttpBindingsDescribeDataSetPermissionsInput(v *DescribeDataSetPermissionsInput, encoder *httpbinding.Encoder) error { 3219 if v == nil { 3220 return fmt.Errorf("unsupported serialization of nil %T", v) 3221 } 3222 3223 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3224 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3225 } 3226 if v.AwsAccountId != nil { 3227 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3228 return err 3229 } 3230 } 3231 3232 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 3233 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 3234 } 3235 if v.DataSetId != nil { 3236 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 3237 return err 3238 } 3239 } 3240 3241 return nil 3242} 3243 3244type awsRestjson1_serializeOpDescribeDataSource struct { 3245} 3246 3247func (*awsRestjson1_serializeOpDescribeDataSource) ID() string { 3248 return "OperationSerializer" 3249} 3250 3251func (m *awsRestjson1_serializeOpDescribeDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3252 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3253) { 3254 request, ok := in.Request.(*smithyhttp.Request) 3255 if !ok { 3256 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3257 } 3258 3259 input, ok := in.Parameters.(*DescribeDataSourceInput) 3260 _ = input 3261 if !ok { 3262 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3263 } 3264 3265 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}") 3266 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3267 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3268 request.Method = "GET" 3269 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3270 if err != nil { 3271 return out, metadata, &smithy.SerializationError{Err: err} 3272 } 3273 3274 if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSourceInput(input, restEncoder); err != nil { 3275 return out, metadata, &smithy.SerializationError{Err: err} 3276 } 3277 3278 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3279 return out, metadata, &smithy.SerializationError{Err: err} 3280 } 3281 in.Request = request 3282 3283 return next.HandleSerialize(ctx, in) 3284} 3285func awsRestjson1_serializeOpHttpBindingsDescribeDataSourceInput(v *DescribeDataSourceInput, encoder *httpbinding.Encoder) error { 3286 if v == nil { 3287 return fmt.Errorf("unsupported serialization of nil %T", v) 3288 } 3289 3290 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3291 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3292 } 3293 if v.AwsAccountId != nil { 3294 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3295 return err 3296 } 3297 } 3298 3299 if v.DataSourceId == nil || len(*v.DataSourceId) == 0 { 3300 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")} 3301 } 3302 if v.DataSourceId != nil { 3303 if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil { 3304 return err 3305 } 3306 } 3307 3308 return nil 3309} 3310 3311type awsRestjson1_serializeOpDescribeDataSourcePermissions struct { 3312} 3313 3314func (*awsRestjson1_serializeOpDescribeDataSourcePermissions) ID() string { 3315 return "OperationSerializer" 3316} 3317 3318func (m *awsRestjson1_serializeOpDescribeDataSourcePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3319 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3320) { 3321 request, ok := in.Request.(*smithyhttp.Request) 3322 if !ok { 3323 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3324 } 3325 3326 input, ok := in.Parameters.(*DescribeDataSourcePermissionsInput) 3327 _ = input 3328 if !ok { 3329 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3330 } 3331 3332 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}/permissions") 3333 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3334 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3335 request.Method = "GET" 3336 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3337 if err != nil { 3338 return out, metadata, &smithy.SerializationError{Err: err} 3339 } 3340 3341 if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSourcePermissionsInput(input, restEncoder); err != nil { 3342 return out, metadata, &smithy.SerializationError{Err: err} 3343 } 3344 3345 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3346 return out, metadata, &smithy.SerializationError{Err: err} 3347 } 3348 in.Request = request 3349 3350 return next.HandleSerialize(ctx, in) 3351} 3352func awsRestjson1_serializeOpHttpBindingsDescribeDataSourcePermissionsInput(v *DescribeDataSourcePermissionsInput, encoder *httpbinding.Encoder) error { 3353 if v == nil { 3354 return fmt.Errorf("unsupported serialization of nil %T", v) 3355 } 3356 3357 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3358 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3359 } 3360 if v.AwsAccountId != nil { 3361 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3362 return err 3363 } 3364 } 3365 3366 if v.DataSourceId == nil || len(*v.DataSourceId) == 0 { 3367 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")} 3368 } 3369 if v.DataSourceId != nil { 3370 if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil { 3371 return err 3372 } 3373 } 3374 3375 return nil 3376} 3377 3378type awsRestjson1_serializeOpDescribeGroup struct { 3379} 3380 3381func (*awsRestjson1_serializeOpDescribeGroup) ID() string { 3382 return "OperationSerializer" 3383} 3384 3385func (m *awsRestjson1_serializeOpDescribeGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3386 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3387) { 3388 request, ok := in.Request.(*smithyhttp.Request) 3389 if !ok { 3390 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3391 } 3392 3393 input, ok := in.Parameters.(*DescribeGroupInput) 3394 _ = input 3395 if !ok { 3396 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3397 } 3398 3399 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}") 3400 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3401 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3402 request.Method = "GET" 3403 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3404 if err != nil { 3405 return out, metadata, &smithy.SerializationError{Err: err} 3406 } 3407 3408 if err := awsRestjson1_serializeOpHttpBindingsDescribeGroupInput(input, restEncoder); err != nil { 3409 return out, metadata, &smithy.SerializationError{Err: err} 3410 } 3411 3412 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3413 return out, metadata, &smithy.SerializationError{Err: err} 3414 } 3415 in.Request = request 3416 3417 return next.HandleSerialize(ctx, in) 3418} 3419func awsRestjson1_serializeOpHttpBindingsDescribeGroupInput(v *DescribeGroupInput, encoder *httpbinding.Encoder) error { 3420 if v == nil { 3421 return fmt.Errorf("unsupported serialization of nil %T", v) 3422 } 3423 3424 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3425 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3426 } 3427 if v.AwsAccountId != nil { 3428 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3429 return err 3430 } 3431 } 3432 3433 if v.GroupName == nil || len(*v.GroupName) == 0 { 3434 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")} 3435 } 3436 if v.GroupName != nil { 3437 if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil { 3438 return err 3439 } 3440 } 3441 3442 if v.Namespace == nil || len(*v.Namespace) == 0 { 3443 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 3444 } 3445 if v.Namespace != nil { 3446 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 3447 return err 3448 } 3449 } 3450 3451 return nil 3452} 3453 3454type awsRestjson1_serializeOpDescribeIAMPolicyAssignment struct { 3455} 3456 3457func (*awsRestjson1_serializeOpDescribeIAMPolicyAssignment) ID() string { 3458 return "OperationSerializer" 3459} 3460 3461func (m *awsRestjson1_serializeOpDescribeIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3462 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3463) { 3464 request, ok := in.Request.(*smithyhttp.Request) 3465 if !ok { 3466 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3467 } 3468 3469 input, ok := in.Parameters.(*DescribeIAMPolicyAssignmentInput) 3470 _ = input 3471 if !ok { 3472 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3473 } 3474 3475 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments/{AssignmentName}") 3476 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3477 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3478 request.Method = "GET" 3479 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3480 if err != nil { 3481 return out, metadata, &smithy.SerializationError{Err: err} 3482 } 3483 3484 if err := awsRestjson1_serializeOpHttpBindingsDescribeIAMPolicyAssignmentInput(input, restEncoder); err != nil { 3485 return out, metadata, &smithy.SerializationError{Err: err} 3486 } 3487 3488 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3489 return out, metadata, &smithy.SerializationError{Err: err} 3490 } 3491 in.Request = request 3492 3493 return next.HandleSerialize(ctx, in) 3494} 3495func awsRestjson1_serializeOpHttpBindingsDescribeIAMPolicyAssignmentInput(v *DescribeIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error { 3496 if v == nil { 3497 return fmt.Errorf("unsupported serialization of nil %T", v) 3498 } 3499 3500 if v.AssignmentName == nil || len(*v.AssignmentName) == 0 { 3501 return &smithy.SerializationError{Err: fmt.Errorf("input member AssignmentName must not be empty")} 3502 } 3503 if v.AssignmentName != nil { 3504 if err := encoder.SetURI("AssignmentName").String(*v.AssignmentName); err != nil { 3505 return err 3506 } 3507 } 3508 3509 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3510 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3511 } 3512 if v.AwsAccountId != nil { 3513 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3514 return err 3515 } 3516 } 3517 3518 if v.Namespace == nil || len(*v.Namespace) == 0 { 3519 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 3520 } 3521 if v.Namespace != nil { 3522 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 3523 return err 3524 } 3525 } 3526 3527 return nil 3528} 3529 3530type awsRestjson1_serializeOpDescribeIngestion struct { 3531} 3532 3533func (*awsRestjson1_serializeOpDescribeIngestion) ID() string { 3534 return "OperationSerializer" 3535} 3536 3537func (m *awsRestjson1_serializeOpDescribeIngestion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3538 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3539) { 3540 request, ok := in.Request.(*smithyhttp.Request) 3541 if !ok { 3542 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3543 } 3544 3545 input, ok := in.Parameters.(*DescribeIngestionInput) 3546 _ = input 3547 if !ok { 3548 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3549 } 3550 3551 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}") 3552 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3553 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3554 request.Method = "GET" 3555 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3556 if err != nil { 3557 return out, metadata, &smithy.SerializationError{Err: err} 3558 } 3559 3560 if err := awsRestjson1_serializeOpHttpBindingsDescribeIngestionInput(input, restEncoder); err != nil { 3561 return out, metadata, &smithy.SerializationError{Err: err} 3562 } 3563 3564 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3565 return out, metadata, &smithy.SerializationError{Err: err} 3566 } 3567 in.Request = request 3568 3569 return next.HandleSerialize(ctx, in) 3570} 3571func awsRestjson1_serializeOpHttpBindingsDescribeIngestionInput(v *DescribeIngestionInput, encoder *httpbinding.Encoder) error { 3572 if v == nil { 3573 return fmt.Errorf("unsupported serialization of nil %T", v) 3574 } 3575 3576 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3577 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3578 } 3579 if v.AwsAccountId != nil { 3580 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3581 return err 3582 } 3583 } 3584 3585 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 3586 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 3587 } 3588 if v.DataSetId != nil { 3589 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 3590 return err 3591 } 3592 } 3593 3594 if v.IngestionId == nil || len(*v.IngestionId) == 0 { 3595 return &smithy.SerializationError{Err: fmt.Errorf("input member IngestionId must not be empty")} 3596 } 3597 if v.IngestionId != nil { 3598 if err := encoder.SetURI("IngestionId").String(*v.IngestionId); err != nil { 3599 return err 3600 } 3601 } 3602 3603 return nil 3604} 3605 3606type awsRestjson1_serializeOpDescribeNamespace struct { 3607} 3608 3609func (*awsRestjson1_serializeOpDescribeNamespace) ID() string { 3610 return "OperationSerializer" 3611} 3612 3613func (m *awsRestjson1_serializeOpDescribeNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3614 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3615) { 3616 request, ok := in.Request.(*smithyhttp.Request) 3617 if !ok { 3618 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3619 } 3620 3621 input, ok := in.Parameters.(*DescribeNamespaceInput) 3622 _ = input 3623 if !ok { 3624 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3625 } 3626 3627 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}") 3628 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3629 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3630 request.Method = "GET" 3631 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3632 if err != nil { 3633 return out, metadata, &smithy.SerializationError{Err: err} 3634 } 3635 3636 if err := awsRestjson1_serializeOpHttpBindingsDescribeNamespaceInput(input, restEncoder); err != nil { 3637 return out, metadata, &smithy.SerializationError{Err: err} 3638 } 3639 3640 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3641 return out, metadata, &smithy.SerializationError{Err: err} 3642 } 3643 in.Request = request 3644 3645 return next.HandleSerialize(ctx, in) 3646} 3647func awsRestjson1_serializeOpHttpBindingsDescribeNamespaceInput(v *DescribeNamespaceInput, encoder *httpbinding.Encoder) error { 3648 if v == nil { 3649 return fmt.Errorf("unsupported serialization of nil %T", v) 3650 } 3651 3652 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3653 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3654 } 3655 if v.AwsAccountId != nil { 3656 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3657 return err 3658 } 3659 } 3660 3661 if v.Namespace == nil || len(*v.Namespace) == 0 { 3662 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 3663 } 3664 if v.Namespace != nil { 3665 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 3666 return err 3667 } 3668 } 3669 3670 return nil 3671} 3672 3673type awsRestjson1_serializeOpDescribeTemplate struct { 3674} 3675 3676func (*awsRestjson1_serializeOpDescribeTemplate) ID() string { 3677 return "OperationSerializer" 3678} 3679 3680func (m *awsRestjson1_serializeOpDescribeTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3681 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3682) { 3683 request, ok := in.Request.(*smithyhttp.Request) 3684 if !ok { 3685 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3686 } 3687 3688 input, ok := in.Parameters.(*DescribeTemplateInput) 3689 _ = input 3690 if !ok { 3691 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3692 } 3693 3694 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}") 3695 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3696 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3697 request.Method = "GET" 3698 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3699 if err != nil { 3700 return out, metadata, &smithy.SerializationError{Err: err} 3701 } 3702 3703 if err := awsRestjson1_serializeOpHttpBindingsDescribeTemplateInput(input, restEncoder); err != nil { 3704 return out, metadata, &smithy.SerializationError{Err: err} 3705 } 3706 3707 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3708 return out, metadata, &smithy.SerializationError{Err: err} 3709 } 3710 in.Request = request 3711 3712 return next.HandleSerialize(ctx, in) 3713} 3714func awsRestjson1_serializeOpHttpBindingsDescribeTemplateInput(v *DescribeTemplateInput, encoder *httpbinding.Encoder) error { 3715 if v == nil { 3716 return fmt.Errorf("unsupported serialization of nil %T", v) 3717 } 3718 3719 if v.AliasName != nil { 3720 encoder.SetQuery("alias-name").String(*v.AliasName) 3721 } 3722 3723 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3724 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3725 } 3726 if v.AwsAccountId != nil { 3727 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3728 return err 3729 } 3730 } 3731 3732 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 3733 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 3734 } 3735 if v.TemplateId != nil { 3736 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 3737 return err 3738 } 3739 } 3740 3741 if v.VersionNumber != nil { 3742 encoder.SetQuery("version-number").Long(*v.VersionNumber) 3743 } 3744 3745 return nil 3746} 3747 3748type awsRestjson1_serializeOpDescribeTemplateAlias struct { 3749} 3750 3751func (*awsRestjson1_serializeOpDescribeTemplateAlias) ID() string { 3752 return "OperationSerializer" 3753} 3754 3755func (m *awsRestjson1_serializeOpDescribeTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3756 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3757) { 3758 request, ok := in.Request.(*smithyhttp.Request) 3759 if !ok { 3760 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3761 } 3762 3763 input, ok := in.Parameters.(*DescribeTemplateAliasInput) 3764 _ = input 3765 if !ok { 3766 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3767 } 3768 3769 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}") 3770 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3771 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3772 request.Method = "GET" 3773 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3774 if err != nil { 3775 return out, metadata, &smithy.SerializationError{Err: err} 3776 } 3777 3778 if err := awsRestjson1_serializeOpHttpBindingsDescribeTemplateAliasInput(input, restEncoder); err != nil { 3779 return out, metadata, &smithy.SerializationError{Err: err} 3780 } 3781 3782 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3783 return out, metadata, &smithy.SerializationError{Err: err} 3784 } 3785 in.Request = request 3786 3787 return next.HandleSerialize(ctx, in) 3788} 3789func awsRestjson1_serializeOpHttpBindingsDescribeTemplateAliasInput(v *DescribeTemplateAliasInput, encoder *httpbinding.Encoder) error { 3790 if v == nil { 3791 return fmt.Errorf("unsupported serialization of nil %T", v) 3792 } 3793 3794 if v.AliasName == nil || len(*v.AliasName) == 0 { 3795 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 3796 } 3797 if v.AliasName != nil { 3798 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 3799 return err 3800 } 3801 } 3802 3803 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3804 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3805 } 3806 if v.AwsAccountId != nil { 3807 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3808 return err 3809 } 3810 } 3811 3812 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 3813 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 3814 } 3815 if v.TemplateId != nil { 3816 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 3817 return err 3818 } 3819 } 3820 3821 return nil 3822} 3823 3824type awsRestjson1_serializeOpDescribeTemplatePermissions struct { 3825} 3826 3827func (*awsRestjson1_serializeOpDescribeTemplatePermissions) ID() string { 3828 return "OperationSerializer" 3829} 3830 3831func (m *awsRestjson1_serializeOpDescribeTemplatePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3832 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3833) { 3834 request, ok := in.Request.(*smithyhttp.Request) 3835 if !ok { 3836 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3837 } 3838 3839 input, ok := in.Parameters.(*DescribeTemplatePermissionsInput) 3840 _ = input 3841 if !ok { 3842 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3843 } 3844 3845 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/permissions") 3846 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3847 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3848 request.Method = "GET" 3849 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3850 if err != nil { 3851 return out, metadata, &smithy.SerializationError{Err: err} 3852 } 3853 3854 if err := awsRestjson1_serializeOpHttpBindingsDescribeTemplatePermissionsInput(input, restEncoder); err != nil { 3855 return out, metadata, &smithy.SerializationError{Err: err} 3856 } 3857 3858 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3859 return out, metadata, &smithy.SerializationError{Err: err} 3860 } 3861 in.Request = request 3862 3863 return next.HandleSerialize(ctx, in) 3864} 3865func awsRestjson1_serializeOpHttpBindingsDescribeTemplatePermissionsInput(v *DescribeTemplatePermissionsInput, encoder *httpbinding.Encoder) error { 3866 if v == nil { 3867 return fmt.Errorf("unsupported serialization of nil %T", v) 3868 } 3869 3870 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3871 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3872 } 3873 if v.AwsAccountId != nil { 3874 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3875 return err 3876 } 3877 } 3878 3879 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 3880 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 3881 } 3882 if v.TemplateId != nil { 3883 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 3884 return err 3885 } 3886 } 3887 3888 return nil 3889} 3890 3891type awsRestjson1_serializeOpDescribeTheme struct { 3892} 3893 3894func (*awsRestjson1_serializeOpDescribeTheme) ID() string { 3895 return "OperationSerializer" 3896} 3897 3898func (m *awsRestjson1_serializeOpDescribeTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3899 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3900) { 3901 request, ok := in.Request.(*smithyhttp.Request) 3902 if !ok { 3903 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3904 } 3905 3906 input, ok := in.Parameters.(*DescribeThemeInput) 3907 _ = input 3908 if !ok { 3909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3910 } 3911 3912 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}") 3913 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3914 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3915 request.Method = "GET" 3916 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3917 if err != nil { 3918 return out, metadata, &smithy.SerializationError{Err: err} 3919 } 3920 3921 if err := awsRestjson1_serializeOpHttpBindingsDescribeThemeInput(input, restEncoder); err != nil { 3922 return out, metadata, &smithy.SerializationError{Err: err} 3923 } 3924 3925 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3926 return out, metadata, &smithy.SerializationError{Err: err} 3927 } 3928 in.Request = request 3929 3930 return next.HandleSerialize(ctx, in) 3931} 3932func awsRestjson1_serializeOpHttpBindingsDescribeThemeInput(v *DescribeThemeInput, encoder *httpbinding.Encoder) error { 3933 if v == nil { 3934 return fmt.Errorf("unsupported serialization of nil %T", v) 3935 } 3936 3937 if v.AliasName != nil { 3938 encoder.SetQuery("alias-name").String(*v.AliasName) 3939 } 3940 3941 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 3942 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 3943 } 3944 if v.AwsAccountId != nil { 3945 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 3946 return err 3947 } 3948 } 3949 3950 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 3951 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 3952 } 3953 if v.ThemeId != nil { 3954 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 3955 return err 3956 } 3957 } 3958 3959 if v.VersionNumber != nil { 3960 encoder.SetQuery("version-number").Long(*v.VersionNumber) 3961 } 3962 3963 return nil 3964} 3965 3966type awsRestjson1_serializeOpDescribeThemeAlias struct { 3967} 3968 3969func (*awsRestjson1_serializeOpDescribeThemeAlias) ID() string { 3970 return "OperationSerializer" 3971} 3972 3973func (m *awsRestjson1_serializeOpDescribeThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3974 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3975) { 3976 request, ok := in.Request.(*smithyhttp.Request) 3977 if !ok { 3978 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3979 } 3980 3981 input, ok := in.Parameters.(*DescribeThemeAliasInput) 3982 _ = input 3983 if !ok { 3984 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3985 } 3986 3987 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}") 3988 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3989 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3990 request.Method = "GET" 3991 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3992 if err != nil { 3993 return out, metadata, &smithy.SerializationError{Err: err} 3994 } 3995 3996 if err := awsRestjson1_serializeOpHttpBindingsDescribeThemeAliasInput(input, restEncoder); err != nil { 3997 return out, metadata, &smithy.SerializationError{Err: err} 3998 } 3999 4000 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4001 return out, metadata, &smithy.SerializationError{Err: err} 4002 } 4003 in.Request = request 4004 4005 return next.HandleSerialize(ctx, in) 4006} 4007func awsRestjson1_serializeOpHttpBindingsDescribeThemeAliasInput(v *DescribeThemeAliasInput, encoder *httpbinding.Encoder) error { 4008 if v == nil { 4009 return fmt.Errorf("unsupported serialization of nil %T", v) 4010 } 4011 4012 if v.AliasName == nil || len(*v.AliasName) == 0 { 4013 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 4014 } 4015 if v.AliasName != nil { 4016 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 4017 return err 4018 } 4019 } 4020 4021 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4022 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4023 } 4024 if v.AwsAccountId != nil { 4025 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4026 return err 4027 } 4028 } 4029 4030 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 4031 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 4032 } 4033 if v.ThemeId != nil { 4034 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 4035 return err 4036 } 4037 } 4038 4039 return nil 4040} 4041 4042type awsRestjson1_serializeOpDescribeThemePermissions struct { 4043} 4044 4045func (*awsRestjson1_serializeOpDescribeThemePermissions) ID() string { 4046 return "OperationSerializer" 4047} 4048 4049func (m *awsRestjson1_serializeOpDescribeThemePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4050 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4051) { 4052 request, ok := in.Request.(*smithyhttp.Request) 4053 if !ok { 4054 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4055 } 4056 4057 input, ok := in.Parameters.(*DescribeThemePermissionsInput) 4058 _ = input 4059 if !ok { 4060 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4061 } 4062 4063 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/permissions") 4064 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4065 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4066 request.Method = "GET" 4067 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4068 if err != nil { 4069 return out, metadata, &smithy.SerializationError{Err: err} 4070 } 4071 4072 if err := awsRestjson1_serializeOpHttpBindingsDescribeThemePermissionsInput(input, restEncoder); err != nil { 4073 return out, metadata, &smithy.SerializationError{Err: err} 4074 } 4075 4076 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4077 return out, metadata, &smithy.SerializationError{Err: err} 4078 } 4079 in.Request = request 4080 4081 return next.HandleSerialize(ctx, in) 4082} 4083func awsRestjson1_serializeOpHttpBindingsDescribeThemePermissionsInput(v *DescribeThemePermissionsInput, encoder *httpbinding.Encoder) error { 4084 if v == nil { 4085 return fmt.Errorf("unsupported serialization of nil %T", v) 4086 } 4087 4088 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4089 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4090 } 4091 if v.AwsAccountId != nil { 4092 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4093 return err 4094 } 4095 } 4096 4097 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 4098 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 4099 } 4100 if v.ThemeId != nil { 4101 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 4102 return err 4103 } 4104 } 4105 4106 return nil 4107} 4108 4109type awsRestjson1_serializeOpDescribeUser struct { 4110} 4111 4112func (*awsRestjson1_serializeOpDescribeUser) ID() string { 4113 return "OperationSerializer" 4114} 4115 4116func (m *awsRestjson1_serializeOpDescribeUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4117 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4118) { 4119 request, ok := in.Request.(*smithyhttp.Request) 4120 if !ok { 4121 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4122 } 4123 4124 input, ok := in.Parameters.(*DescribeUserInput) 4125 _ = input 4126 if !ok { 4127 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4128 } 4129 4130 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}") 4131 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4132 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4133 request.Method = "GET" 4134 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4135 if err != nil { 4136 return out, metadata, &smithy.SerializationError{Err: err} 4137 } 4138 4139 if err := awsRestjson1_serializeOpHttpBindingsDescribeUserInput(input, restEncoder); err != nil { 4140 return out, metadata, &smithy.SerializationError{Err: err} 4141 } 4142 4143 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4144 return out, metadata, &smithy.SerializationError{Err: err} 4145 } 4146 in.Request = request 4147 4148 return next.HandleSerialize(ctx, in) 4149} 4150func awsRestjson1_serializeOpHttpBindingsDescribeUserInput(v *DescribeUserInput, encoder *httpbinding.Encoder) error { 4151 if v == nil { 4152 return fmt.Errorf("unsupported serialization of nil %T", v) 4153 } 4154 4155 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4156 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4157 } 4158 if v.AwsAccountId != nil { 4159 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4160 return err 4161 } 4162 } 4163 4164 if v.Namespace == nil || len(*v.Namespace) == 0 { 4165 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 4166 } 4167 if v.Namespace != nil { 4168 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 4169 return err 4170 } 4171 } 4172 4173 if v.UserName == nil || len(*v.UserName) == 0 { 4174 return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")} 4175 } 4176 if v.UserName != nil { 4177 if err := encoder.SetURI("UserName").String(*v.UserName); err != nil { 4178 return err 4179 } 4180 } 4181 4182 return nil 4183} 4184 4185type awsRestjson1_serializeOpGetDashboardEmbedUrl struct { 4186} 4187 4188func (*awsRestjson1_serializeOpGetDashboardEmbedUrl) ID() string { 4189 return "OperationSerializer" 4190} 4191 4192func (m *awsRestjson1_serializeOpGetDashboardEmbedUrl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4193 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4194) { 4195 request, ok := in.Request.(*smithyhttp.Request) 4196 if !ok { 4197 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4198 } 4199 4200 input, ok := in.Parameters.(*GetDashboardEmbedUrlInput) 4201 _ = input 4202 if !ok { 4203 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4204 } 4205 4206 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/embed-url") 4207 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4208 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4209 request.Method = "GET" 4210 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4211 if err != nil { 4212 return out, metadata, &smithy.SerializationError{Err: err} 4213 } 4214 4215 if err := awsRestjson1_serializeOpHttpBindingsGetDashboardEmbedUrlInput(input, restEncoder); err != nil { 4216 return out, metadata, &smithy.SerializationError{Err: err} 4217 } 4218 4219 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4220 return out, metadata, &smithy.SerializationError{Err: err} 4221 } 4222 in.Request = request 4223 4224 return next.HandleSerialize(ctx, in) 4225} 4226func awsRestjson1_serializeOpHttpBindingsGetDashboardEmbedUrlInput(v *GetDashboardEmbedUrlInput, encoder *httpbinding.Encoder) error { 4227 if v == nil { 4228 return fmt.Errorf("unsupported serialization of nil %T", v) 4229 } 4230 4231 if v.AdditionalDashboardIds != nil { 4232 for i := range v.AdditionalDashboardIds { 4233 encoder.AddQuery("additional-dashboard-ids").String(v.AdditionalDashboardIds[i]) 4234 } 4235 } 4236 4237 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4238 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4239 } 4240 if v.AwsAccountId != nil { 4241 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4242 return err 4243 } 4244 } 4245 4246 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 4247 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 4248 } 4249 if v.DashboardId != nil { 4250 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 4251 return err 4252 } 4253 } 4254 4255 if len(v.IdentityType) > 0 { 4256 encoder.SetQuery("creds-type").String(string(v.IdentityType)) 4257 } 4258 4259 if v.Namespace != nil { 4260 encoder.SetQuery("namespace").String(*v.Namespace) 4261 } 4262 4263 if v.ResetDisabled { 4264 encoder.SetQuery("reset-disabled").Boolean(v.ResetDisabled) 4265 } 4266 4267 if v.SessionLifetimeInMinutes != nil { 4268 encoder.SetQuery("session-lifetime").Long(*v.SessionLifetimeInMinutes) 4269 } 4270 4271 if v.StatePersistenceEnabled { 4272 encoder.SetQuery("state-persistence-enabled").Boolean(v.StatePersistenceEnabled) 4273 } 4274 4275 if v.UndoRedoDisabled { 4276 encoder.SetQuery("undo-redo-disabled").Boolean(v.UndoRedoDisabled) 4277 } 4278 4279 if v.UserArn != nil { 4280 encoder.SetQuery("user-arn").String(*v.UserArn) 4281 } 4282 4283 return nil 4284} 4285 4286type awsRestjson1_serializeOpGetSessionEmbedUrl struct { 4287} 4288 4289func (*awsRestjson1_serializeOpGetSessionEmbedUrl) ID() string { 4290 return "OperationSerializer" 4291} 4292 4293func (m *awsRestjson1_serializeOpGetSessionEmbedUrl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4294 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4295) { 4296 request, ok := in.Request.(*smithyhttp.Request) 4297 if !ok { 4298 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4299 } 4300 4301 input, ok := in.Parameters.(*GetSessionEmbedUrlInput) 4302 _ = input 4303 if !ok { 4304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4305 } 4306 4307 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/session-embed-url") 4308 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4309 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4310 request.Method = "GET" 4311 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4312 if err != nil { 4313 return out, metadata, &smithy.SerializationError{Err: err} 4314 } 4315 4316 if err := awsRestjson1_serializeOpHttpBindingsGetSessionEmbedUrlInput(input, restEncoder); err != nil { 4317 return out, metadata, &smithy.SerializationError{Err: err} 4318 } 4319 4320 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4321 return out, metadata, &smithy.SerializationError{Err: err} 4322 } 4323 in.Request = request 4324 4325 return next.HandleSerialize(ctx, in) 4326} 4327func awsRestjson1_serializeOpHttpBindingsGetSessionEmbedUrlInput(v *GetSessionEmbedUrlInput, encoder *httpbinding.Encoder) error { 4328 if v == nil { 4329 return fmt.Errorf("unsupported serialization of nil %T", v) 4330 } 4331 4332 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4333 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4334 } 4335 if v.AwsAccountId != nil { 4336 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4337 return err 4338 } 4339 } 4340 4341 if v.EntryPoint != nil { 4342 encoder.SetQuery("entry-point").String(*v.EntryPoint) 4343 } 4344 4345 if v.SessionLifetimeInMinutes != nil { 4346 encoder.SetQuery("session-lifetime").Long(*v.SessionLifetimeInMinutes) 4347 } 4348 4349 if v.UserArn != nil { 4350 encoder.SetQuery("user-arn").String(*v.UserArn) 4351 } 4352 4353 return nil 4354} 4355 4356type awsRestjson1_serializeOpListAnalyses struct { 4357} 4358 4359func (*awsRestjson1_serializeOpListAnalyses) ID() string { 4360 return "OperationSerializer" 4361} 4362 4363func (m *awsRestjson1_serializeOpListAnalyses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4364 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4365) { 4366 request, ok := in.Request.(*smithyhttp.Request) 4367 if !ok { 4368 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4369 } 4370 4371 input, ok := in.Parameters.(*ListAnalysesInput) 4372 _ = input 4373 if !ok { 4374 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4375 } 4376 4377 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses") 4378 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4379 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4380 request.Method = "GET" 4381 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4382 if err != nil { 4383 return out, metadata, &smithy.SerializationError{Err: err} 4384 } 4385 4386 if err := awsRestjson1_serializeOpHttpBindingsListAnalysesInput(input, restEncoder); err != nil { 4387 return out, metadata, &smithy.SerializationError{Err: err} 4388 } 4389 4390 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4391 return out, metadata, &smithy.SerializationError{Err: err} 4392 } 4393 in.Request = request 4394 4395 return next.HandleSerialize(ctx, in) 4396} 4397func awsRestjson1_serializeOpHttpBindingsListAnalysesInput(v *ListAnalysesInput, encoder *httpbinding.Encoder) error { 4398 if v == nil { 4399 return fmt.Errorf("unsupported serialization of nil %T", v) 4400 } 4401 4402 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4403 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4404 } 4405 if v.AwsAccountId != nil { 4406 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4407 return err 4408 } 4409 } 4410 4411 if v.MaxResults != 0 { 4412 encoder.SetQuery("max-results").Integer(v.MaxResults) 4413 } 4414 4415 if v.NextToken != nil { 4416 encoder.SetQuery("next-token").String(*v.NextToken) 4417 } 4418 4419 return nil 4420} 4421 4422type awsRestjson1_serializeOpListDashboards struct { 4423} 4424 4425func (*awsRestjson1_serializeOpListDashboards) ID() string { 4426 return "OperationSerializer" 4427} 4428 4429func (m *awsRestjson1_serializeOpListDashboards) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4430 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4431) { 4432 request, ok := in.Request.(*smithyhttp.Request) 4433 if !ok { 4434 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4435 } 4436 4437 input, ok := in.Parameters.(*ListDashboardsInput) 4438 _ = input 4439 if !ok { 4440 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4441 } 4442 4443 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards") 4444 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4445 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4446 request.Method = "GET" 4447 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4448 if err != nil { 4449 return out, metadata, &smithy.SerializationError{Err: err} 4450 } 4451 4452 if err := awsRestjson1_serializeOpHttpBindingsListDashboardsInput(input, restEncoder); err != nil { 4453 return out, metadata, &smithy.SerializationError{Err: err} 4454 } 4455 4456 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4457 return out, metadata, &smithy.SerializationError{Err: err} 4458 } 4459 in.Request = request 4460 4461 return next.HandleSerialize(ctx, in) 4462} 4463func awsRestjson1_serializeOpHttpBindingsListDashboardsInput(v *ListDashboardsInput, encoder *httpbinding.Encoder) error { 4464 if v == nil { 4465 return fmt.Errorf("unsupported serialization of nil %T", v) 4466 } 4467 4468 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4469 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4470 } 4471 if v.AwsAccountId != nil { 4472 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4473 return err 4474 } 4475 } 4476 4477 if v.MaxResults != 0 { 4478 encoder.SetQuery("max-results").Integer(v.MaxResults) 4479 } 4480 4481 if v.NextToken != nil { 4482 encoder.SetQuery("next-token").String(*v.NextToken) 4483 } 4484 4485 return nil 4486} 4487 4488type awsRestjson1_serializeOpListDashboardVersions struct { 4489} 4490 4491func (*awsRestjson1_serializeOpListDashboardVersions) ID() string { 4492 return "OperationSerializer" 4493} 4494 4495func (m *awsRestjson1_serializeOpListDashboardVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4496 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4497) { 4498 request, ok := in.Request.(*smithyhttp.Request) 4499 if !ok { 4500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4501 } 4502 4503 input, ok := in.Parameters.(*ListDashboardVersionsInput) 4504 _ = input 4505 if !ok { 4506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4507 } 4508 4509 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/versions") 4510 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4511 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4512 request.Method = "GET" 4513 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4514 if err != nil { 4515 return out, metadata, &smithy.SerializationError{Err: err} 4516 } 4517 4518 if err := awsRestjson1_serializeOpHttpBindingsListDashboardVersionsInput(input, restEncoder); err != nil { 4519 return out, metadata, &smithy.SerializationError{Err: err} 4520 } 4521 4522 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4523 return out, metadata, &smithy.SerializationError{Err: err} 4524 } 4525 in.Request = request 4526 4527 return next.HandleSerialize(ctx, in) 4528} 4529func awsRestjson1_serializeOpHttpBindingsListDashboardVersionsInput(v *ListDashboardVersionsInput, encoder *httpbinding.Encoder) error { 4530 if v == nil { 4531 return fmt.Errorf("unsupported serialization of nil %T", v) 4532 } 4533 4534 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4535 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4536 } 4537 if v.AwsAccountId != nil { 4538 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4539 return err 4540 } 4541 } 4542 4543 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 4544 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 4545 } 4546 if v.DashboardId != nil { 4547 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 4548 return err 4549 } 4550 } 4551 4552 if v.MaxResults != 0 { 4553 encoder.SetQuery("max-results").Integer(v.MaxResults) 4554 } 4555 4556 if v.NextToken != nil { 4557 encoder.SetQuery("next-token").String(*v.NextToken) 4558 } 4559 4560 return nil 4561} 4562 4563type awsRestjson1_serializeOpListDataSets struct { 4564} 4565 4566func (*awsRestjson1_serializeOpListDataSets) ID() string { 4567 return "OperationSerializer" 4568} 4569 4570func (m *awsRestjson1_serializeOpListDataSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4571 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4572) { 4573 request, ok := in.Request.(*smithyhttp.Request) 4574 if !ok { 4575 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4576 } 4577 4578 input, ok := in.Parameters.(*ListDataSetsInput) 4579 _ = input 4580 if !ok { 4581 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4582 } 4583 4584 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets") 4585 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4586 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4587 request.Method = "GET" 4588 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4589 if err != nil { 4590 return out, metadata, &smithy.SerializationError{Err: err} 4591 } 4592 4593 if err := awsRestjson1_serializeOpHttpBindingsListDataSetsInput(input, restEncoder); err != nil { 4594 return out, metadata, &smithy.SerializationError{Err: err} 4595 } 4596 4597 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4598 return out, metadata, &smithy.SerializationError{Err: err} 4599 } 4600 in.Request = request 4601 4602 return next.HandleSerialize(ctx, in) 4603} 4604func awsRestjson1_serializeOpHttpBindingsListDataSetsInput(v *ListDataSetsInput, encoder *httpbinding.Encoder) error { 4605 if v == nil { 4606 return fmt.Errorf("unsupported serialization of nil %T", v) 4607 } 4608 4609 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4610 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4611 } 4612 if v.AwsAccountId != nil { 4613 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4614 return err 4615 } 4616 } 4617 4618 if v.MaxResults != 0 { 4619 encoder.SetQuery("max-results").Integer(v.MaxResults) 4620 } 4621 4622 if v.NextToken != nil { 4623 encoder.SetQuery("next-token").String(*v.NextToken) 4624 } 4625 4626 return nil 4627} 4628 4629type awsRestjson1_serializeOpListDataSources struct { 4630} 4631 4632func (*awsRestjson1_serializeOpListDataSources) ID() string { 4633 return "OperationSerializer" 4634} 4635 4636func (m *awsRestjson1_serializeOpListDataSources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4637 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4638) { 4639 request, ok := in.Request.(*smithyhttp.Request) 4640 if !ok { 4641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4642 } 4643 4644 input, ok := in.Parameters.(*ListDataSourcesInput) 4645 _ = input 4646 if !ok { 4647 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4648 } 4649 4650 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources") 4651 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4652 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4653 request.Method = "GET" 4654 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4655 if err != nil { 4656 return out, metadata, &smithy.SerializationError{Err: err} 4657 } 4658 4659 if err := awsRestjson1_serializeOpHttpBindingsListDataSourcesInput(input, restEncoder); err != nil { 4660 return out, metadata, &smithy.SerializationError{Err: err} 4661 } 4662 4663 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4664 return out, metadata, &smithy.SerializationError{Err: err} 4665 } 4666 in.Request = request 4667 4668 return next.HandleSerialize(ctx, in) 4669} 4670func awsRestjson1_serializeOpHttpBindingsListDataSourcesInput(v *ListDataSourcesInput, encoder *httpbinding.Encoder) error { 4671 if v == nil { 4672 return fmt.Errorf("unsupported serialization of nil %T", v) 4673 } 4674 4675 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4676 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4677 } 4678 if v.AwsAccountId != nil { 4679 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4680 return err 4681 } 4682 } 4683 4684 if v.MaxResults != 0 { 4685 encoder.SetQuery("max-results").Integer(v.MaxResults) 4686 } 4687 4688 if v.NextToken != nil { 4689 encoder.SetQuery("next-token").String(*v.NextToken) 4690 } 4691 4692 return nil 4693} 4694 4695type awsRestjson1_serializeOpListGroupMemberships struct { 4696} 4697 4698func (*awsRestjson1_serializeOpListGroupMemberships) ID() string { 4699 return "OperationSerializer" 4700} 4701 4702func (m *awsRestjson1_serializeOpListGroupMemberships) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4703 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4704) { 4705 request, ok := in.Request.(*smithyhttp.Request) 4706 if !ok { 4707 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4708 } 4709 4710 input, ok := in.Parameters.(*ListGroupMembershipsInput) 4711 _ = input 4712 if !ok { 4713 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4714 } 4715 4716 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members") 4717 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4718 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4719 request.Method = "GET" 4720 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4721 if err != nil { 4722 return out, metadata, &smithy.SerializationError{Err: err} 4723 } 4724 4725 if err := awsRestjson1_serializeOpHttpBindingsListGroupMembershipsInput(input, restEncoder); err != nil { 4726 return out, metadata, &smithy.SerializationError{Err: err} 4727 } 4728 4729 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4730 return out, metadata, &smithy.SerializationError{Err: err} 4731 } 4732 in.Request = request 4733 4734 return next.HandleSerialize(ctx, in) 4735} 4736func awsRestjson1_serializeOpHttpBindingsListGroupMembershipsInput(v *ListGroupMembershipsInput, encoder *httpbinding.Encoder) error { 4737 if v == nil { 4738 return fmt.Errorf("unsupported serialization of nil %T", v) 4739 } 4740 4741 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4742 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4743 } 4744 if v.AwsAccountId != nil { 4745 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4746 return err 4747 } 4748 } 4749 4750 if v.GroupName == nil || len(*v.GroupName) == 0 { 4751 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")} 4752 } 4753 if v.GroupName != nil { 4754 if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil { 4755 return err 4756 } 4757 } 4758 4759 if v.MaxResults != 0 { 4760 encoder.SetQuery("max-results").Integer(v.MaxResults) 4761 } 4762 4763 if v.Namespace == nil || len(*v.Namespace) == 0 { 4764 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 4765 } 4766 if v.Namespace != nil { 4767 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 4768 return err 4769 } 4770 } 4771 4772 if v.NextToken != nil { 4773 encoder.SetQuery("next-token").String(*v.NextToken) 4774 } 4775 4776 return nil 4777} 4778 4779type awsRestjson1_serializeOpListGroups struct { 4780} 4781 4782func (*awsRestjson1_serializeOpListGroups) ID() string { 4783 return "OperationSerializer" 4784} 4785 4786func (m *awsRestjson1_serializeOpListGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4787 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4788) { 4789 request, ok := in.Request.(*smithyhttp.Request) 4790 if !ok { 4791 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4792 } 4793 4794 input, ok := in.Parameters.(*ListGroupsInput) 4795 _ = input 4796 if !ok { 4797 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4798 } 4799 4800 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups") 4801 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4802 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4803 request.Method = "GET" 4804 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4805 if err != nil { 4806 return out, metadata, &smithy.SerializationError{Err: err} 4807 } 4808 4809 if err := awsRestjson1_serializeOpHttpBindingsListGroupsInput(input, restEncoder); err != nil { 4810 return out, metadata, &smithy.SerializationError{Err: err} 4811 } 4812 4813 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4814 return out, metadata, &smithy.SerializationError{Err: err} 4815 } 4816 in.Request = request 4817 4818 return next.HandleSerialize(ctx, in) 4819} 4820func awsRestjson1_serializeOpHttpBindingsListGroupsInput(v *ListGroupsInput, encoder *httpbinding.Encoder) error { 4821 if v == nil { 4822 return fmt.Errorf("unsupported serialization of nil %T", v) 4823 } 4824 4825 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4826 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4827 } 4828 if v.AwsAccountId != nil { 4829 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4830 return err 4831 } 4832 } 4833 4834 if v.MaxResults != 0 { 4835 encoder.SetQuery("max-results").Integer(v.MaxResults) 4836 } 4837 4838 if v.Namespace == nil || len(*v.Namespace) == 0 { 4839 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 4840 } 4841 if v.Namespace != nil { 4842 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 4843 return err 4844 } 4845 } 4846 4847 if v.NextToken != nil { 4848 encoder.SetQuery("next-token").String(*v.NextToken) 4849 } 4850 4851 return nil 4852} 4853 4854type awsRestjson1_serializeOpListIAMPolicyAssignments struct { 4855} 4856 4857func (*awsRestjson1_serializeOpListIAMPolicyAssignments) ID() string { 4858 return "OperationSerializer" 4859} 4860 4861func (m *awsRestjson1_serializeOpListIAMPolicyAssignments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4862 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4863) { 4864 request, ok := in.Request.(*smithyhttp.Request) 4865 if !ok { 4866 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4867 } 4868 4869 input, ok := in.Parameters.(*ListIAMPolicyAssignmentsInput) 4870 _ = input 4871 if !ok { 4872 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4873 } 4874 4875 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments") 4876 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4877 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4878 request.Method = "GET" 4879 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4880 if err != nil { 4881 return out, metadata, &smithy.SerializationError{Err: err} 4882 } 4883 4884 if err := awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsInput(input, restEncoder); err != nil { 4885 return out, metadata, &smithy.SerializationError{Err: err} 4886 } 4887 4888 restEncoder.SetHeader("Content-Type").String("application/json") 4889 4890 jsonEncoder := smithyjson.NewEncoder() 4891 if err := awsRestjson1_serializeOpDocumentListIAMPolicyAssignmentsInput(input, jsonEncoder.Value); err != nil { 4892 return out, metadata, &smithy.SerializationError{Err: err} 4893 } 4894 4895 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4896 return out, metadata, &smithy.SerializationError{Err: err} 4897 } 4898 4899 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4900 return out, metadata, &smithy.SerializationError{Err: err} 4901 } 4902 in.Request = request 4903 4904 return next.HandleSerialize(ctx, in) 4905} 4906func awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsInput(v *ListIAMPolicyAssignmentsInput, encoder *httpbinding.Encoder) error { 4907 if v == nil { 4908 return fmt.Errorf("unsupported serialization of nil %T", v) 4909 } 4910 4911 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4912 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 4913 } 4914 if v.AwsAccountId != nil { 4915 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 4916 return err 4917 } 4918 } 4919 4920 if v.MaxResults != 0 { 4921 encoder.SetQuery("max-results").Integer(v.MaxResults) 4922 } 4923 4924 if v.Namespace == nil || len(*v.Namespace) == 0 { 4925 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 4926 } 4927 if v.Namespace != nil { 4928 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 4929 return err 4930 } 4931 } 4932 4933 if v.NextToken != nil { 4934 encoder.SetQuery("next-token").String(*v.NextToken) 4935 } 4936 4937 return nil 4938} 4939 4940func awsRestjson1_serializeOpDocumentListIAMPolicyAssignmentsInput(v *ListIAMPolicyAssignmentsInput, value smithyjson.Value) error { 4941 object := value.Object() 4942 defer object.Close() 4943 4944 if len(v.AssignmentStatus) > 0 { 4945 ok := object.Key("AssignmentStatus") 4946 ok.String(string(v.AssignmentStatus)) 4947 } 4948 4949 return nil 4950} 4951 4952type awsRestjson1_serializeOpListIAMPolicyAssignmentsForUser struct { 4953} 4954 4955func (*awsRestjson1_serializeOpListIAMPolicyAssignmentsForUser) ID() string { 4956 return "OperationSerializer" 4957} 4958 4959func (m *awsRestjson1_serializeOpListIAMPolicyAssignmentsForUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4960 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4961) { 4962 request, ok := in.Request.(*smithyhttp.Request) 4963 if !ok { 4964 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4965 } 4966 4967 input, ok := in.Parameters.(*ListIAMPolicyAssignmentsForUserInput) 4968 _ = input 4969 if !ok { 4970 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4971 } 4972 4973 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}/iam-policy-assignments") 4974 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4975 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4976 request.Method = "GET" 4977 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4978 if err != nil { 4979 return out, metadata, &smithy.SerializationError{Err: err} 4980 } 4981 4982 if err := awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsForUserInput(input, restEncoder); err != nil { 4983 return out, metadata, &smithy.SerializationError{Err: err} 4984 } 4985 4986 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4987 return out, metadata, &smithy.SerializationError{Err: err} 4988 } 4989 in.Request = request 4990 4991 return next.HandleSerialize(ctx, in) 4992} 4993func awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsForUserInput(v *ListIAMPolicyAssignmentsForUserInput, encoder *httpbinding.Encoder) error { 4994 if v == nil { 4995 return fmt.Errorf("unsupported serialization of nil %T", v) 4996 } 4997 4998 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 4999 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5000 } 5001 if v.AwsAccountId != nil { 5002 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5003 return err 5004 } 5005 } 5006 5007 if v.MaxResults != 0 { 5008 encoder.SetQuery("max-results").Integer(v.MaxResults) 5009 } 5010 5011 if v.Namespace == nil || len(*v.Namespace) == 0 { 5012 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 5013 } 5014 if v.Namespace != nil { 5015 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 5016 return err 5017 } 5018 } 5019 5020 if v.NextToken != nil { 5021 encoder.SetQuery("next-token").String(*v.NextToken) 5022 } 5023 5024 if v.UserName == nil || len(*v.UserName) == 0 { 5025 return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")} 5026 } 5027 if v.UserName != nil { 5028 if err := encoder.SetURI("UserName").String(*v.UserName); err != nil { 5029 return err 5030 } 5031 } 5032 5033 return nil 5034} 5035 5036type awsRestjson1_serializeOpListIngestions struct { 5037} 5038 5039func (*awsRestjson1_serializeOpListIngestions) ID() string { 5040 return "OperationSerializer" 5041} 5042 5043func (m *awsRestjson1_serializeOpListIngestions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5044 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5045) { 5046 request, ok := in.Request.(*smithyhttp.Request) 5047 if !ok { 5048 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5049 } 5050 5051 input, ok := in.Parameters.(*ListIngestionsInput) 5052 _ = input 5053 if !ok { 5054 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5055 } 5056 5057 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions") 5058 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5059 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5060 request.Method = "GET" 5061 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5062 if err != nil { 5063 return out, metadata, &smithy.SerializationError{Err: err} 5064 } 5065 5066 if err := awsRestjson1_serializeOpHttpBindingsListIngestionsInput(input, restEncoder); err != nil { 5067 return out, metadata, &smithy.SerializationError{Err: err} 5068 } 5069 5070 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5071 return out, metadata, &smithy.SerializationError{Err: err} 5072 } 5073 in.Request = request 5074 5075 return next.HandleSerialize(ctx, in) 5076} 5077func awsRestjson1_serializeOpHttpBindingsListIngestionsInput(v *ListIngestionsInput, encoder *httpbinding.Encoder) error { 5078 if v == nil { 5079 return fmt.Errorf("unsupported serialization of nil %T", v) 5080 } 5081 5082 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5083 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5084 } 5085 if v.AwsAccountId != nil { 5086 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5087 return err 5088 } 5089 } 5090 5091 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 5092 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 5093 } 5094 if v.DataSetId != nil { 5095 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 5096 return err 5097 } 5098 } 5099 5100 if v.MaxResults != 0 { 5101 encoder.SetQuery("max-results").Integer(v.MaxResults) 5102 } 5103 5104 if v.NextToken != nil { 5105 encoder.SetQuery("next-token").String(*v.NextToken) 5106 } 5107 5108 return nil 5109} 5110 5111type awsRestjson1_serializeOpListNamespaces struct { 5112} 5113 5114func (*awsRestjson1_serializeOpListNamespaces) ID() string { 5115 return "OperationSerializer" 5116} 5117 5118func (m *awsRestjson1_serializeOpListNamespaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5119 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5120) { 5121 request, ok := in.Request.(*smithyhttp.Request) 5122 if !ok { 5123 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5124 } 5125 5126 input, ok := in.Parameters.(*ListNamespacesInput) 5127 _ = input 5128 if !ok { 5129 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5130 } 5131 5132 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces") 5133 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5134 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5135 request.Method = "GET" 5136 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5137 if err != nil { 5138 return out, metadata, &smithy.SerializationError{Err: err} 5139 } 5140 5141 if err := awsRestjson1_serializeOpHttpBindingsListNamespacesInput(input, restEncoder); err != nil { 5142 return out, metadata, &smithy.SerializationError{Err: err} 5143 } 5144 5145 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5146 return out, metadata, &smithy.SerializationError{Err: err} 5147 } 5148 in.Request = request 5149 5150 return next.HandleSerialize(ctx, in) 5151} 5152func awsRestjson1_serializeOpHttpBindingsListNamespacesInput(v *ListNamespacesInput, encoder *httpbinding.Encoder) error { 5153 if v == nil { 5154 return fmt.Errorf("unsupported serialization of nil %T", v) 5155 } 5156 5157 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5158 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5159 } 5160 if v.AwsAccountId != nil { 5161 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5162 return err 5163 } 5164 } 5165 5166 if v.MaxResults != 0 { 5167 encoder.SetQuery("max-results").Integer(v.MaxResults) 5168 } 5169 5170 if v.NextToken != nil { 5171 encoder.SetQuery("next-token").String(*v.NextToken) 5172 } 5173 5174 return nil 5175} 5176 5177type awsRestjson1_serializeOpListTagsForResource struct { 5178} 5179 5180func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 5181 return "OperationSerializer" 5182} 5183 5184func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5185 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5186) { 5187 request, ok := in.Request.(*smithyhttp.Request) 5188 if !ok { 5189 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5190 } 5191 5192 input, ok := in.Parameters.(*ListTagsForResourceInput) 5193 _ = input 5194 if !ok { 5195 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5196 } 5197 5198 opPath, opQuery := httpbinding.SplitURI("/resources/{ResourceArn}/tags") 5199 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5200 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5201 request.Method = "GET" 5202 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5203 if err != nil { 5204 return out, metadata, &smithy.SerializationError{Err: err} 5205 } 5206 5207 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 5208 return out, metadata, &smithy.SerializationError{Err: err} 5209 } 5210 5211 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5212 return out, metadata, &smithy.SerializationError{Err: err} 5213 } 5214 in.Request = request 5215 5216 return next.HandleSerialize(ctx, in) 5217} 5218func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 5219 if v == nil { 5220 return fmt.Errorf("unsupported serialization of nil %T", v) 5221 } 5222 5223 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 5224 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 5225 } 5226 if v.ResourceArn != nil { 5227 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 5228 return err 5229 } 5230 } 5231 5232 return nil 5233} 5234 5235type awsRestjson1_serializeOpListTemplateAliases struct { 5236} 5237 5238func (*awsRestjson1_serializeOpListTemplateAliases) ID() string { 5239 return "OperationSerializer" 5240} 5241 5242func (m *awsRestjson1_serializeOpListTemplateAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5243 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5244) { 5245 request, ok := in.Request.(*smithyhttp.Request) 5246 if !ok { 5247 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5248 } 5249 5250 input, ok := in.Parameters.(*ListTemplateAliasesInput) 5251 _ = input 5252 if !ok { 5253 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5254 } 5255 5256 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases") 5257 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5258 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5259 request.Method = "GET" 5260 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5261 if err != nil { 5262 return out, metadata, &smithy.SerializationError{Err: err} 5263 } 5264 5265 if err := awsRestjson1_serializeOpHttpBindingsListTemplateAliasesInput(input, restEncoder); err != nil { 5266 return out, metadata, &smithy.SerializationError{Err: err} 5267 } 5268 5269 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5270 return out, metadata, &smithy.SerializationError{Err: err} 5271 } 5272 in.Request = request 5273 5274 return next.HandleSerialize(ctx, in) 5275} 5276func awsRestjson1_serializeOpHttpBindingsListTemplateAliasesInput(v *ListTemplateAliasesInput, encoder *httpbinding.Encoder) error { 5277 if v == nil { 5278 return fmt.Errorf("unsupported serialization of nil %T", v) 5279 } 5280 5281 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5282 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5283 } 5284 if v.AwsAccountId != nil { 5285 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5286 return err 5287 } 5288 } 5289 5290 if v.MaxResults != 0 { 5291 encoder.SetQuery("max-result").Integer(v.MaxResults) 5292 } 5293 5294 if v.NextToken != nil { 5295 encoder.SetQuery("next-token").String(*v.NextToken) 5296 } 5297 5298 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 5299 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 5300 } 5301 if v.TemplateId != nil { 5302 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 5303 return err 5304 } 5305 } 5306 5307 return nil 5308} 5309 5310type awsRestjson1_serializeOpListTemplates struct { 5311} 5312 5313func (*awsRestjson1_serializeOpListTemplates) ID() string { 5314 return "OperationSerializer" 5315} 5316 5317func (m *awsRestjson1_serializeOpListTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5318 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5319) { 5320 request, ok := in.Request.(*smithyhttp.Request) 5321 if !ok { 5322 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5323 } 5324 5325 input, ok := in.Parameters.(*ListTemplatesInput) 5326 _ = input 5327 if !ok { 5328 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5329 } 5330 5331 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates") 5332 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5333 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5334 request.Method = "GET" 5335 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5336 if err != nil { 5337 return out, metadata, &smithy.SerializationError{Err: err} 5338 } 5339 5340 if err := awsRestjson1_serializeOpHttpBindingsListTemplatesInput(input, restEncoder); err != nil { 5341 return out, metadata, &smithy.SerializationError{Err: err} 5342 } 5343 5344 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5345 return out, metadata, &smithy.SerializationError{Err: err} 5346 } 5347 in.Request = request 5348 5349 return next.HandleSerialize(ctx, in) 5350} 5351func awsRestjson1_serializeOpHttpBindingsListTemplatesInput(v *ListTemplatesInput, encoder *httpbinding.Encoder) error { 5352 if v == nil { 5353 return fmt.Errorf("unsupported serialization of nil %T", v) 5354 } 5355 5356 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5357 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5358 } 5359 if v.AwsAccountId != nil { 5360 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5361 return err 5362 } 5363 } 5364 5365 if v.MaxResults != 0 { 5366 encoder.SetQuery("max-result").Integer(v.MaxResults) 5367 } 5368 5369 if v.NextToken != nil { 5370 encoder.SetQuery("next-token").String(*v.NextToken) 5371 } 5372 5373 return nil 5374} 5375 5376type awsRestjson1_serializeOpListTemplateVersions struct { 5377} 5378 5379func (*awsRestjson1_serializeOpListTemplateVersions) ID() string { 5380 return "OperationSerializer" 5381} 5382 5383func (m *awsRestjson1_serializeOpListTemplateVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5384 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5385) { 5386 request, ok := in.Request.(*smithyhttp.Request) 5387 if !ok { 5388 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5389 } 5390 5391 input, ok := in.Parameters.(*ListTemplateVersionsInput) 5392 _ = input 5393 if !ok { 5394 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5395 } 5396 5397 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/versions") 5398 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5399 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5400 request.Method = "GET" 5401 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5402 if err != nil { 5403 return out, metadata, &smithy.SerializationError{Err: err} 5404 } 5405 5406 if err := awsRestjson1_serializeOpHttpBindingsListTemplateVersionsInput(input, restEncoder); err != nil { 5407 return out, metadata, &smithy.SerializationError{Err: err} 5408 } 5409 5410 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5411 return out, metadata, &smithy.SerializationError{Err: err} 5412 } 5413 in.Request = request 5414 5415 return next.HandleSerialize(ctx, in) 5416} 5417func awsRestjson1_serializeOpHttpBindingsListTemplateVersionsInput(v *ListTemplateVersionsInput, encoder *httpbinding.Encoder) error { 5418 if v == nil { 5419 return fmt.Errorf("unsupported serialization of nil %T", v) 5420 } 5421 5422 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5423 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5424 } 5425 if v.AwsAccountId != nil { 5426 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5427 return err 5428 } 5429 } 5430 5431 if v.MaxResults != 0 { 5432 encoder.SetQuery("max-results").Integer(v.MaxResults) 5433 } 5434 5435 if v.NextToken != nil { 5436 encoder.SetQuery("next-token").String(*v.NextToken) 5437 } 5438 5439 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 5440 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 5441 } 5442 if v.TemplateId != nil { 5443 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 5444 return err 5445 } 5446 } 5447 5448 return nil 5449} 5450 5451type awsRestjson1_serializeOpListThemeAliases struct { 5452} 5453 5454func (*awsRestjson1_serializeOpListThemeAliases) ID() string { 5455 return "OperationSerializer" 5456} 5457 5458func (m *awsRestjson1_serializeOpListThemeAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5459 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5460) { 5461 request, ok := in.Request.(*smithyhttp.Request) 5462 if !ok { 5463 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5464 } 5465 5466 input, ok := in.Parameters.(*ListThemeAliasesInput) 5467 _ = input 5468 if !ok { 5469 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5470 } 5471 5472 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases") 5473 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5474 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5475 request.Method = "GET" 5476 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5477 if err != nil { 5478 return out, metadata, &smithy.SerializationError{Err: err} 5479 } 5480 5481 if err := awsRestjson1_serializeOpHttpBindingsListThemeAliasesInput(input, restEncoder); err != nil { 5482 return out, metadata, &smithy.SerializationError{Err: err} 5483 } 5484 5485 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5486 return out, metadata, &smithy.SerializationError{Err: err} 5487 } 5488 in.Request = request 5489 5490 return next.HandleSerialize(ctx, in) 5491} 5492func awsRestjson1_serializeOpHttpBindingsListThemeAliasesInput(v *ListThemeAliasesInput, encoder *httpbinding.Encoder) error { 5493 if v == nil { 5494 return fmt.Errorf("unsupported serialization of nil %T", v) 5495 } 5496 5497 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5498 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5499 } 5500 if v.AwsAccountId != nil { 5501 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5502 return err 5503 } 5504 } 5505 5506 if v.MaxResults != 0 { 5507 encoder.SetQuery("max-result").Integer(v.MaxResults) 5508 } 5509 5510 if v.NextToken != nil { 5511 encoder.SetQuery("next-token").String(*v.NextToken) 5512 } 5513 5514 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 5515 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 5516 } 5517 if v.ThemeId != nil { 5518 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 5519 return err 5520 } 5521 } 5522 5523 return nil 5524} 5525 5526type awsRestjson1_serializeOpListThemes struct { 5527} 5528 5529func (*awsRestjson1_serializeOpListThemes) ID() string { 5530 return "OperationSerializer" 5531} 5532 5533func (m *awsRestjson1_serializeOpListThemes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5534 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5535) { 5536 request, ok := in.Request.(*smithyhttp.Request) 5537 if !ok { 5538 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5539 } 5540 5541 input, ok := in.Parameters.(*ListThemesInput) 5542 _ = input 5543 if !ok { 5544 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5545 } 5546 5547 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes") 5548 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5549 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5550 request.Method = "GET" 5551 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5552 if err != nil { 5553 return out, metadata, &smithy.SerializationError{Err: err} 5554 } 5555 5556 if err := awsRestjson1_serializeOpHttpBindingsListThemesInput(input, restEncoder); err != nil { 5557 return out, metadata, &smithy.SerializationError{Err: err} 5558 } 5559 5560 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5561 return out, metadata, &smithy.SerializationError{Err: err} 5562 } 5563 in.Request = request 5564 5565 return next.HandleSerialize(ctx, in) 5566} 5567func awsRestjson1_serializeOpHttpBindingsListThemesInput(v *ListThemesInput, encoder *httpbinding.Encoder) error { 5568 if v == nil { 5569 return fmt.Errorf("unsupported serialization of nil %T", v) 5570 } 5571 5572 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5573 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5574 } 5575 if v.AwsAccountId != nil { 5576 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5577 return err 5578 } 5579 } 5580 5581 if v.MaxResults != 0 { 5582 encoder.SetQuery("max-results").Integer(v.MaxResults) 5583 } 5584 5585 if v.NextToken != nil { 5586 encoder.SetQuery("next-token").String(*v.NextToken) 5587 } 5588 5589 if len(v.Type) > 0 { 5590 encoder.SetQuery("type").String(string(v.Type)) 5591 } 5592 5593 return nil 5594} 5595 5596type awsRestjson1_serializeOpListThemeVersions struct { 5597} 5598 5599func (*awsRestjson1_serializeOpListThemeVersions) ID() string { 5600 return "OperationSerializer" 5601} 5602 5603func (m *awsRestjson1_serializeOpListThemeVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5604 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5605) { 5606 request, ok := in.Request.(*smithyhttp.Request) 5607 if !ok { 5608 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5609 } 5610 5611 input, ok := in.Parameters.(*ListThemeVersionsInput) 5612 _ = input 5613 if !ok { 5614 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5615 } 5616 5617 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/versions") 5618 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5619 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5620 request.Method = "GET" 5621 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5622 if err != nil { 5623 return out, metadata, &smithy.SerializationError{Err: err} 5624 } 5625 5626 if err := awsRestjson1_serializeOpHttpBindingsListThemeVersionsInput(input, restEncoder); err != nil { 5627 return out, metadata, &smithy.SerializationError{Err: err} 5628 } 5629 5630 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5631 return out, metadata, &smithy.SerializationError{Err: err} 5632 } 5633 in.Request = request 5634 5635 return next.HandleSerialize(ctx, in) 5636} 5637func awsRestjson1_serializeOpHttpBindingsListThemeVersionsInput(v *ListThemeVersionsInput, encoder *httpbinding.Encoder) error { 5638 if v == nil { 5639 return fmt.Errorf("unsupported serialization of nil %T", v) 5640 } 5641 5642 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5643 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5644 } 5645 if v.AwsAccountId != nil { 5646 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5647 return err 5648 } 5649 } 5650 5651 if v.MaxResults != 0 { 5652 encoder.SetQuery("max-results").Integer(v.MaxResults) 5653 } 5654 5655 if v.NextToken != nil { 5656 encoder.SetQuery("next-token").String(*v.NextToken) 5657 } 5658 5659 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 5660 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 5661 } 5662 if v.ThemeId != nil { 5663 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 5664 return err 5665 } 5666 } 5667 5668 return nil 5669} 5670 5671type awsRestjson1_serializeOpListUserGroups struct { 5672} 5673 5674func (*awsRestjson1_serializeOpListUserGroups) ID() string { 5675 return "OperationSerializer" 5676} 5677 5678func (m *awsRestjson1_serializeOpListUserGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5679 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5680) { 5681 request, ok := in.Request.(*smithyhttp.Request) 5682 if !ok { 5683 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5684 } 5685 5686 input, ok := in.Parameters.(*ListUserGroupsInput) 5687 _ = input 5688 if !ok { 5689 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5690 } 5691 5692 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}/groups") 5693 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5694 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5695 request.Method = "GET" 5696 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5697 if err != nil { 5698 return out, metadata, &smithy.SerializationError{Err: err} 5699 } 5700 5701 if err := awsRestjson1_serializeOpHttpBindingsListUserGroupsInput(input, restEncoder); err != nil { 5702 return out, metadata, &smithy.SerializationError{Err: err} 5703 } 5704 5705 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5706 return out, metadata, &smithy.SerializationError{Err: err} 5707 } 5708 in.Request = request 5709 5710 return next.HandleSerialize(ctx, in) 5711} 5712func awsRestjson1_serializeOpHttpBindingsListUserGroupsInput(v *ListUserGroupsInput, encoder *httpbinding.Encoder) error { 5713 if v == nil { 5714 return fmt.Errorf("unsupported serialization of nil %T", v) 5715 } 5716 5717 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5718 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5719 } 5720 if v.AwsAccountId != nil { 5721 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5722 return err 5723 } 5724 } 5725 5726 if v.MaxResults != 0 { 5727 encoder.SetQuery("max-results").Integer(v.MaxResults) 5728 } 5729 5730 if v.Namespace == nil || len(*v.Namespace) == 0 { 5731 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 5732 } 5733 if v.Namespace != nil { 5734 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 5735 return err 5736 } 5737 } 5738 5739 if v.NextToken != nil { 5740 encoder.SetQuery("next-token").String(*v.NextToken) 5741 } 5742 5743 if v.UserName == nil || len(*v.UserName) == 0 { 5744 return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")} 5745 } 5746 if v.UserName != nil { 5747 if err := encoder.SetURI("UserName").String(*v.UserName); err != nil { 5748 return err 5749 } 5750 } 5751 5752 return nil 5753} 5754 5755type awsRestjson1_serializeOpListUsers struct { 5756} 5757 5758func (*awsRestjson1_serializeOpListUsers) ID() string { 5759 return "OperationSerializer" 5760} 5761 5762func (m *awsRestjson1_serializeOpListUsers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5763 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5764) { 5765 request, ok := in.Request.(*smithyhttp.Request) 5766 if !ok { 5767 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5768 } 5769 5770 input, ok := in.Parameters.(*ListUsersInput) 5771 _ = input 5772 if !ok { 5773 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5774 } 5775 5776 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users") 5777 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5778 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5779 request.Method = "GET" 5780 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5781 if err != nil { 5782 return out, metadata, &smithy.SerializationError{Err: err} 5783 } 5784 5785 if err := awsRestjson1_serializeOpHttpBindingsListUsersInput(input, restEncoder); err != nil { 5786 return out, metadata, &smithy.SerializationError{Err: err} 5787 } 5788 5789 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5790 return out, metadata, &smithy.SerializationError{Err: err} 5791 } 5792 in.Request = request 5793 5794 return next.HandleSerialize(ctx, in) 5795} 5796func awsRestjson1_serializeOpHttpBindingsListUsersInput(v *ListUsersInput, encoder *httpbinding.Encoder) error { 5797 if v == nil { 5798 return fmt.Errorf("unsupported serialization of nil %T", v) 5799 } 5800 5801 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5802 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5803 } 5804 if v.AwsAccountId != nil { 5805 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5806 return err 5807 } 5808 } 5809 5810 if v.MaxResults != 0 { 5811 encoder.SetQuery("max-results").Integer(v.MaxResults) 5812 } 5813 5814 if v.Namespace == nil || len(*v.Namespace) == 0 { 5815 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 5816 } 5817 if v.Namespace != nil { 5818 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 5819 return err 5820 } 5821 } 5822 5823 if v.NextToken != nil { 5824 encoder.SetQuery("next-token").String(*v.NextToken) 5825 } 5826 5827 return nil 5828} 5829 5830type awsRestjson1_serializeOpRegisterUser struct { 5831} 5832 5833func (*awsRestjson1_serializeOpRegisterUser) ID() string { 5834 return "OperationSerializer" 5835} 5836 5837func (m *awsRestjson1_serializeOpRegisterUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5838 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5839) { 5840 request, ok := in.Request.(*smithyhttp.Request) 5841 if !ok { 5842 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5843 } 5844 5845 input, ok := in.Parameters.(*RegisterUserInput) 5846 _ = input 5847 if !ok { 5848 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5849 } 5850 5851 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users") 5852 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5853 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5854 request.Method = "POST" 5855 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5856 if err != nil { 5857 return out, metadata, &smithy.SerializationError{Err: err} 5858 } 5859 5860 if err := awsRestjson1_serializeOpHttpBindingsRegisterUserInput(input, restEncoder); err != nil { 5861 return out, metadata, &smithy.SerializationError{Err: err} 5862 } 5863 5864 restEncoder.SetHeader("Content-Type").String("application/json") 5865 5866 jsonEncoder := smithyjson.NewEncoder() 5867 if err := awsRestjson1_serializeOpDocumentRegisterUserInput(input, jsonEncoder.Value); err != nil { 5868 return out, metadata, &smithy.SerializationError{Err: err} 5869 } 5870 5871 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5872 return out, metadata, &smithy.SerializationError{Err: err} 5873 } 5874 5875 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5876 return out, metadata, &smithy.SerializationError{Err: err} 5877 } 5878 in.Request = request 5879 5880 return next.HandleSerialize(ctx, in) 5881} 5882func awsRestjson1_serializeOpHttpBindingsRegisterUserInput(v *RegisterUserInput, encoder *httpbinding.Encoder) error { 5883 if v == nil { 5884 return fmt.Errorf("unsupported serialization of nil %T", v) 5885 } 5886 5887 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 5888 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 5889 } 5890 if v.AwsAccountId != nil { 5891 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 5892 return err 5893 } 5894 } 5895 5896 if v.Namespace == nil || len(*v.Namespace) == 0 { 5897 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 5898 } 5899 if v.Namespace != nil { 5900 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 5901 return err 5902 } 5903 } 5904 5905 return nil 5906} 5907 5908func awsRestjson1_serializeOpDocumentRegisterUserInput(v *RegisterUserInput, value smithyjson.Value) error { 5909 object := value.Object() 5910 defer object.Close() 5911 5912 if v.CustomPermissionsName != nil { 5913 ok := object.Key("CustomPermissionsName") 5914 ok.String(*v.CustomPermissionsName) 5915 } 5916 5917 if v.Email != nil { 5918 ok := object.Key("Email") 5919 ok.String(*v.Email) 5920 } 5921 5922 if v.IamArn != nil { 5923 ok := object.Key("IamArn") 5924 ok.String(*v.IamArn) 5925 } 5926 5927 if len(v.IdentityType) > 0 { 5928 ok := object.Key("IdentityType") 5929 ok.String(string(v.IdentityType)) 5930 } 5931 5932 if v.SessionName != nil { 5933 ok := object.Key("SessionName") 5934 ok.String(*v.SessionName) 5935 } 5936 5937 if v.UserName != nil { 5938 ok := object.Key("UserName") 5939 ok.String(*v.UserName) 5940 } 5941 5942 if len(v.UserRole) > 0 { 5943 ok := object.Key("UserRole") 5944 ok.String(string(v.UserRole)) 5945 } 5946 5947 return nil 5948} 5949 5950type awsRestjson1_serializeOpRestoreAnalysis struct { 5951} 5952 5953func (*awsRestjson1_serializeOpRestoreAnalysis) ID() string { 5954 return "OperationSerializer" 5955} 5956 5957func (m *awsRestjson1_serializeOpRestoreAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5958 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5959) { 5960 request, ok := in.Request.(*smithyhttp.Request) 5961 if !ok { 5962 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5963 } 5964 5965 input, ok := in.Parameters.(*RestoreAnalysisInput) 5966 _ = input 5967 if !ok { 5968 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5969 } 5970 5971 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/restore/analyses/{AnalysisId}") 5972 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5973 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5974 request.Method = "POST" 5975 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5976 if err != nil { 5977 return out, metadata, &smithy.SerializationError{Err: err} 5978 } 5979 5980 if err := awsRestjson1_serializeOpHttpBindingsRestoreAnalysisInput(input, restEncoder); err != nil { 5981 return out, metadata, &smithy.SerializationError{Err: err} 5982 } 5983 5984 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5985 return out, metadata, &smithy.SerializationError{Err: err} 5986 } 5987 in.Request = request 5988 5989 return next.HandleSerialize(ctx, in) 5990} 5991func awsRestjson1_serializeOpHttpBindingsRestoreAnalysisInput(v *RestoreAnalysisInput, encoder *httpbinding.Encoder) error { 5992 if v == nil { 5993 return fmt.Errorf("unsupported serialization of nil %T", v) 5994 } 5995 5996 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 5997 return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")} 5998 } 5999 if v.AnalysisId != nil { 6000 if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil { 6001 return err 6002 } 6003 } 6004 6005 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6006 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6007 } 6008 if v.AwsAccountId != nil { 6009 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6010 return err 6011 } 6012 } 6013 6014 return nil 6015} 6016 6017type awsRestjson1_serializeOpSearchAnalyses struct { 6018} 6019 6020func (*awsRestjson1_serializeOpSearchAnalyses) ID() string { 6021 return "OperationSerializer" 6022} 6023 6024func (m *awsRestjson1_serializeOpSearchAnalyses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6025 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6026) { 6027 request, ok := in.Request.(*smithyhttp.Request) 6028 if !ok { 6029 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6030 } 6031 6032 input, ok := in.Parameters.(*SearchAnalysesInput) 6033 _ = input 6034 if !ok { 6035 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6036 } 6037 6038 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/search/analyses") 6039 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6040 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6041 request.Method = "POST" 6042 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6043 if err != nil { 6044 return out, metadata, &smithy.SerializationError{Err: err} 6045 } 6046 6047 if err := awsRestjson1_serializeOpHttpBindingsSearchAnalysesInput(input, restEncoder); err != nil { 6048 return out, metadata, &smithy.SerializationError{Err: err} 6049 } 6050 6051 restEncoder.SetHeader("Content-Type").String("application/json") 6052 6053 jsonEncoder := smithyjson.NewEncoder() 6054 if err := awsRestjson1_serializeOpDocumentSearchAnalysesInput(input, jsonEncoder.Value); err != nil { 6055 return out, metadata, &smithy.SerializationError{Err: err} 6056 } 6057 6058 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6059 return out, metadata, &smithy.SerializationError{Err: err} 6060 } 6061 6062 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6063 return out, metadata, &smithy.SerializationError{Err: err} 6064 } 6065 in.Request = request 6066 6067 return next.HandleSerialize(ctx, in) 6068} 6069func awsRestjson1_serializeOpHttpBindingsSearchAnalysesInput(v *SearchAnalysesInput, encoder *httpbinding.Encoder) error { 6070 if v == nil { 6071 return fmt.Errorf("unsupported serialization of nil %T", v) 6072 } 6073 6074 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6075 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6076 } 6077 if v.AwsAccountId != nil { 6078 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6079 return err 6080 } 6081 } 6082 6083 return nil 6084} 6085 6086func awsRestjson1_serializeOpDocumentSearchAnalysesInput(v *SearchAnalysesInput, value smithyjson.Value) error { 6087 object := value.Object() 6088 defer object.Close() 6089 6090 if v.Filters != nil { 6091 ok := object.Key("Filters") 6092 if err := awsRestjson1_serializeDocumentAnalysisSearchFilterList(v.Filters, ok); err != nil { 6093 return err 6094 } 6095 } 6096 6097 if v.MaxResults != 0 { 6098 ok := object.Key("MaxResults") 6099 ok.Integer(v.MaxResults) 6100 } 6101 6102 if v.NextToken != nil { 6103 ok := object.Key("NextToken") 6104 ok.String(*v.NextToken) 6105 } 6106 6107 return nil 6108} 6109 6110type awsRestjson1_serializeOpSearchDashboards struct { 6111} 6112 6113func (*awsRestjson1_serializeOpSearchDashboards) ID() string { 6114 return "OperationSerializer" 6115} 6116 6117func (m *awsRestjson1_serializeOpSearchDashboards) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6118 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6119) { 6120 request, ok := in.Request.(*smithyhttp.Request) 6121 if !ok { 6122 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6123 } 6124 6125 input, ok := in.Parameters.(*SearchDashboardsInput) 6126 _ = input 6127 if !ok { 6128 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6129 } 6130 6131 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/search/dashboards") 6132 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6133 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6134 request.Method = "POST" 6135 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6136 if err != nil { 6137 return out, metadata, &smithy.SerializationError{Err: err} 6138 } 6139 6140 if err := awsRestjson1_serializeOpHttpBindingsSearchDashboardsInput(input, restEncoder); err != nil { 6141 return out, metadata, &smithy.SerializationError{Err: err} 6142 } 6143 6144 restEncoder.SetHeader("Content-Type").String("application/json") 6145 6146 jsonEncoder := smithyjson.NewEncoder() 6147 if err := awsRestjson1_serializeOpDocumentSearchDashboardsInput(input, jsonEncoder.Value); err != nil { 6148 return out, metadata, &smithy.SerializationError{Err: err} 6149 } 6150 6151 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6152 return out, metadata, &smithy.SerializationError{Err: err} 6153 } 6154 6155 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6156 return out, metadata, &smithy.SerializationError{Err: err} 6157 } 6158 in.Request = request 6159 6160 return next.HandleSerialize(ctx, in) 6161} 6162func awsRestjson1_serializeOpHttpBindingsSearchDashboardsInput(v *SearchDashboardsInput, encoder *httpbinding.Encoder) error { 6163 if v == nil { 6164 return fmt.Errorf("unsupported serialization of nil %T", v) 6165 } 6166 6167 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6168 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6169 } 6170 if v.AwsAccountId != nil { 6171 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6172 return err 6173 } 6174 } 6175 6176 return nil 6177} 6178 6179func awsRestjson1_serializeOpDocumentSearchDashboardsInput(v *SearchDashboardsInput, value smithyjson.Value) error { 6180 object := value.Object() 6181 defer object.Close() 6182 6183 if v.Filters != nil { 6184 ok := object.Key("Filters") 6185 if err := awsRestjson1_serializeDocumentDashboardSearchFilterList(v.Filters, ok); err != nil { 6186 return err 6187 } 6188 } 6189 6190 if v.MaxResults != 0 { 6191 ok := object.Key("MaxResults") 6192 ok.Integer(v.MaxResults) 6193 } 6194 6195 if v.NextToken != nil { 6196 ok := object.Key("NextToken") 6197 ok.String(*v.NextToken) 6198 } 6199 6200 return nil 6201} 6202 6203type awsRestjson1_serializeOpTagResource struct { 6204} 6205 6206func (*awsRestjson1_serializeOpTagResource) ID() string { 6207 return "OperationSerializer" 6208} 6209 6210func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6211 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6212) { 6213 request, ok := in.Request.(*smithyhttp.Request) 6214 if !ok { 6215 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6216 } 6217 6218 input, ok := in.Parameters.(*TagResourceInput) 6219 _ = input 6220 if !ok { 6221 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6222 } 6223 6224 opPath, opQuery := httpbinding.SplitURI("/resources/{ResourceArn}/tags") 6225 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6226 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6227 request.Method = "POST" 6228 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6229 if err != nil { 6230 return out, metadata, &smithy.SerializationError{Err: err} 6231 } 6232 6233 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 6234 return out, metadata, &smithy.SerializationError{Err: err} 6235 } 6236 6237 restEncoder.SetHeader("Content-Type").String("application/json") 6238 6239 jsonEncoder := smithyjson.NewEncoder() 6240 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 6241 return out, metadata, &smithy.SerializationError{Err: err} 6242 } 6243 6244 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6245 return out, metadata, &smithy.SerializationError{Err: err} 6246 } 6247 6248 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6249 return out, metadata, &smithy.SerializationError{Err: err} 6250 } 6251 in.Request = request 6252 6253 return next.HandleSerialize(ctx, in) 6254} 6255func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 6256 if v == nil { 6257 return fmt.Errorf("unsupported serialization of nil %T", v) 6258 } 6259 6260 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 6261 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 6262 } 6263 if v.ResourceArn != nil { 6264 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 6265 return err 6266 } 6267 } 6268 6269 return nil 6270} 6271 6272func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 6273 object := value.Object() 6274 defer object.Close() 6275 6276 if v.Tags != nil { 6277 ok := object.Key("Tags") 6278 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 6279 return err 6280 } 6281 } 6282 6283 return nil 6284} 6285 6286type awsRestjson1_serializeOpUntagResource struct { 6287} 6288 6289func (*awsRestjson1_serializeOpUntagResource) ID() string { 6290 return "OperationSerializer" 6291} 6292 6293func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6294 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6295) { 6296 request, ok := in.Request.(*smithyhttp.Request) 6297 if !ok { 6298 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6299 } 6300 6301 input, ok := in.Parameters.(*UntagResourceInput) 6302 _ = input 6303 if !ok { 6304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6305 } 6306 6307 opPath, opQuery := httpbinding.SplitURI("/resources/{ResourceArn}/tags") 6308 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6309 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6310 request.Method = "DELETE" 6311 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6312 if err != nil { 6313 return out, metadata, &smithy.SerializationError{Err: err} 6314 } 6315 6316 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 6317 return out, metadata, &smithy.SerializationError{Err: err} 6318 } 6319 6320 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6321 return out, metadata, &smithy.SerializationError{Err: err} 6322 } 6323 in.Request = request 6324 6325 return next.HandleSerialize(ctx, in) 6326} 6327func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 6328 if v == nil { 6329 return fmt.Errorf("unsupported serialization of nil %T", v) 6330 } 6331 6332 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 6333 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 6334 } 6335 if v.ResourceArn != nil { 6336 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 6337 return err 6338 } 6339 } 6340 6341 if v.TagKeys != nil { 6342 for i := range v.TagKeys { 6343 encoder.AddQuery("keys").String(v.TagKeys[i]) 6344 } 6345 } 6346 6347 return nil 6348} 6349 6350type awsRestjson1_serializeOpUpdateAccountCustomization struct { 6351} 6352 6353func (*awsRestjson1_serializeOpUpdateAccountCustomization) ID() string { 6354 return "OperationSerializer" 6355} 6356 6357func (m *awsRestjson1_serializeOpUpdateAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6358 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6359) { 6360 request, ok := in.Request.(*smithyhttp.Request) 6361 if !ok { 6362 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6363 } 6364 6365 input, ok := in.Parameters.(*UpdateAccountCustomizationInput) 6366 _ = input 6367 if !ok { 6368 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6369 } 6370 6371 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations") 6372 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6373 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6374 request.Method = "PUT" 6375 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6376 if err != nil { 6377 return out, metadata, &smithy.SerializationError{Err: err} 6378 } 6379 6380 if err := awsRestjson1_serializeOpHttpBindingsUpdateAccountCustomizationInput(input, restEncoder); err != nil { 6381 return out, metadata, &smithy.SerializationError{Err: err} 6382 } 6383 6384 restEncoder.SetHeader("Content-Type").String("application/json") 6385 6386 jsonEncoder := smithyjson.NewEncoder() 6387 if err := awsRestjson1_serializeOpDocumentUpdateAccountCustomizationInput(input, jsonEncoder.Value); err != nil { 6388 return out, metadata, &smithy.SerializationError{Err: err} 6389 } 6390 6391 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6392 return out, metadata, &smithy.SerializationError{Err: err} 6393 } 6394 6395 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6396 return out, metadata, &smithy.SerializationError{Err: err} 6397 } 6398 in.Request = request 6399 6400 return next.HandleSerialize(ctx, in) 6401} 6402func awsRestjson1_serializeOpHttpBindingsUpdateAccountCustomizationInput(v *UpdateAccountCustomizationInput, encoder *httpbinding.Encoder) error { 6403 if v == nil { 6404 return fmt.Errorf("unsupported serialization of nil %T", v) 6405 } 6406 6407 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6408 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6409 } 6410 if v.AwsAccountId != nil { 6411 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6412 return err 6413 } 6414 } 6415 6416 if v.Namespace != nil { 6417 encoder.SetQuery("namespace").String(*v.Namespace) 6418 } 6419 6420 return nil 6421} 6422 6423func awsRestjson1_serializeOpDocumentUpdateAccountCustomizationInput(v *UpdateAccountCustomizationInput, value smithyjson.Value) error { 6424 object := value.Object() 6425 defer object.Close() 6426 6427 if v.AccountCustomization != nil { 6428 ok := object.Key("AccountCustomization") 6429 if err := awsRestjson1_serializeDocumentAccountCustomization(v.AccountCustomization, ok); err != nil { 6430 return err 6431 } 6432 } 6433 6434 return nil 6435} 6436 6437type awsRestjson1_serializeOpUpdateAccountSettings struct { 6438} 6439 6440func (*awsRestjson1_serializeOpUpdateAccountSettings) ID() string { 6441 return "OperationSerializer" 6442} 6443 6444func (m *awsRestjson1_serializeOpUpdateAccountSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6445 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6446) { 6447 request, ok := in.Request.(*smithyhttp.Request) 6448 if !ok { 6449 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6450 } 6451 6452 input, ok := in.Parameters.(*UpdateAccountSettingsInput) 6453 _ = input 6454 if !ok { 6455 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6456 } 6457 6458 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/settings") 6459 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6460 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6461 request.Method = "PUT" 6462 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6463 if err != nil { 6464 return out, metadata, &smithy.SerializationError{Err: err} 6465 } 6466 6467 if err := awsRestjson1_serializeOpHttpBindingsUpdateAccountSettingsInput(input, restEncoder); err != nil { 6468 return out, metadata, &smithy.SerializationError{Err: err} 6469 } 6470 6471 restEncoder.SetHeader("Content-Type").String("application/json") 6472 6473 jsonEncoder := smithyjson.NewEncoder() 6474 if err := awsRestjson1_serializeOpDocumentUpdateAccountSettingsInput(input, jsonEncoder.Value); err != nil { 6475 return out, metadata, &smithy.SerializationError{Err: err} 6476 } 6477 6478 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6479 return out, metadata, &smithy.SerializationError{Err: err} 6480 } 6481 6482 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6483 return out, metadata, &smithy.SerializationError{Err: err} 6484 } 6485 in.Request = request 6486 6487 return next.HandleSerialize(ctx, in) 6488} 6489func awsRestjson1_serializeOpHttpBindingsUpdateAccountSettingsInput(v *UpdateAccountSettingsInput, encoder *httpbinding.Encoder) error { 6490 if v == nil { 6491 return fmt.Errorf("unsupported serialization of nil %T", v) 6492 } 6493 6494 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6495 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6496 } 6497 if v.AwsAccountId != nil { 6498 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6499 return err 6500 } 6501 } 6502 6503 return nil 6504} 6505 6506func awsRestjson1_serializeOpDocumentUpdateAccountSettingsInput(v *UpdateAccountSettingsInput, value smithyjson.Value) error { 6507 object := value.Object() 6508 defer object.Close() 6509 6510 if v.DefaultNamespace != nil { 6511 ok := object.Key("DefaultNamespace") 6512 ok.String(*v.DefaultNamespace) 6513 } 6514 6515 if v.NotificationEmail != nil { 6516 ok := object.Key("NotificationEmail") 6517 ok.String(*v.NotificationEmail) 6518 } 6519 6520 return nil 6521} 6522 6523type awsRestjson1_serializeOpUpdateAnalysis struct { 6524} 6525 6526func (*awsRestjson1_serializeOpUpdateAnalysis) ID() string { 6527 return "OperationSerializer" 6528} 6529 6530func (m *awsRestjson1_serializeOpUpdateAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6531 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6532) { 6533 request, ok := in.Request.(*smithyhttp.Request) 6534 if !ok { 6535 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6536 } 6537 6538 input, ok := in.Parameters.(*UpdateAnalysisInput) 6539 _ = input 6540 if !ok { 6541 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6542 } 6543 6544 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}") 6545 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6546 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6547 request.Method = "PUT" 6548 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6549 if err != nil { 6550 return out, metadata, &smithy.SerializationError{Err: err} 6551 } 6552 6553 if err := awsRestjson1_serializeOpHttpBindingsUpdateAnalysisInput(input, restEncoder); err != nil { 6554 return out, metadata, &smithy.SerializationError{Err: err} 6555 } 6556 6557 restEncoder.SetHeader("Content-Type").String("application/json") 6558 6559 jsonEncoder := smithyjson.NewEncoder() 6560 if err := awsRestjson1_serializeOpDocumentUpdateAnalysisInput(input, jsonEncoder.Value); err != nil { 6561 return out, metadata, &smithy.SerializationError{Err: err} 6562 } 6563 6564 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6565 return out, metadata, &smithy.SerializationError{Err: err} 6566 } 6567 6568 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6569 return out, metadata, &smithy.SerializationError{Err: err} 6570 } 6571 in.Request = request 6572 6573 return next.HandleSerialize(ctx, in) 6574} 6575func awsRestjson1_serializeOpHttpBindingsUpdateAnalysisInput(v *UpdateAnalysisInput, encoder *httpbinding.Encoder) error { 6576 if v == nil { 6577 return fmt.Errorf("unsupported serialization of nil %T", v) 6578 } 6579 6580 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 6581 return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")} 6582 } 6583 if v.AnalysisId != nil { 6584 if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil { 6585 return err 6586 } 6587 } 6588 6589 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6590 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6591 } 6592 if v.AwsAccountId != nil { 6593 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6594 return err 6595 } 6596 } 6597 6598 return nil 6599} 6600 6601func awsRestjson1_serializeOpDocumentUpdateAnalysisInput(v *UpdateAnalysisInput, value smithyjson.Value) error { 6602 object := value.Object() 6603 defer object.Close() 6604 6605 if v.Name != nil { 6606 ok := object.Key("Name") 6607 ok.String(*v.Name) 6608 } 6609 6610 if v.Parameters != nil { 6611 ok := object.Key("Parameters") 6612 if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil { 6613 return err 6614 } 6615 } 6616 6617 if v.SourceEntity != nil { 6618 ok := object.Key("SourceEntity") 6619 if err := awsRestjson1_serializeDocumentAnalysisSourceEntity(v.SourceEntity, ok); err != nil { 6620 return err 6621 } 6622 } 6623 6624 if v.ThemeArn != nil { 6625 ok := object.Key("ThemeArn") 6626 ok.String(*v.ThemeArn) 6627 } 6628 6629 return nil 6630} 6631 6632type awsRestjson1_serializeOpUpdateAnalysisPermissions struct { 6633} 6634 6635func (*awsRestjson1_serializeOpUpdateAnalysisPermissions) ID() string { 6636 return "OperationSerializer" 6637} 6638 6639func (m *awsRestjson1_serializeOpUpdateAnalysisPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6640 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6641) { 6642 request, ok := in.Request.(*smithyhttp.Request) 6643 if !ok { 6644 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6645 } 6646 6647 input, ok := in.Parameters.(*UpdateAnalysisPermissionsInput) 6648 _ = input 6649 if !ok { 6650 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6651 } 6652 6653 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}/permissions") 6654 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6655 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6656 request.Method = "PUT" 6657 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6658 if err != nil { 6659 return out, metadata, &smithy.SerializationError{Err: err} 6660 } 6661 6662 if err := awsRestjson1_serializeOpHttpBindingsUpdateAnalysisPermissionsInput(input, restEncoder); err != nil { 6663 return out, metadata, &smithy.SerializationError{Err: err} 6664 } 6665 6666 restEncoder.SetHeader("Content-Type").String("application/json") 6667 6668 jsonEncoder := smithyjson.NewEncoder() 6669 if err := awsRestjson1_serializeOpDocumentUpdateAnalysisPermissionsInput(input, jsonEncoder.Value); err != nil { 6670 return out, metadata, &smithy.SerializationError{Err: err} 6671 } 6672 6673 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6674 return out, metadata, &smithy.SerializationError{Err: err} 6675 } 6676 6677 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6678 return out, metadata, &smithy.SerializationError{Err: err} 6679 } 6680 in.Request = request 6681 6682 return next.HandleSerialize(ctx, in) 6683} 6684func awsRestjson1_serializeOpHttpBindingsUpdateAnalysisPermissionsInput(v *UpdateAnalysisPermissionsInput, encoder *httpbinding.Encoder) error { 6685 if v == nil { 6686 return fmt.Errorf("unsupported serialization of nil %T", v) 6687 } 6688 6689 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 6690 return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")} 6691 } 6692 if v.AnalysisId != nil { 6693 if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil { 6694 return err 6695 } 6696 } 6697 6698 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6699 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6700 } 6701 if v.AwsAccountId != nil { 6702 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6703 return err 6704 } 6705 } 6706 6707 return nil 6708} 6709 6710func awsRestjson1_serializeOpDocumentUpdateAnalysisPermissionsInput(v *UpdateAnalysisPermissionsInput, value smithyjson.Value) error { 6711 object := value.Object() 6712 defer object.Close() 6713 6714 if v.GrantPermissions != nil { 6715 ok := object.Key("GrantPermissions") 6716 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil { 6717 return err 6718 } 6719 } 6720 6721 if v.RevokePermissions != nil { 6722 ok := object.Key("RevokePermissions") 6723 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil { 6724 return err 6725 } 6726 } 6727 6728 return nil 6729} 6730 6731type awsRestjson1_serializeOpUpdateDashboard struct { 6732} 6733 6734func (*awsRestjson1_serializeOpUpdateDashboard) ID() string { 6735 return "OperationSerializer" 6736} 6737 6738func (m *awsRestjson1_serializeOpUpdateDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6739 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6740) { 6741 request, ok := in.Request.(*smithyhttp.Request) 6742 if !ok { 6743 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6744 } 6745 6746 input, ok := in.Parameters.(*UpdateDashboardInput) 6747 _ = input 6748 if !ok { 6749 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6750 } 6751 6752 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}") 6753 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6754 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6755 request.Method = "PUT" 6756 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6757 if err != nil { 6758 return out, metadata, &smithy.SerializationError{Err: err} 6759 } 6760 6761 if err := awsRestjson1_serializeOpHttpBindingsUpdateDashboardInput(input, restEncoder); err != nil { 6762 return out, metadata, &smithy.SerializationError{Err: err} 6763 } 6764 6765 restEncoder.SetHeader("Content-Type").String("application/json") 6766 6767 jsonEncoder := smithyjson.NewEncoder() 6768 if err := awsRestjson1_serializeOpDocumentUpdateDashboardInput(input, jsonEncoder.Value); err != nil { 6769 return out, metadata, &smithy.SerializationError{Err: err} 6770 } 6771 6772 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6773 return out, metadata, &smithy.SerializationError{Err: err} 6774 } 6775 6776 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6777 return out, metadata, &smithy.SerializationError{Err: err} 6778 } 6779 in.Request = request 6780 6781 return next.HandleSerialize(ctx, in) 6782} 6783func awsRestjson1_serializeOpHttpBindingsUpdateDashboardInput(v *UpdateDashboardInput, encoder *httpbinding.Encoder) error { 6784 if v == nil { 6785 return fmt.Errorf("unsupported serialization of nil %T", v) 6786 } 6787 6788 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6789 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6790 } 6791 if v.AwsAccountId != nil { 6792 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6793 return err 6794 } 6795 } 6796 6797 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 6798 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 6799 } 6800 if v.DashboardId != nil { 6801 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 6802 return err 6803 } 6804 } 6805 6806 return nil 6807} 6808 6809func awsRestjson1_serializeOpDocumentUpdateDashboardInput(v *UpdateDashboardInput, value smithyjson.Value) error { 6810 object := value.Object() 6811 defer object.Close() 6812 6813 if v.DashboardPublishOptions != nil { 6814 ok := object.Key("DashboardPublishOptions") 6815 if err := awsRestjson1_serializeDocumentDashboardPublishOptions(v.DashboardPublishOptions, ok); err != nil { 6816 return err 6817 } 6818 } 6819 6820 if v.Name != nil { 6821 ok := object.Key("Name") 6822 ok.String(*v.Name) 6823 } 6824 6825 if v.Parameters != nil { 6826 ok := object.Key("Parameters") 6827 if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil { 6828 return err 6829 } 6830 } 6831 6832 if v.SourceEntity != nil { 6833 ok := object.Key("SourceEntity") 6834 if err := awsRestjson1_serializeDocumentDashboardSourceEntity(v.SourceEntity, ok); err != nil { 6835 return err 6836 } 6837 } 6838 6839 if v.ThemeArn != nil { 6840 ok := object.Key("ThemeArn") 6841 ok.String(*v.ThemeArn) 6842 } 6843 6844 if v.VersionDescription != nil { 6845 ok := object.Key("VersionDescription") 6846 ok.String(*v.VersionDescription) 6847 } 6848 6849 return nil 6850} 6851 6852type awsRestjson1_serializeOpUpdateDashboardPermissions struct { 6853} 6854 6855func (*awsRestjson1_serializeOpUpdateDashboardPermissions) ID() string { 6856 return "OperationSerializer" 6857} 6858 6859func (m *awsRestjson1_serializeOpUpdateDashboardPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6860 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6861) { 6862 request, ok := in.Request.(*smithyhttp.Request) 6863 if !ok { 6864 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6865 } 6866 6867 input, ok := in.Parameters.(*UpdateDashboardPermissionsInput) 6868 _ = input 6869 if !ok { 6870 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6871 } 6872 6873 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/permissions") 6874 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6875 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6876 request.Method = "PUT" 6877 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6878 if err != nil { 6879 return out, metadata, &smithy.SerializationError{Err: err} 6880 } 6881 6882 if err := awsRestjson1_serializeOpHttpBindingsUpdateDashboardPermissionsInput(input, restEncoder); err != nil { 6883 return out, metadata, &smithy.SerializationError{Err: err} 6884 } 6885 6886 restEncoder.SetHeader("Content-Type").String("application/json") 6887 6888 jsonEncoder := smithyjson.NewEncoder() 6889 if err := awsRestjson1_serializeOpDocumentUpdateDashboardPermissionsInput(input, jsonEncoder.Value); err != nil { 6890 return out, metadata, &smithy.SerializationError{Err: err} 6891 } 6892 6893 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6894 return out, metadata, &smithy.SerializationError{Err: err} 6895 } 6896 6897 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6898 return out, metadata, &smithy.SerializationError{Err: err} 6899 } 6900 in.Request = request 6901 6902 return next.HandleSerialize(ctx, in) 6903} 6904func awsRestjson1_serializeOpHttpBindingsUpdateDashboardPermissionsInput(v *UpdateDashboardPermissionsInput, encoder *httpbinding.Encoder) error { 6905 if v == nil { 6906 return fmt.Errorf("unsupported serialization of nil %T", v) 6907 } 6908 6909 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6910 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6911 } 6912 if v.AwsAccountId != nil { 6913 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 6914 return err 6915 } 6916 } 6917 6918 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 6919 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 6920 } 6921 if v.DashboardId != nil { 6922 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 6923 return err 6924 } 6925 } 6926 6927 return nil 6928} 6929 6930func awsRestjson1_serializeOpDocumentUpdateDashboardPermissionsInput(v *UpdateDashboardPermissionsInput, value smithyjson.Value) error { 6931 object := value.Object() 6932 defer object.Close() 6933 6934 if v.GrantPermissions != nil { 6935 ok := object.Key("GrantPermissions") 6936 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil { 6937 return err 6938 } 6939 } 6940 6941 if v.RevokePermissions != nil { 6942 ok := object.Key("RevokePermissions") 6943 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil { 6944 return err 6945 } 6946 } 6947 6948 return nil 6949} 6950 6951type awsRestjson1_serializeOpUpdateDashboardPublishedVersion struct { 6952} 6953 6954func (*awsRestjson1_serializeOpUpdateDashboardPublishedVersion) ID() string { 6955 return "OperationSerializer" 6956} 6957 6958func (m *awsRestjson1_serializeOpUpdateDashboardPublishedVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6959 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6960) { 6961 request, ok := in.Request.(*smithyhttp.Request) 6962 if !ok { 6963 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6964 } 6965 6966 input, ok := in.Parameters.(*UpdateDashboardPublishedVersionInput) 6967 _ = input 6968 if !ok { 6969 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6970 } 6971 6972 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/versions/{VersionNumber}") 6973 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6974 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6975 request.Method = "PUT" 6976 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6977 if err != nil { 6978 return out, metadata, &smithy.SerializationError{Err: err} 6979 } 6980 6981 if err := awsRestjson1_serializeOpHttpBindingsUpdateDashboardPublishedVersionInput(input, restEncoder); err != nil { 6982 return out, metadata, &smithy.SerializationError{Err: err} 6983 } 6984 6985 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6986 return out, metadata, &smithy.SerializationError{Err: err} 6987 } 6988 in.Request = request 6989 6990 return next.HandleSerialize(ctx, in) 6991} 6992func awsRestjson1_serializeOpHttpBindingsUpdateDashboardPublishedVersionInput(v *UpdateDashboardPublishedVersionInput, encoder *httpbinding.Encoder) error { 6993 if v == nil { 6994 return fmt.Errorf("unsupported serialization of nil %T", v) 6995 } 6996 6997 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 6998 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 6999 } 7000 if v.AwsAccountId != nil { 7001 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7002 return err 7003 } 7004 } 7005 7006 if v.DashboardId == nil || len(*v.DashboardId) == 0 { 7007 return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")} 7008 } 7009 if v.DashboardId != nil { 7010 if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil { 7011 return err 7012 } 7013 } 7014 7015 if v.VersionNumber == nil { 7016 return &smithy.SerializationError{Err: fmt.Errorf("input member VersionNumber must not be empty")} 7017 } 7018 if v.VersionNumber != nil { 7019 if err := encoder.SetURI("VersionNumber").Long(*v.VersionNumber); err != nil { 7020 return err 7021 } 7022 } 7023 7024 return nil 7025} 7026 7027type awsRestjson1_serializeOpUpdateDataSet struct { 7028} 7029 7030func (*awsRestjson1_serializeOpUpdateDataSet) ID() string { 7031 return "OperationSerializer" 7032} 7033 7034func (m *awsRestjson1_serializeOpUpdateDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7035 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7036) { 7037 request, ok := in.Request.(*smithyhttp.Request) 7038 if !ok { 7039 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7040 } 7041 7042 input, ok := in.Parameters.(*UpdateDataSetInput) 7043 _ = input 7044 if !ok { 7045 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7046 } 7047 7048 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}") 7049 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7050 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7051 request.Method = "PUT" 7052 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7053 if err != nil { 7054 return out, metadata, &smithy.SerializationError{Err: err} 7055 } 7056 7057 if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSetInput(input, restEncoder); err != nil { 7058 return out, metadata, &smithy.SerializationError{Err: err} 7059 } 7060 7061 restEncoder.SetHeader("Content-Type").String("application/json") 7062 7063 jsonEncoder := smithyjson.NewEncoder() 7064 if err := awsRestjson1_serializeOpDocumentUpdateDataSetInput(input, jsonEncoder.Value); err != nil { 7065 return out, metadata, &smithy.SerializationError{Err: err} 7066 } 7067 7068 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7069 return out, metadata, &smithy.SerializationError{Err: err} 7070 } 7071 7072 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7073 return out, metadata, &smithy.SerializationError{Err: err} 7074 } 7075 in.Request = request 7076 7077 return next.HandleSerialize(ctx, in) 7078} 7079func awsRestjson1_serializeOpHttpBindingsUpdateDataSetInput(v *UpdateDataSetInput, encoder *httpbinding.Encoder) error { 7080 if v == nil { 7081 return fmt.Errorf("unsupported serialization of nil %T", v) 7082 } 7083 7084 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7085 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7086 } 7087 if v.AwsAccountId != nil { 7088 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7089 return err 7090 } 7091 } 7092 7093 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 7094 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 7095 } 7096 if v.DataSetId != nil { 7097 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 7098 return err 7099 } 7100 } 7101 7102 return nil 7103} 7104 7105func awsRestjson1_serializeOpDocumentUpdateDataSetInput(v *UpdateDataSetInput, value smithyjson.Value) error { 7106 object := value.Object() 7107 defer object.Close() 7108 7109 if v.ColumnGroups != nil { 7110 ok := object.Key("ColumnGroups") 7111 if err := awsRestjson1_serializeDocumentColumnGroupList(v.ColumnGroups, ok); err != nil { 7112 return err 7113 } 7114 } 7115 7116 if v.ColumnLevelPermissionRules != nil { 7117 ok := object.Key("ColumnLevelPermissionRules") 7118 if err := awsRestjson1_serializeDocumentColumnLevelPermissionRuleList(v.ColumnLevelPermissionRules, ok); err != nil { 7119 return err 7120 } 7121 } 7122 7123 if v.FieldFolders != nil { 7124 ok := object.Key("FieldFolders") 7125 if err := awsRestjson1_serializeDocumentFieldFolderMap(v.FieldFolders, ok); err != nil { 7126 return err 7127 } 7128 } 7129 7130 if len(v.ImportMode) > 0 { 7131 ok := object.Key("ImportMode") 7132 ok.String(string(v.ImportMode)) 7133 } 7134 7135 if v.LogicalTableMap != nil { 7136 ok := object.Key("LogicalTableMap") 7137 if err := awsRestjson1_serializeDocumentLogicalTableMap(v.LogicalTableMap, ok); err != nil { 7138 return err 7139 } 7140 } 7141 7142 if v.Name != nil { 7143 ok := object.Key("Name") 7144 ok.String(*v.Name) 7145 } 7146 7147 if v.PhysicalTableMap != nil { 7148 ok := object.Key("PhysicalTableMap") 7149 if err := awsRestjson1_serializeDocumentPhysicalTableMap(v.PhysicalTableMap, ok); err != nil { 7150 return err 7151 } 7152 } 7153 7154 if v.RowLevelPermissionDataSet != nil { 7155 ok := object.Key("RowLevelPermissionDataSet") 7156 if err := awsRestjson1_serializeDocumentRowLevelPermissionDataSet(v.RowLevelPermissionDataSet, ok); err != nil { 7157 return err 7158 } 7159 } 7160 7161 return nil 7162} 7163 7164type awsRestjson1_serializeOpUpdateDataSetPermissions struct { 7165} 7166 7167func (*awsRestjson1_serializeOpUpdateDataSetPermissions) ID() string { 7168 return "OperationSerializer" 7169} 7170 7171func (m *awsRestjson1_serializeOpUpdateDataSetPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7172 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7173) { 7174 request, ok := in.Request.(*smithyhttp.Request) 7175 if !ok { 7176 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7177 } 7178 7179 input, ok := in.Parameters.(*UpdateDataSetPermissionsInput) 7180 _ = input 7181 if !ok { 7182 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7183 } 7184 7185 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/permissions") 7186 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7187 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7188 request.Method = "POST" 7189 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7190 if err != nil { 7191 return out, metadata, &smithy.SerializationError{Err: err} 7192 } 7193 7194 if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSetPermissionsInput(input, restEncoder); err != nil { 7195 return out, metadata, &smithy.SerializationError{Err: err} 7196 } 7197 7198 restEncoder.SetHeader("Content-Type").String("application/json") 7199 7200 jsonEncoder := smithyjson.NewEncoder() 7201 if err := awsRestjson1_serializeOpDocumentUpdateDataSetPermissionsInput(input, jsonEncoder.Value); err != nil { 7202 return out, metadata, &smithy.SerializationError{Err: err} 7203 } 7204 7205 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7206 return out, metadata, &smithy.SerializationError{Err: err} 7207 } 7208 7209 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7210 return out, metadata, &smithy.SerializationError{Err: err} 7211 } 7212 in.Request = request 7213 7214 return next.HandleSerialize(ctx, in) 7215} 7216func awsRestjson1_serializeOpHttpBindingsUpdateDataSetPermissionsInput(v *UpdateDataSetPermissionsInput, encoder *httpbinding.Encoder) error { 7217 if v == nil { 7218 return fmt.Errorf("unsupported serialization of nil %T", v) 7219 } 7220 7221 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7222 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7223 } 7224 if v.AwsAccountId != nil { 7225 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7226 return err 7227 } 7228 } 7229 7230 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 7231 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 7232 } 7233 if v.DataSetId != nil { 7234 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 7235 return err 7236 } 7237 } 7238 7239 return nil 7240} 7241 7242func awsRestjson1_serializeOpDocumentUpdateDataSetPermissionsInput(v *UpdateDataSetPermissionsInput, value smithyjson.Value) error { 7243 object := value.Object() 7244 defer object.Close() 7245 7246 if v.GrantPermissions != nil { 7247 ok := object.Key("GrantPermissions") 7248 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.GrantPermissions, ok); err != nil { 7249 return err 7250 } 7251 } 7252 7253 if v.RevokePermissions != nil { 7254 ok := object.Key("RevokePermissions") 7255 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.RevokePermissions, ok); err != nil { 7256 return err 7257 } 7258 } 7259 7260 return nil 7261} 7262 7263type awsRestjson1_serializeOpUpdateDataSource struct { 7264} 7265 7266func (*awsRestjson1_serializeOpUpdateDataSource) ID() string { 7267 return "OperationSerializer" 7268} 7269 7270func (m *awsRestjson1_serializeOpUpdateDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7271 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7272) { 7273 request, ok := in.Request.(*smithyhttp.Request) 7274 if !ok { 7275 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7276 } 7277 7278 input, ok := in.Parameters.(*UpdateDataSourceInput) 7279 _ = input 7280 if !ok { 7281 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7282 } 7283 7284 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}") 7285 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7286 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7287 request.Method = "PUT" 7288 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7289 if err != nil { 7290 return out, metadata, &smithy.SerializationError{Err: err} 7291 } 7292 7293 if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSourceInput(input, restEncoder); err != nil { 7294 return out, metadata, &smithy.SerializationError{Err: err} 7295 } 7296 7297 restEncoder.SetHeader("Content-Type").String("application/json") 7298 7299 jsonEncoder := smithyjson.NewEncoder() 7300 if err := awsRestjson1_serializeOpDocumentUpdateDataSourceInput(input, jsonEncoder.Value); err != nil { 7301 return out, metadata, &smithy.SerializationError{Err: err} 7302 } 7303 7304 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7305 return out, metadata, &smithy.SerializationError{Err: err} 7306 } 7307 7308 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7309 return out, metadata, &smithy.SerializationError{Err: err} 7310 } 7311 in.Request = request 7312 7313 return next.HandleSerialize(ctx, in) 7314} 7315func awsRestjson1_serializeOpHttpBindingsUpdateDataSourceInput(v *UpdateDataSourceInput, encoder *httpbinding.Encoder) error { 7316 if v == nil { 7317 return fmt.Errorf("unsupported serialization of nil %T", v) 7318 } 7319 7320 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7321 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7322 } 7323 if v.AwsAccountId != nil { 7324 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7325 return err 7326 } 7327 } 7328 7329 if v.DataSourceId == nil || len(*v.DataSourceId) == 0 { 7330 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")} 7331 } 7332 if v.DataSourceId != nil { 7333 if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil { 7334 return err 7335 } 7336 } 7337 7338 return nil 7339} 7340 7341func awsRestjson1_serializeOpDocumentUpdateDataSourceInput(v *UpdateDataSourceInput, value smithyjson.Value) error { 7342 object := value.Object() 7343 defer object.Close() 7344 7345 if v.Credentials != nil { 7346 ok := object.Key("Credentials") 7347 if err := awsRestjson1_serializeDocumentDataSourceCredentials(v.Credentials, ok); err != nil { 7348 return err 7349 } 7350 } 7351 7352 if v.DataSourceParameters != nil { 7353 ok := object.Key("DataSourceParameters") 7354 if err := awsRestjson1_serializeDocumentDataSourceParameters(v.DataSourceParameters, ok); err != nil { 7355 return err 7356 } 7357 } 7358 7359 if v.Name != nil { 7360 ok := object.Key("Name") 7361 ok.String(*v.Name) 7362 } 7363 7364 if v.SslProperties != nil { 7365 ok := object.Key("SslProperties") 7366 if err := awsRestjson1_serializeDocumentSslProperties(v.SslProperties, ok); err != nil { 7367 return err 7368 } 7369 } 7370 7371 if v.VpcConnectionProperties != nil { 7372 ok := object.Key("VpcConnectionProperties") 7373 if err := awsRestjson1_serializeDocumentVpcConnectionProperties(v.VpcConnectionProperties, ok); err != nil { 7374 return err 7375 } 7376 } 7377 7378 return nil 7379} 7380 7381type awsRestjson1_serializeOpUpdateDataSourcePermissions struct { 7382} 7383 7384func (*awsRestjson1_serializeOpUpdateDataSourcePermissions) ID() string { 7385 return "OperationSerializer" 7386} 7387 7388func (m *awsRestjson1_serializeOpUpdateDataSourcePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7389 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7390) { 7391 request, ok := in.Request.(*smithyhttp.Request) 7392 if !ok { 7393 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7394 } 7395 7396 input, ok := in.Parameters.(*UpdateDataSourcePermissionsInput) 7397 _ = input 7398 if !ok { 7399 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7400 } 7401 7402 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}/permissions") 7403 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7404 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7405 request.Method = "POST" 7406 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7407 if err != nil { 7408 return out, metadata, &smithy.SerializationError{Err: err} 7409 } 7410 7411 if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSourcePermissionsInput(input, restEncoder); err != nil { 7412 return out, metadata, &smithy.SerializationError{Err: err} 7413 } 7414 7415 restEncoder.SetHeader("Content-Type").String("application/json") 7416 7417 jsonEncoder := smithyjson.NewEncoder() 7418 if err := awsRestjson1_serializeOpDocumentUpdateDataSourcePermissionsInput(input, jsonEncoder.Value); err != nil { 7419 return out, metadata, &smithy.SerializationError{Err: err} 7420 } 7421 7422 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7423 return out, metadata, &smithy.SerializationError{Err: err} 7424 } 7425 7426 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7427 return out, metadata, &smithy.SerializationError{Err: err} 7428 } 7429 in.Request = request 7430 7431 return next.HandleSerialize(ctx, in) 7432} 7433func awsRestjson1_serializeOpHttpBindingsUpdateDataSourcePermissionsInput(v *UpdateDataSourcePermissionsInput, encoder *httpbinding.Encoder) error { 7434 if v == nil { 7435 return fmt.Errorf("unsupported serialization of nil %T", v) 7436 } 7437 7438 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7439 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7440 } 7441 if v.AwsAccountId != nil { 7442 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7443 return err 7444 } 7445 } 7446 7447 if v.DataSourceId == nil || len(*v.DataSourceId) == 0 { 7448 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")} 7449 } 7450 if v.DataSourceId != nil { 7451 if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil { 7452 return err 7453 } 7454 } 7455 7456 return nil 7457} 7458 7459func awsRestjson1_serializeOpDocumentUpdateDataSourcePermissionsInput(v *UpdateDataSourcePermissionsInput, value smithyjson.Value) error { 7460 object := value.Object() 7461 defer object.Close() 7462 7463 if v.GrantPermissions != nil { 7464 ok := object.Key("GrantPermissions") 7465 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.GrantPermissions, ok); err != nil { 7466 return err 7467 } 7468 } 7469 7470 if v.RevokePermissions != nil { 7471 ok := object.Key("RevokePermissions") 7472 if err := awsRestjson1_serializeDocumentResourcePermissionList(v.RevokePermissions, ok); err != nil { 7473 return err 7474 } 7475 } 7476 7477 return nil 7478} 7479 7480type awsRestjson1_serializeOpUpdateGroup struct { 7481} 7482 7483func (*awsRestjson1_serializeOpUpdateGroup) ID() string { 7484 return "OperationSerializer" 7485} 7486 7487func (m *awsRestjson1_serializeOpUpdateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7488 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7489) { 7490 request, ok := in.Request.(*smithyhttp.Request) 7491 if !ok { 7492 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7493 } 7494 7495 input, ok := in.Parameters.(*UpdateGroupInput) 7496 _ = input 7497 if !ok { 7498 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7499 } 7500 7501 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}") 7502 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7503 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7504 request.Method = "PUT" 7505 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7506 if err != nil { 7507 return out, metadata, &smithy.SerializationError{Err: err} 7508 } 7509 7510 if err := awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(input, restEncoder); err != nil { 7511 return out, metadata, &smithy.SerializationError{Err: err} 7512 } 7513 7514 restEncoder.SetHeader("Content-Type").String("application/json") 7515 7516 jsonEncoder := smithyjson.NewEncoder() 7517 if err := awsRestjson1_serializeOpDocumentUpdateGroupInput(input, jsonEncoder.Value); err != nil { 7518 return out, metadata, &smithy.SerializationError{Err: err} 7519 } 7520 7521 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7522 return out, metadata, &smithy.SerializationError{Err: err} 7523 } 7524 7525 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7526 return out, metadata, &smithy.SerializationError{Err: err} 7527 } 7528 in.Request = request 7529 7530 return next.HandleSerialize(ctx, in) 7531} 7532func awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(v *UpdateGroupInput, encoder *httpbinding.Encoder) error { 7533 if v == nil { 7534 return fmt.Errorf("unsupported serialization of nil %T", v) 7535 } 7536 7537 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7538 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7539 } 7540 if v.AwsAccountId != nil { 7541 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7542 return err 7543 } 7544 } 7545 7546 if v.GroupName == nil || len(*v.GroupName) == 0 { 7547 return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")} 7548 } 7549 if v.GroupName != nil { 7550 if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil { 7551 return err 7552 } 7553 } 7554 7555 if v.Namespace == nil || len(*v.Namespace) == 0 { 7556 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 7557 } 7558 if v.Namespace != nil { 7559 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 7560 return err 7561 } 7562 } 7563 7564 return nil 7565} 7566 7567func awsRestjson1_serializeOpDocumentUpdateGroupInput(v *UpdateGroupInput, value smithyjson.Value) error { 7568 object := value.Object() 7569 defer object.Close() 7570 7571 if v.Description != nil { 7572 ok := object.Key("Description") 7573 ok.String(*v.Description) 7574 } 7575 7576 return nil 7577} 7578 7579type awsRestjson1_serializeOpUpdateIAMPolicyAssignment struct { 7580} 7581 7582func (*awsRestjson1_serializeOpUpdateIAMPolicyAssignment) ID() string { 7583 return "OperationSerializer" 7584} 7585 7586func (m *awsRestjson1_serializeOpUpdateIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7587 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7588) { 7589 request, ok := in.Request.(*smithyhttp.Request) 7590 if !ok { 7591 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7592 } 7593 7594 input, ok := in.Parameters.(*UpdateIAMPolicyAssignmentInput) 7595 _ = input 7596 if !ok { 7597 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7598 } 7599 7600 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments/{AssignmentName}") 7601 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7602 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7603 request.Method = "PUT" 7604 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7605 if err != nil { 7606 return out, metadata, &smithy.SerializationError{Err: err} 7607 } 7608 7609 if err := awsRestjson1_serializeOpHttpBindingsUpdateIAMPolicyAssignmentInput(input, restEncoder); err != nil { 7610 return out, metadata, &smithy.SerializationError{Err: err} 7611 } 7612 7613 restEncoder.SetHeader("Content-Type").String("application/json") 7614 7615 jsonEncoder := smithyjson.NewEncoder() 7616 if err := awsRestjson1_serializeOpDocumentUpdateIAMPolicyAssignmentInput(input, jsonEncoder.Value); err != nil { 7617 return out, metadata, &smithy.SerializationError{Err: err} 7618 } 7619 7620 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7621 return out, metadata, &smithy.SerializationError{Err: err} 7622 } 7623 7624 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7625 return out, metadata, &smithy.SerializationError{Err: err} 7626 } 7627 in.Request = request 7628 7629 return next.HandleSerialize(ctx, in) 7630} 7631func awsRestjson1_serializeOpHttpBindingsUpdateIAMPolicyAssignmentInput(v *UpdateIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error { 7632 if v == nil { 7633 return fmt.Errorf("unsupported serialization of nil %T", v) 7634 } 7635 7636 if v.AssignmentName == nil || len(*v.AssignmentName) == 0 { 7637 return &smithy.SerializationError{Err: fmt.Errorf("input member AssignmentName must not be empty")} 7638 } 7639 if v.AssignmentName != nil { 7640 if err := encoder.SetURI("AssignmentName").String(*v.AssignmentName); err != nil { 7641 return err 7642 } 7643 } 7644 7645 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7646 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7647 } 7648 if v.AwsAccountId != nil { 7649 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7650 return err 7651 } 7652 } 7653 7654 if v.Namespace == nil || len(*v.Namespace) == 0 { 7655 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 7656 } 7657 if v.Namespace != nil { 7658 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 7659 return err 7660 } 7661 } 7662 7663 return nil 7664} 7665 7666func awsRestjson1_serializeOpDocumentUpdateIAMPolicyAssignmentInput(v *UpdateIAMPolicyAssignmentInput, value smithyjson.Value) error { 7667 object := value.Object() 7668 defer object.Close() 7669 7670 if len(v.AssignmentStatus) > 0 { 7671 ok := object.Key("AssignmentStatus") 7672 ok.String(string(v.AssignmentStatus)) 7673 } 7674 7675 if v.Identities != nil { 7676 ok := object.Key("Identities") 7677 if err := awsRestjson1_serializeDocumentIdentityMap(v.Identities, ok); err != nil { 7678 return err 7679 } 7680 } 7681 7682 if v.PolicyArn != nil { 7683 ok := object.Key("PolicyArn") 7684 ok.String(*v.PolicyArn) 7685 } 7686 7687 return nil 7688} 7689 7690type awsRestjson1_serializeOpUpdateTemplate struct { 7691} 7692 7693func (*awsRestjson1_serializeOpUpdateTemplate) ID() string { 7694 return "OperationSerializer" 7695} 7696 7697func (m *awsRestjson1_serializeOpUpdateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7698 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7699) { 7700 request, ok := in.Request.(*smithyhttp.Request) 7701 if !ok { 7702 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7703 } 7704 7705 input, ok := in.Parameters.(*UpdateTemplateInput) 7706 _ = input 7707 if !ok { 7708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7709 } 7710 7711 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}") 7712 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7713 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7714 request.Method = "PUT" 7715 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7716 if err != nil { 7717 return out, metadata, &smithy.SerializationError{Err: err} 7718 } 7719 7720 if err := awsRestjson1_serializeOpHttpBindingsUpdateTemplateInput(input, restEncoder); err != nil { 7721 return out, metadata, &smithy.SerializationError{Err: err} 7722 } 7723 7724 restEncoder.SetHeader("Content-Type").String("application/json") 7725 7726 jsonEncoder := smithyjson.NewEncoder() 7727 if err := awsRestjson1_serializeOpDocumentUpdateTemplateInput(input, jsonEncoder.Value); err != nil { 7728 return out, metadata, &smithy.SerializationError{Err: err} 7729 } 7730 7731 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7732 return out, metadata, &smithy.SerializationError{Err: err} 7733 } 7734 7735 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7736 return out, metadata, &smithy.SerializationError{Err: err} 7737 } 7738 in.Request = request 7739 7740 return next.HandleSerialize(ctx, in) 7741} 7742func awsRestjson1_serializeOpHttpBindingsUpdateTemplateInput(v *UpdateTemplateInput, encoder *httpbinding.Encoder) error { 7743 if v == nil { 7744 return fmt.Errorf("unsupported serialization of nil %T", v) 7745 } 7746 7747 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7748 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7749 } 7750 if v.AwsAccountId != nil { 7751 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7752 return err 7753 } 7754 } 7755 7756 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 7757 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 7758 } 7759 if v.TemplateId != nil { 7760 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 7761 return err 7762 } 7763 } 7764 7765 return nil 7766} 7767 7768func awsRestjson1_serializeOpDocumentUpdateTemplateInput(v *UpdateTemplateInput, value smithyjson.Value) error { 7769 object := value.Object() 7770 defer object.Close() 7771 7772 if v.Name != nil { 7773 ok := object.Key("Name") 7774 ok.String(*v.Name) 7775 } 7776 7777 if v.SourceEntity != nil { 7778 ok := object.Key("SourceEntity") 7779 if err := awsRestjson1_serializeDocumentTemplateSourceEntity(v.SourceEntity, ok); err != nil { 7780 return err 7781 } 7782 } 7783 7784 if v.VersionDescription != nil { 7785 ok := object.Key("VersionDescription") 7786 ok.String(*v.VersionDescription) 7787 } 7788 7789 return nil 7790} 7791 7792type awsRestjson1_serializeOpUpdateTemplateAlias struct { 7793} 7794 7795func (*awsRestjson1_serializeOpUpdateTemplateAlias) ID() string { 7796 return "OperationSerializer" 7797} 7798 7799func (m *awsRestjson1_serializeOpUpdateTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7800 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7801) { 7802 request, ok := in.Request.(*smithyhttp.Request) 7803 if !ok { 7804 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7805 } 7806 7807 input, ok := in.Parameters.(*UpdateTemplateAliasInput) 7808 _ = input 7809 if !ok { 7810 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7811 } 7812 7813 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}") 7814 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7815 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7816 request.Method = "PUT" 7817 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7818 if err != nil { 7819 return out, metadata, &smithy.SerializationError{Err: err} 7820 } 7821 7822 if err := awsRestjson1_serializeOpHttpBindingsUpdateTemplateAliasInput(input, restEncoder); err != nil { 7823 return out, metadata, &smithy.SerializationError{Err: err} 7824 } 7825 7826 restEncoder.SetHeader("Content-Type").String("application/json") 7827 7828 jsonEncoder := smithyjson.NewEncoder() 7829 if err := awsRestjson1_serializeOpDocumentUpdateTemplateAliasInput(input, jsonEncoder.Value); err != nil { 7830 return out, metadata, &smithy.SerializationError{Err: err} 7831 } 7832 7833 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7834 return out, metadata, &smithy.SerializationError{Err: err} 7835 } 7836 7837 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7838 return out, metadata, &smithy.SerializationError{Err: err} 7839 } 7840 in.Request = request 7841 7842 return next.HandleSerialize(ctx, in) 7843} 7844func awsRestjson1_serializeOpHttpBindingsUpdateTemplateAliasInput(v *UpdateTemplateAliasInput, encoder *httpbinding.Encoder) error { 7845 if v == nil { 7846 return fmt.Errorf("unsupported serialization of nil %T", v) 7847 } 7848 7849 if v.AliasName == nil || len(*v.AliasName) == 0 { 7850 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 7851 } 7852 if v.AliasName != nil { 7853 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 7854 return err 7855 } 7856 } 7857 7858 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7859 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7860 } 7861 if v.AwsAccountId != nil { 7862 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7863 return err 7864 } 7865 } 7866 7867 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 7868 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 7869 } 7870 if v.TemplateId != nil { 7871 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 7872 return err 7873 } 7874 } 7875 7876 return nil 7877} 7878 7879func awsRestjson1_serializeOpDocumentUpdateTemplateAliasInput(v *UpdateTemplateAliasInput, value smithyjson.Value) error { 7880 object := value.Object() 7881 defer object.Close() 7882 7883 if v.TemplateVersionNumber != nil { 7884 ok := object.Key("TemplateVersionNumber") 7885 ok.Long(*v.TemplateVersionNumber) 7886 } 7887 7888 return nil 7889} 7890 7891type awsRestjson1_serializeOpUpdateTemplatePermissions struct { 7892} 7893 7894func (*awsRestjson1_serializeOpUpdateTemplatePermissions) ID() string { 7895 return "OperationSerializer" 7896} 7897 7898func (m *awsRestjson1_serializeOpUpdateTemplatePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7899 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7900) { 7901 request, ok := in.Request.(*smithyhttp.Request) 7902 if !ok { 7903 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7904 } 7905 7906 input, ok := in.Parameters.(*UpdateTemplatePermissionsInput) 7907 _ = input 7908 if !ok { 7909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7910 } 7911 7912 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/permissions") 7913 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7914 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7915 request.Method = "PUT" 7916 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7917 if err != nil { 7918 return out, metadata, &smithy.SerializationError{Err: err} 7919 } 7920 7921 if err := awsRestjson1_serializeOpHttpBindingsUpdateTemplatePermissionsInput(input, restEncoder); err != nil { 7922 return out, metadata, &smithy.SerializationError{Err: err} 7923 } 7924 7925 restEncoder.SetHeader("Content-Type").String("application/json") 7926 7927 jsonEncoder := smithyjson.NewEncoder() 7928 if err := awsRestjson1_serializeOpDocumentUpdateTemplatePermissionsInput(input, jsonEncoder.Value); err != nil { 7929 return out, metadata, &smithy.SerializationError{Err: err} 7930 } 7931 7932 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7933 return out, metadata, &smithy.SerializationError{Err: err} 7934 } 7935 7936 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7937 return out, metadata, &smithy.SerializationError{Err: err} 7938 } 7939 in.Request = request 7940 7941 return next.HandleSerialize(ctx, in) 7942} 7943func awsRestjson1_serializeOpHttpBindingsUpdateTemplatePermissionsInput(v *UpdateTemplatePermissionsInput, encoder *httpbinding.Encoder) error { 7944 if v == nil { 7945 return fmt.Errorf("unsupported serialization of nil %T", v) 7946 } 7947 7948 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 7949 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 7950 } 7951 if v.AwsAccountId != nil { 7952 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 7953 return err 7954 } 7955 } 7956 7957 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 7958 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 7959 } 7960 if v.TemplateId != nil { 7961 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 7962 return err 7963 } 7964 } 7965 7966 return nil 7967} 7968 7969func awsRestjson1_serializeOpDocumentUpdateTemplatePermissionsInput(v *UpdateTemplatePermissionsInput, value smithyjson.Value) error { 7970 object := value.Object() 7971 defer object.Close() 7972 7973 if v.GrantPermissions != nil { 7974 ok := object.Key("GrantPermissions") 7975 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil { 7976 return err 7977 } 7978 } 7979 7980 if v.RevokePermissions != nil { 7981 ok := object.Key("RevokePermissions") 7982 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil { 7983 return err 7984 } 7985 } 7986 7987 return nil 7988} 7989 7990type awsRestjson1_serializeOpUpdateTheme struct { 7991} 7992 7993func (*awsRestjson1_serializeOpUpdateTheme) ID() string { 7994 return "OperationSerializer" 7995} 7996 7997func (m *awsRestjson1_serializeOpUpdateTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7998 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7999) { 8000 request, ok := in.Request.(*smithyhttp.Request) 8001 if !ok { 8002 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 8003 } 8004 8005 input, ok := in.Parameters.(*UpdateThemeInput) 8006 _ = input 8007 if !ok { 8008 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 8009 } 8010 8011 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}") 8012 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 8013 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 8014 request.Method = "PUT" 8015 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 8016 if err != nil { 8017 return out, metadata, &smithy.SerializationError{Err: err} 8018 } 8019 8020 if err := awsRestjson1_serializeOpHttpBindingsUpdateThemeInput(input, restEncoder); err != nil { 8021 return out, metadata, &smithy.SerializationError{Err: err} 8022 } 8023 8024 restEncoder.SetHeader("Content-Type").String("application/json") 8025 8026 jsonEncoder := smithyjson.NewEncoder() 8027 if err := awsRestjson1_serializeOpDocumentUpdateThemeInput(input, jsonEncoder.Value); err != nil { 8028 return out, metadata, &smithy.SerializationError{Err: err} 8029 } 8030 8031 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 8032 return out, metadata, &smithy.SerializationError{Err: err} 8033 } 8034 8035 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 8036 return out, metadata, &smithy.SerializationError{Err: err} 8037 } 8038 in.Request = request 8039 8040 return next.HandleSerialize(ctx, in) 8041} 8042func awsRestjson1_serializeOpHttpBindingsUpdateThemeInput(v *UpdateThemeInput, encoder *httpbinding.Encoder) error { 8043 if v == nil { 8044 return fmt.Errorf("unsupported serialization of nil %T", v) 8045 } 8046 8047 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 8048 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 8049 } 8050 if v.AwsAccountId != nil { 8051 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 8052 return err 8053 } 8054 } 8055 8056 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 8057 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 8058 } 8059 if v.ThemeId != nil { 8060 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 8061 return err 8062 } 8063 } 8064 8065 return nil 8066} 8067 8068func awsRestjson1_serializeOpDocumentUpdateThemeInput(v *UpdateThemeInput, value smithyjson.Value) error { 8069 object := value.Object() 8070 defer object.Close() 8071 8072 if v.BaseThemeId != nil { 8073 ok := object.Key("BaseThemeId") 8074 ok.String(*v.BaseThemeId) 8075 } 8076 8077 if v.Configuration != nil { 8078 ok := object.Key("Configuration") 8079 if err := awsRestjson1_serializeDocumentThemeConfiguration(v.Configuration, ok); err != nil { 8080 return err 8081 } 8082 } 8083 8084 if v.Name != nil { 8085 ok := object.Key("Name") 8086 ok.String(*v.Name) 8087 } 8088 8089 if v.VersionDescription != nil { 8090 ok := object.Key("VersionDescription") 8091 ok.String(*v.VersionDescription) 8092 } 8093 8094 return nil 8095} 8096 8097type awsRestjson1_serializeOpUpdateThemeAlias struct { 8098} 8099 8100func (*awsRestjson1_serializeOpUpdateThemeAlias) ID() string { 8101 return "OperationSerializer" 8102} 8103 8104func (m *awsRestjson1_serializeOpUpdateThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 8105 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 8106) { 8107 request, ok := in.Request.(*smithyhttp.Request) 8108 if !ok { 8109 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 8110 } 8111 8112 input, ok := in.Parameters.(*UpdateThemeAliasInput) 8113 _ = input 8114 if !ok { 8115 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 8116 } 8117 8118 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}") 8119 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 8120 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 8121 request.Method = "PUT" 8122 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 8123 if err != nil { 8124 return out, metadata, &smithy.SerializationError{Err: err} 8125 } 8126 8127 if err := awsRestjson1_serializeOpHttpBindingsUpdateThemeAliasInput(input, restEncoder); err != nil { 8128 return out, metadata, &smithy.SerializationError{Err: err} 8129 } 8130 8131 restEncoder.SetHeader("Content-Type").String("application/json") 8132 8133 jsonEncoder := smithyjson.NewEncoder() 8134 if err := awsRestjson1_serializeOpDocumentUpdateThemeAliasInput(input, jsonEncoder.Value); err != nil { 8135 return out, metadata, &smithy.SerializationError{Err: err} 8136 } 8137 8138 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 8139 return out, metadata, &smithy.SerializationError{Err: err} 8140 } 8141 8142 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 8143 return out, metadata, &smithy.SerializationError{Err: err} 8144 } 8145 in.Request = request 8146 8147 return next.HandleSerialize(ctx, in) 8148} 8149func awsRestjson1_serializeOpHttpBindingsUpdateThemeAliasInput(v *UpdateThemeAliasInput, encoder *httpbinding.Encoder) error { 8150 if v == nil { 8151 return fmt.Errorf("unsupported serialization of nil %T", v) 8152 } 8153 8154 if v.AliasName == nil || len(*v.AliasName) == 0 { 8155 return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")} 8156 } 8157 if v.AliasName != nil { 8158 if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil { 8159 return err 8160 } 8161 } 8162 8163 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 8164 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 8165 } 8166 if v.AwsAccountId != nil { 8167 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 8168 return err 8169 } 8170 } 8171 8172 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 8173 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 8174 } 8175 if v.ThemeId != nil { 8176 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 8177 return err 8178 } 8179 } 8180 8181 return nil 8182} 8183 8184func awsRestjson1_serializeOpDocumentUpdateThemeAliasInput(v *UpdateThemeAliasInput, value smithyjson.Value) error { 8185 object := value.Object() 8186 defer object.Close() 8187 8188 if v.ThemeVersionNumber != nil { 8189 ok := object.Key("ThemeVersionNumber") 8190 ok.Long(*v.ThemeVersionNumber) 8191 } 8192 8193 return nil 8194} 8195 8196type awsRestjson1_serializeOpUpdateThemePermissions struct { 8197} 8198 8199func (*awsRestjson1_serializeOpUpdateThemePermissions) ID() string { 8200 return "OperationSerializer" 8201} 8202 8203func (m *awsRestjson1_serializeOpUpdateThemePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 8204 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 8205) { 8206 request, ok := in.Request.(*smithyhttp.Request) 8207 if !ok { 8208 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 8209 } 8210 8211 input, ok := in.Parameters.(*UpdateThemePermissionsInput) 8212 _ = input 8213 if !ok { 8214 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 8215 } 8216 8217 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/permissions") 8218 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 8219 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 8220 request.Method = "PUT" 8221 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 8222 if err != nil { 8223 return out, metadata, &smithy.SerializationError{Err: err} 8224 } 8225 8226 if err := awsRestjson1_serializeOpHttpBindingsUpdateThemePermissionsInput(input, restEncoder); err != nil { 8227 return out, metadata, &smithy.SerializationError{Err: err} 8228 } 8229 8230 restEncoder.SetHeader("Content-Type").String("application/json") 8231 8232 jsonEncoder := smithyjson.NewEncoder() 8233 if err := awsRestjson1_serializeOpDocumentUpdateThemePermissionsInput(input, jsonEncoder.Value); err != nil { 8234 return out, metadata, &smithy.SerializationError{Err: err} 8235 } 8236 8237 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 8238 return out, metadata, &smithy.SerializationError{Err: err} 8239 } 8240 8241 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 8242 return out, metadata, &smithy.SerializationError{Err: err} 8243 } 8244 in.Request = request 8245 8246 return next.HandleSerialize(ctx, in) 8247} 8248func awsRestjson1_serializeOpHttpBindingsUpdateThemePermissionsInput(v *UpdateThemePermissionsInput, encoder *httpbinding.Encoder) error { 8249 if v == nil { 8250 return fmt.Errorf("unsupported serialization of nil %T", v) 8251 } 8252 8253 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 8254 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 8255 } 8256 if v.AwsAccountId != nil { 8257 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 8258 return err 8259 } 8260 } 8261 8262 if v.ThemeId == nil || len(*v.ThemeId) == 0 { 8263 return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")} 8264 } 8265 if v.ThemeId != nil { 8266 if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil { 8267 return err 8268 } 8269 } 8270 8271 return nil 8272} 8273 8274func awsRestjson1_serializeOpDocumentUpdateThemePermissionsInput(v *UpdateThemePermissionsInput, value smithyjson.Value) error { 8275 object := value.Object() 8276 defer object.Close() 8277 8278 if v.GrantPermissions != nil { 8279 ok := object.Key("GrantPermissions") 8280 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil { 8281 return err 8282 } 8283 } 8284 8285 if v.RevokePermissions != nil { 8286 ok := object.Key("RevokePermissions") 8287 if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil { 8288 return err 8289 } 8290 } 8291 8292 return nil 8293} 8294 8295type awsRestjson1_serializeOpUpdateUser struct { 8296} 8297 8298func (*awsRestjson1_serializeOpUpdateUser) ID() string { 8299 return "OperationSerializer" 8300} 8301 8302func (m *awsRestjson1_serializeOpUpdateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 8303 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 8304) { 8305 request, ok := in.Request.(*smithyhttp.Request) 8306 if !ok { 8307 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 8308 } 8309 8310 input, ok := in.Parameters.(*UpdateUserInput) 8311 _ = input 8312 if !ok { 8313 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 8314 } 8315 8316 opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}") 8317 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 8318 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 8319 request.Method = "PUT" 8320 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 8321 if err != nil { 8322 return out, metadata, &smithy.SerializationError{Err: err} 8323 } 8324 8325 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserInput(input, restEncoder); err != nil { 8326 return out, metadata, &smithy.SerializationError{Err: err} 8327 } 8328 8329 restEncoder.SetHeader("Content-Type").String("application/json") 8330 8331 jsonEncoder := smithyjson.NewEncoder() 8332 if err := awsRestjson1_serializeOpDocumentUpdateUserInput(input, jsonEncoder.Value); err != nil { 8333 return out, metadata, &smithy.SerializationError{Err: err} 8334 } 8335 8336 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 8337 return out, metadata, &smithy.SerializationError{Err: err} 8338 } 8339 8340 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 8341 return out, metadata, &smithy.SerializationError{Err: err} 8342 } 8343 in.Request = request 8344 8345 return next.HandleSerialize(ctx, in) 8346} 8347func awsRestjson1_serializeOpHttpBindingsUpdateUserInput(v *UpdateUserInput, encoder *httpbinding.Encoder) error { 8348 if v == nil { 8349 return fmt.Errorf("unsupported serialization of nil %T", v) 8350 } 8351 8352 if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 { 8353 return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")} 8354 } 8355 if v.AwsAccountId != nil { 8356 if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil { 8357 return err 8358 } 8359 } 8360 8361 if v.Namespace == nil || len(*v.Namespace) == 0 { 8362 return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")} 8363 } 8364 if v.Namespace != nil { 8365 if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil { 8366 return err 8367 } 8368 } 8369 8370 if v.UserName == nil || len(*v.UserName) == 0 { 8371 return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")} 8372 } 8373 if v.UserName != nil { 8374 if err := encoder.SetURI("UserName").String(*v.UserName); err != nil { 8375 return err 8376 } 8377 } 8378 8379 return nil 8380} 8381 8382func awsRestjson1_serializeOpDocumentUpdateUserInput(v *UpdateUserInput, value smithyjson.Value) error { 8383 object := value.Object() 8384 defer object.Close() 8385 8386 if v.CustomPermissionsName != nil { 8387 ok := object.Key("CustomPermissionsName") 8388 ok.String(*v.CustomPermissionsName) 8389 } 8390 8391 if v.Email != nil { 8392 ok := object.Key("Email") 8393 ok.String(*v.Email) 8394 } 8395 8396 if len(v.Role) > 0 { 8397 ok := object.Key("Role") 8398 ok.String(string(v.Role)) 8399 } 8400 8401 if v.UnapplyCustomPermissions { 8402 ok := object.Key("UnapplyCustomPermissions") 8403 ok.Boolean(v.UnapplyCustomPermissions) 8404 } 8405 8406 return nil 8407} 8408 8409func awsRestjson1_serializeDocumentAccountCustomization(v *types.AccountCustomization, value smithyjson.Value) error { 8410 object := value.Object() 8411 defer object.Close() 8412 8413 if v.DefaultTheme != nil { 8414 ok := object.Key("DefaultTheme") 8415 ok.String(*v.DefaultTheme) 8416 } 8417 8418 return nil 8419} 8420 8421func awsRestjson1_serializeDocumentActionList(v []string, value smithyjson.Value) error { 8422 array := value.Array() 8423 defer array.Close() 8424 8425 for i := range v { 8426 av := array.Value() 8427 av.String(v[i]) 8428 } 8429 return nil 8430} 8431 8432func awsRestjson1_serializeDocumentAdHocFilteringOption(v *types.AdHocFilteringOption, value smithyjson.Value) error { 8433 object := value.Object() 8434 defer object.Close() 8435 8436 if len(v.AvailabilityStatus) > 0 { 8437 ok := object.Key("AvailabilityStatus") 8438 ok.String(string(v.AvailabilityStatus)) 8439 } 8440 8441 return nil 8442} 8443 8444func awsRestjson1_serializeDocumentAmazonElasticsearchParameters(v *types.AmazonElasticsearchParameters, value smithyjson.Value) error { 8445 object := value.Object() 8446 defer object.Close() 8447 8448 if v.Domain != nil { 8449 ok := object.Key("Domain") 8450 ok.String(*v.Domain) 8451 } 8452 8453 return nil 8454} 8455 8456func awsRestjson1_serializeDocumentAnalysisSearchFilter(v *types.AnalysisSearchFilter, value smithyjson.Value) error { 8457 object := value.Object() 8458 defer object.Close() 8459 8460 if len(v.Name) > 0 { 8461 ok := object.Key("Name") 8462 ok.String(string(v.Name)) 8463 } 8464 8465 if len(v.Operator) > 0 { 8466 ok := object.Key("Operator") 8467 ok.String(string(v.Operator)) 8468 } 8469 8470 if v.Value != nil { 8471 ok := object.Key("Value") 8472 ok.String(*v.Value) 8473 } 8474 8475 return nil 8476} 8477 8478func awsRestjson1_serializeDocumentAnalysisSearchFilterList(v []types.AnalysisSearchFilter, value smithyjson.Value) error { 8479 array := value.Array() 8480 defer array.Close() 8481 8482 for i := range v { 8483 av := array.Value() 8484 if err := awsRestjson1_serializeDocumentAnalysisSearchFilter(&v[i], av); err != nil { 8485 return err 8486 } 8487 } 8488 return nil 8489} 8490 8491func awsRestjson1_serializeDocumentAnalysisSourceEntity(v *types.AnalysisSourceEntity, value smithyjson.Value) error { 8492 object := value.Object() 8493 defer object.Close() 8494 8495 if v.SourceTemplate != nil { 8496 ok := object.Key("SourceTemplate") 8497 if err := awsRestjson1_serializeDocumentAnalysisSourceTemplate(v.SourceTemplate, ok); err != nil { 8498 return err 8499 } 8500 } 8501 8502 return nil 8503} 8504 8505func awsRestjson1_serializeDocumentAnalysisSourceTemplate(v *types.AnalysisSourceTemplate, value smithyjson.Value) error { 8506 object := value.Object() 8507 defer object.Close() 8508 8509 if v.Arn != nil { 8510 ok := object.Key("Arn") 8511 ok.String(*v.Arn) 8512 } 8513 8514 if v.DataSetReferences != nil { 8515 ok := object.Key("DataSetReferences") 8516 if err := awsRestjson1_serializeDocumentDataSetReferenceList(v.DataSetReferences, ok); err != nil { 8517 return err 8518 } 8519 } 8520 8521 return nil 8522} 8523 8524func awsRestjson1_serializeDocumentAthenaParameters(v *types.AthenaParameters, value smithyjson.Value) error { 8525 object := value.Object() 8526 defer object.Close() 8527 8528 if v.WorkGroup != nil { 8529 ok := object.Key("WorkGroup") 8530 ok.String(*v.WorkGroup) 8531 } 8532 8533 return nil 8534} 8535 8536func awsRestjson1_serializeDocumentAuroraParameters(v *types.AuroraParameters, value smithyjson.Value) error { 8537 object := value.Object() 8538 defer object.Close() 8539 8540 if v.Database != nil { 8541 ok := object.Key("Database") 8542 ok.String(*v.Database) 8543 } 8544 8545 if v.Host != nil { 8546 ok := object.Key("Host") 8547 ok.String(*v.Host) 8548 } 8549 8550 { 8551 ok := object.Key("Port") 8552 ok.Integer(v.Port) 8553 } 8554 8555 return nil 8556} 8557 8558func awsRestjson1_serializeDocumentAuroraPostgreSqlParameters(v *types.AuroraPostgreSqlParameters, value smithyjson.Value) error { 8559 object := value.Object() 8560 defer object.Close() 8561 8562 if v.Database != nil { 8563 ok := object.Key("Database") 8564 ok.String(*v.Database) 8565 } 8566 8567 if v.Host != nil { 8568 ok := object.Key("Host") 8569 ok.String(*v.Host) 8570 } 8571 8572 { 8573 ok := object.Key("Port") 8574 ok.Integer(v.Port) 8575 } 8576 8577 return nil 8578} 8579 8580func awsRestjson1_serializeDocumentAwsIotAnalyticsParameters(v *types.AwsIotAnalyticsParameters, value smithyjson.Value) error { 8581 object := value.Object() 8582 defer object.Close() 8583 8584 if v.DataSetName != nil { 8585 ok := object.Key("DataSetName") 8586 ok.String(*v.DataSetName) 8587 } 8588 8589 return nil 8590} 8591 8592func awsRestjson1_serializeDocumentBorderStyle(v *types.BorderStyle, value smithyjson.Value) error { 8593 object := value.Object() 8594 defer object.Close() 8595 8596 if v.Show { 8597 ok := object.Key("Show") 8598 ok.Boolean(v.Show) 8599 } 8600 8601 return nil 8602} 8603 8604func awsRestjson1_serializeDocumentCalculatedColumn(v *types.CalculatedColumn, value smithyjson.Value) error { 8605 object := value.Object() 8606 defer object.Close() 8607 8608 if v.ColumnId != nil { 8609 ok := object.Key("ColumnId") 8610 ok.String(*v.ColumnId) 8611 } 8612 8613 if v.ColumnName != nil { 8614 ok := object.Key("ColumnName") 8615 ok.String(*v.ColumnName) 8616 } 8617 8618 if v.Expression != nil { 8619 ok := object.Key("Expression") 8620 ok.String(*v.Expression) 8621 } 8622 8623 return nil 8624} 8625 8626func awsRestjson1_serializeDocumentCalculatedColumnList(v []types.CalculatedColumn, value smithyjson.Value) error { 8627 array := value.Array() 8628 defer array.Close() 8629 8630 for i := range v { 8631 av := array.Value() 8632 if err := awsRestjson1_serializeDocumentCalculatedColumn(&v[i], av); err != nil { 8633 return err 8634 } 8635 } 8636 return nil 8637} 8638 8639func awsRestjson1_serializeDocumentCastColumnTypeOperation(v *types.CastColumnTypeOperation, value smithyjson.Value) error { 8640 object := value.Object() 8641 defer object.Close() 8642 8643 if v.ColumnName != nil { 8644 ok := object.Key("ColumnName") 8645 ok.String(*v.ColumnName) 8646 } 8647 8648 if v.Format != nil { 8649 ok := object.Key("Format") 8650 ok.String(*v.Format) 8651 } 8652 8653 if len(v.NewColumnType) > 0 { 8654 ok := object.Key("NewColumnType") 8655 ok.String(string(v.NewColumnType)) 8656 } 8657 8658 return nil 8659} 8660 8661func awsRestjson1_serializeDocumentColorList(v []string, value smithyjson.Value) error { 8662 array := value.Array() 8663 defer array.Close() 8664 8665 for i := range v { 8666 av := array.Value() 8667 av.String(v[i]) 8668 } 8669 return nil 8670} 8671 8672func awsRestjson1_serializeDocumentColumnDescription(v *types.ColumnDescription, value smithyjson.Value) error { 8673 object := value.Object() 8674 defer object.Close() 8675 8676 if v.Text != nil { 8677 ok := object.Key("Text") 8678 ok.String(*v.Text) 8679 } 8680 8681 return nil 8682} 8683 8684func awsRestjson1_serializeDocumentColumnGroup(v *types.ColumnGroup, value smithyjson.Value) error { 8685 object := value.Object() 8686 defer object.Close() 8687 8688 if v.GeoSpatialColumnGroup != nil { 8689 ok := object.Key("GeoSpatialColumnGroup") 8690 if err := awsRestjson1_serializeDocumentGeoSpatialColumnGroup(v.GeoSpatialColumnGroup, ok); err != nil { 8691 return err 8692 } 8693 } 8694 8695 return nil 8696} 8697 8698func awsRestjson1_serializeDocumentColumnGroupList(v []types.ColumnGroup, value smithyjson.Value) error { 8699 array := value.Array() 8700 defer array.Close() 8701 8702 for i := range v { 8703 av := array.Value() 8704 if err := awsRestjson1_serializeDocumentColumnGroup(&v[i], av); err != nil { 8705 return err 8706 } 8707 } 8708 return nil 8709} 8710 8711func awsRestjson1_serializeDocumentColumnLevelPermissionRule(v *types.ColumnLevelPermissionRule, value smithyjson.Value) error { 8712 object := value.Object() 8713 defer object.Close() 8714 8715 if v.ColumnNames != nil { 8716 ok := object.Key("ColumnNames") 8717 if err := awsRestjson1_serializeDocumentColumnNameList(v.ColumnNames, ok); err != nil { 8718 return err 8719 } 8720 } 8721 8722 if v.Principals != nil { 8723 ok := object.Key("Principals") 8724 if err := awsRestjson1_serializeDocumentPrincipalList(v.Principals, ok); err != nil { 8725 return err 8726 } 8727 } 8728 8729 return nil 8730} 8731 8732func awsRestjson1_serializeDocumentColumnLevelPermissionRuleList(v []types.ColumnLevelPermissionRule, value smithyjson.Value) error { 8733 array := value.Array() 8734 defer array.Close() 8735 8736 for i := range v { 8737 av := array.Value() 8738 if err := awsRestjson1_serializeDocumentColumnLevelPermissionRule(&v[i], av); err != nil { 8739 return err 8740 } 8741 } 8742 return nil 8743} 8744 8745func awsRestjson1_serializeDocumentColumnList(v []string, value smithyjson.Value) error { 8746 array := value.Array() 8747 defer array.Close() 8748 8749 for i := range v { 8750 av := array.Value() 8751 av.String(v[i]) 8752 } 8753 return nil 8754} 8755 8756func awsRestjson1_serializeDocumentColumnNameList(v []string, value smithyjson.Value) error { 8757 array := value.Array() 8758 defer array.Close() 8759 8760 for i := range v { 8761 av := array.Value() 8762 av.String(v[i]) 8763 } 8764 return nil 8765} 8766 8767func awsRestjson1_serializeDocumentColumnTag(v *types.ColumnTag, value smithyjson.Value) error { 8768 object := value.Object() 8769 defer object.Close() 8770 8771 if v.ColumnDescription != nil { 8772 ok := object.Key("ColumnDescription") 8773 if err := awsRestjson1_serializeDocumentColumnDescription(v.ColumnDescription, ok); err != nil { 8774 return err 8775 } 8776 } 8777 8778 if len(v.ColumnGeographicRole) > 0 { 8779 ok := object.Key("ColumnGeographicRole") 8780 ok.String(string(v.ColumnGeographicRole)) 8781 } 8782 8783 return nil 8784} 8785 8786func awsRestjson1_serializeDocumentColumnTagList(v []types.ColumnTag, value smithyjson.Value) error { 8787 array := value.Array() 8788 defer array.Close() 8789 8790 for i := range v { 8791 av := array.Value() 8792 if err := awsRestjson1_serializeDocumentColumnTag(&v[i], av); err != nil { 8793 return err 8794 } 8795 } 8796 return nil 8797} 8798 8799func awsRestjson1_serializeDocumentCreateColumnsOperation(v *types.CreateColumnsOperation, value smithyjson.Value) error { 8800 object := value.Object() 8801 defer object.Close() 8802 8803 if v.Columns != nil { 8804 ok := object.Key("Columns") 8805 if err := awsRestjson1_serializeDocumentCalculatedColumnList(v.Columns, ok); err != nil { 8806 return err 8807 } 8808 } 8809 8810 return nil 8811} 8812 8813func awsRestjson1_serializeDocumentCredentialPair(v *types.CredentialPair, value smithyjson.Value) error { 8814 object := value.Object() 8815 defer object.Close() 8816 8817 if v.AlternateDataSourceParameters != nil { 8818 ok := object.Key("AlternateDataSourceParameters") 8819 if err := awsRestjson1_serializeDocumentDataSourceParametersList(v.AlternateDataSourceParameters, ok); err != nil { 8820 return err 8821 } 8822 } 8823 8824 if v.Password != nil { 8825 ok := object.Key("Password") 8826 ok.String(*v.Password) 8827 } 8828 8829 if v.Username != nil { 8830 ok := object.Key("Username") 8831 ok.String(*v.Username) 8832 } 8833 8834 return nil 8835} 8836 8837func awsRestjson1_serializeDocumentCustomSql(v *types.CustomSql, value smithyjson.Value) error { 8838 object := value.Object() 8839 defer object.Close() 8840 8841 if v.Columns != nil { 8842 ok := object.Key("Columns") 8843 if err := awsRestjson1_serializeDocumentInputColumnList(v.Columns, ok); err != nil { 8844 return err 8845 } 8846 } 8847 8848 if v.DataSourceArn != nil { 8849 ok := object.Key("DataSourceArn") 8850 ok.String(*v.DataSourceArn) 8851 } 8852 8853 if v.Name != nil { 8854 ok := object.Key("Name") 8855 ok.String(*v.Name) 8856 } 8857 8858 if v.SqlQuery != nil { 8859 ok := object.Key("SqlQuery") 8860 ok.String(*v.SqlQuery) 8861 } 8862 8863 return nil 8864} 8865 8866func awsRestjson1_serializeDocumentDashboardPublishOptions(v *types.DashboardPublishOptions, value smithyjson.Value) error { 8867 object := value.Object() 8868 defer object.Close() 8869 8870 if v.AdHocFilteringOption != nil { 8871 ok := object.Key("AdHocFilteringOption") 8872 if err := awsRestjson1_serializeDocumentAdHocFilteringOption(v.AdHocFilteringOption, ok); err != nil { 8873 return err 8874 } 8875 } 8876 8877 if v.ExportToCSVOption != nil { 8878 ok := object.Key("ExportToCSVOption") 8879 if err := awsRestjson1_serializeDocumentExportToCSVOption(v.ExportToCSVOption, ok); err != nil { 8880 return err 8881 } 8882 } 8883 8884 if v.SheetControlsOption != nil { 8885 ok := object.Key("SheetControlsOption") 8886 if err := awsRestjson1_serializeDocumentSheetControlsOption(v.SheetControlsOption, ok); err != nil { 8887 return err 8888 } 8889 } 8890 8891 return nil 8892} 8893 8894func awsRestjson1_serializeDocumentDashboardSearchFilter(v *types.DashboardSearchFilter, value smithyjson.Value) error { 8895 object := value.Object() 8896 defer object.Close() 8897 8898 if len(v.Name) > 0 { 8899 ok := object.Key("Name") 8900 ok.String(string(v.Name)) 8901 } 8902 8903 if len(v.Operator) > 0 { 8904 ok := object.Key("Operator") 8905 ok.String(string(v.Operator)) 8906 } 8907 8908 if v.Value != nil { 8909 ok := object.Key("Value") 8910 ok.String(*v.Value) 8911 } 8912 8913 return nil 8914} 8915 8916func awsRestjson1_serializeDocumentDashboardSearchFilterList(v []types.DashboardSearchFilter, value smithyjson.Value) error { 8917 array := value.Array() 8918 defer array.Close() 8919 8920 for i := range v { 8921 av := array.Value() 8922 if err := awsRestjson1_serializeDocumentDashboardSearchFilter(&v[i], av); err != nil { 8923 return err 8924 } 8925 } 8926 return nil 8927} 8928 8929func awsRestjson1_serializeDocumentDashboardSourceEntity(v *types.DashboardSourceEntity, value smithyjson.Value) error { 8930 object := value.Object() 8931 defer object.Close() 8932 8933 if v.SourceTemplate != nil { 8934 ok := object.Key("SourceTemplate") 8935 if err := awsRestjson1_serializeDocumentDashboardSourceTemplate(v.SourceTemplate, ok); err != nil { 8936 return err 8937 } 8938 } 8939 8940 return nil 8941} 8942 8943func awsRestjson1_serializeDocumentDashboardSourceTemplate(v *types.DashboardSourceTemplate, value smithyjson.Value) error { 8944 object := value.Object() 8945 defer object.Close() 8946 8947 if v.Arn != nil { 8948 ok := object.Key("Arn") 8949 ok.String(*v.Arn) 8950 } 8951 8952 if v.DataSetReferences != nil { 8953 ok := object.Key("DataSetReferences") 8954 if err := awsRestjson1_serializeDocumentDataSetReferenceList(v.DataSetReferences, ok); err != nil { 8955 return err 8956 } 8957 } 8958 8959 return nil 8960} 8961 8962func awsRestjson1_serializeDocumentDataColorPalette(v *types.DataColorPalette, value smithyjson.Value) error { 8963 object := value.Object() 8964 defer object.Close() 8965 8966 if v.Colors != nil { 8967 ok := object.Key("Colors") 8968 if err := awsRestjson1_serializeDocumentColorList(v.Colors, ok); err != nil { 8969 return err 8970 } 8971 } 8972 8973 if v.EmptyFillColor != nil { 8974 ok := object.Key("EmptyFillColor") 8975 ok.String(*v.EmptyFillColor) 8976 } 8977 8978 if v.MinMaxGradient != nil { 8979 ok := object.Key("MinMaxGradient") 8980 if err := awsRestjson1_serializeDocumentColorList(v.MinMaxGradient, ok); err != nil { 8981 return err 8982 } 8983 } 8984 8985 return nil 8986} 8987 8988func awsRestjson1_serializeDocumentDataSetReference(v *types.DataSetReference, value smithyjson.Value) error { 8989 object := value.Object() 8990 defer object.Close() 8991 8992 if v.DataSetArn != nil { 8993 ok := object.Key("DataSetArn") 8994 ok.String(*v.DataSetArn) 8995 } 8996 8997 if v.DataSetPlaceholder != nil { 8998 ok := object.Key("DataSetPlaceholder") 8999 ok.String(*v.DataSetPlaceholder) 9000 } 9001 9002 return nil 9003} 9004 9005func awsRestjson1_serializeDocumentDataSetReferenceList(v []types.DataSetReference, value smithyjson.Value) error { 9006 array := value.Array() 9007 defer array.Close() 9008 9009 for i := range v { 9010 av := array.Value() 9011 if err := awsRestjson1_serializeDocumentDataSetReference(&v[i], av); err != nil { 9012 return err 9013 } 9014 } 9015 return nil 9016} 9017 9018func awsRestjson1_serializeDocumentDataSourceCredentials(v *types.DataSourceCredentials, value smithyjson.Value) error { 9019 object := value.Object() 9020 defer object.Close() 9021 9022 if v.CopySourceArn != nil { 9023 ok := object.Key("CopySourceArn") 9024 ok.String(*v.CopySourceArn) 9025 } 9026 9027 if v.CredentialPair != nil { 9028 ok := object.Key("CredentialPair") 9029 if err := awsRestjson1_serializeDocumentCredentialPair(v.CredentialPair, ok); err != nil { 9030 return err 9031 } 9032 } 9033 9034 return nil 9035} 9036 9037func awsRestjson1_serializeDocumentDataSourceParameters(v types.DataSourceParameters, value smithyjson.Value) error { 9038 object := value.Object() 9039 defer object.Close() 9040 9041 switch uv := v.(type) { 9042 case *types.DataSourceParametersMemberAmazonElasticsearchParameters: 9043 av := object.Key("AmazonElasticsearchParameters") 9044 if err := awsRestjson1_serializeDocumentAmazonElasticsearchParameters(&uv.Value, av); err != nil { 9045 return err 9046 } 9047 9048 case *types.DataSourceParametersMemberAthenaParameters: 9049 av := object.Key("AthenaParameters") 9050 if err := awsRestjson1_serializeDocumentAthenaParameters(&uv.Value, av); err != nil { 9051 return err 9052 } 9053 9054 case *types.DataSourceParametersMemberAuroraParameters: 9055 av := object.Key("AuroraParameters") 9056 if err := awsRestjson1_serializeDocumentAuroraParameters(&uv.Value, av); err != nil { 9057 return err 9058 } 9059 9060 case *types.DataSourceParametersMemberAuroraPostgreSqlParameters: 9061 av := object.Key("AuroraPostgreSqlParameters") 9062 if err := awsRestjson1_serializeDocumentAuroraPostgreSqlParameters(&uv.Value, av); err != nil { 9063 return err 9064 } 9065 9066 case *types.DataSourceParametersMemberAwsIotAnalyticsParameters: 9067 av := object.Key("AwsIotAnalyticsParameters") 9068 if err := awsRestjson1_serializeDocumentAwsIotAnalyticsParameters(&uv.Value, av); err != nil { 9069 return err 9070 } 9071 9072 case *types.DataSourceParametersMemberJiraParameters: 9073 av := object.Key("JiraParameters") 9074 if err := awsRestjson1_serializeDocumentJiraParameters(&uv.Value, av); err != nil { 9075 return err 9076 } 9077 9078 case *types.DataSourceParametersMemberMariaDbParameters: 9079 av := object.Key("MariaDbParameters") 9080 if err := awsRestjson1_serializeDocumentMariaDbParameters(&uv.Value, av); err != nil { 9081 return err 9082 } 9083 9084 case *types.DataSourceParametersMemberMySqlParameters: 9085 av := object.Key("MySqlParameters") 9086 if err := awsRestjson1_serializeDocumentMySqlParameters(&uv.Value, av); err != nil { 9087 return err 9088 } 9089 9090 case *types.DataSourceParametersMemberOracleParameters: 9091 av := object.Key("OracleParameters") 9092 if err := awsRestjson1_serializeDocumentOracleParameters(&uv.Value, av); err != nil { 9093 return err 9094 } 9095 9096 case *types.DataSourceParametersMemberPostgreSqlParameters: 9097 av := object.Key("PostgreSqlParameters") 9098 if err := awsRestjson1_serializeDocumentPostgreSqlParameters(&uv.Value, av); err != nil { 9099 return err 9100 } 9101 9102 case *types.DataSourceParametersMemberPrestoParameters: 9103 av := object.Key("PrestoParameters") 9104 if err := awsRestjson1_serializeDocumentPrestoParameters(&uv.Value, av); err != nil { 9105 return err 9106 } 9107 9108 case *types.DataSourceParametersMemberRdsParameters: 9109 av := object.Key("RdsParameters") 9110 if err := awsRestjson1_serializeDocumentRdsParameters(&uv.Value, av); err != nil { 9111 return err 9112 } 9113 9114 case *types.DataSourceParametersMemberRedshiftParameters: 9115 av := object.Key("RedshiftParameters") 9116 if err := awsRestjson1_serializeDocumentRedshiftParameters(&uv.Value, av); err != nil { 9117 return err 9118 } 9119 9120 case *types.DataSourceParametersMemberS3Parameters: 9121 av := object.Key("S3Parameters") 9122 if err := awsRestjson1_serializeDocumentS3Parameters(&uv.Value, av); err != nil { 9123 return err 9124 } 9125 9126 case *types.DataSourceParametersMemberServiceNowParameters: 9127 av := object.Key("ServiceNowParameters") 9128 if err := awsRestjson1_serializeDocumentServiceNowParameters(&uv.Value, av); err != nil { 9129 return err 9130 } 9131 9132 case *types.DataSourceParametersMemberSnowflakeParameters: 9133 av := object.Key("SnowflakeParameters") 9134 if err := awsRestjson1_serializeDocumentSnowflakeParameters(&uv.Value, av); err != nil { 9135 return err 9136 } 9137 9138 case *types.DataSourceParametersMemberSparkParameters: 9139 av := object.Key("SparkParameters") 9140 if err := awsRestjson1_serializeDocumentSparkParameters(&uv.Value, av); err != nil { 9141 return err 9142 } 9143 9144 case *types.DataSourceParametersMemberSqlServerParameters: 9145 av := object.Key("SqlServerParameters") 9146 if err := awsRestjson1_serializeDocumentSqlServerParameters(&uv.Value, av); err != nil { 9147 return err 9148 } 9149 9150 case *types.DataSourceParametersMemberTeradataParameters: 9151 av := object.Key("TeradataParameters") 9152 if err := awsRestjson1_serializeDocumentTeradataParameters(&uv.Value, av); err != nil { 9153 return err 9154 } 9155 9156 case *types.DataSourceParametersMemberTwitterParameters: 9157 av := object.Key("TwitterParameters") 9158 if err := awsRestjson1_serializeDocumentTwitterParameters(&uv.Value, av); err != nil { 9159 return err 9160 } 9161 9162 default: 9163 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 9164 9165 } 9166 return nil 9167} 9168 9169func awsRestjson1_serializeDocumentDataSourceParametersList(v []types.DataSourceParameters, value smithyjson.Value) error { 9170 array := value.Array() 9171 defer array.Close() 9172 9173 for i := range v { 9174 av := array.Value() 9175 if vv := v[i]; vv == nil { 9176 continue 9177 } 9178 if err := awsRestjson1_serializeDocumentDataSourceParameters(v[i], av); err != nil { 9179 return err 9180 } 9181 } 9182 return nil 9183} 9184 9185func awsRestjson1_serializeDocumentDateTimeParameter(v *types.DateTimeParameter, value smithyjson.Value) error { 9186 object := value.Object() 9187 defer object.Close() 9188 9189 if v.Name != nil { 9190 ok := object.Key("Name") 9191 ok.String(*v.Name) 9192 } 9193 9194 if v.Values != nil { 9195 ok := object.Key("Values") 9196 if err := awsRestjson1_serializeDocumentTimestampList(v.Values, ok); err != nil { 9197 return err 9198 } 9199 } 9200 9201 return nil 9202} 9203 9204func awsRestjson1_serializeDocumentDateTimeParameterList(v []types.DateTimeParameter, value smithyjson.Value) error { 9205 array := value.Array() 9206 defer array.Close() 9207 9208 for i := range v { 9209 av := array.Value() 9210 if err := awsRestjson1_serializeDocumentDateTimeParameter(&v[i], av); err != nil { 9211 return err 9212 } 9213 } 9214 return nil 9215} 9216 9217func awsRestjson1_serializeDocumentDecimalParameter(v *types.DecimalParameter, value smithyjson.Value) error { 9218 object := value.Object() 9219 defer object.Close() 9220 9221 if v.Name != nil { 9222 ok := object.Key("Name") 9223 ok.String(*v.Name) 9224 } 9225 9226 if v.Values != nil { 9227 ok := object.Key("Values") 9228 if err := awsRestjson1_serializeDocumentDoubleList(v.Values, ok); err != nil { 9229 return err 9230 } 9231 } 9232 9233 return nil 9234} 9235 9236func awsRestjson1_serializeDocumentDecimalParameterList(v []types.DecimalParameter, value smithyjson.Value) error { 9237 array := value.Array() 9238 defer array.Close() 9239 9240 for i := range v { 9241 av := array.Value() 9242 if err := awsRestjson1_serializeDocumentDecimalParameter(&v[i], av); err != nil { 9243 return err 9244 } 9245 } 9246 return nil 9247} 9248 9249func awsRestjson1_serializeDocumentDoubleList(v []float64, value smithyjson.Value) error { 9250 array := value.Array() 9251 defer array.Close() 9252 9253 for i := range v { 9254 av := array.Value() 9255 av.Double(v[i]) 9256 } 9257 return nil 9258} 9259 9260func awsRestjson1_serializeDocumentExportToCSVOption(v *types.ExportToCSVOption, value smithyjson.Value) error { 9261 object := value.Object() 9262 defer object.Close() 9263 9264 if len(v.AvailabilityStatus) > 0 { 9265 ok := object.Key("AvailabilityStatus") 9266 ok.String(string(v.AvailabilityStatus)) 9267 } 9268 9269 return nil 9270} 9271 9272func awsRestjson1_serializeDocumentFieldFolder(v *types.FieldFolder, value smithyjson.Value) error { 9273 object := value.Object() 9274 defer object.Close() 9275 9276 if v.Columns != nil { 9277 ok := object.Key("columns") 9278 if err := awsRestjson1_serializeDocumentFolderColumnList(v.Columns, ok); err != nil { 9279 return err 9280 } 9281 } 9282 9283 if v.Description != nil { 9284 ok := object.Key("description") 9285 ok.String(*v.Description) 9286 } 9287 9288 return nil 9289} 9290 9291func awsRestjson1_serializeDocumentFieldFolderMap(v map[string]types.FieldFolder, value smithyjson.Value) error { 9292 object := value.Object() 9293 defer object.Close() 9294 9295 for key := range v { 9296 om := object.Key(key) 9297 mapVar := v[key] 9298 if err := awsRestjson1_serializeDocumentFieldFolder(&mapVar, om); err != nil { 9299 return err 9300 } 9301 } 9302 return nil 9303} 9304 9305func awsRestjson1_serializeDocumentFilterOperation(v *types.FilterOperation, value smithyjson.Value) error { 9306 object := value.Object() 9307 defer object.Close() 9308 9309 if v.ConditionExpression != nil { 9310 ok := object.Key("ConditionExpression") 9311 ok.String(*v.ConditionExpression) 9312 } 9313 9314 return nil 9315} 9316 9317func awsRestjson1_serializeDocumentFolderColumnList(v []string, value smithyjson.Value) error { 9318 array := value.Array() 9319 defer array.Close() 9320 9321 for i := range v { 9322 av := array.Value() 9323 av.String(v[i]) 9324 } 9325 return nil 9326} 9327 9328func awsRestjson1_serializeDocumentGeoSpatialColumnGroup(v *types.GeoSpatialColumnGroup, value smithyjson.Value) error { 9329 object := value.Object() 9330 defer object.Close() 9331 9332 if v.Columns != nil { 9333 ok := object.Key("Columns") 9334 if err := awsRestjson1_serializeDocumentColumnList(v.Columns, ok); err != nil { 9335 return err 9336 } 9337 } 9338 9339 if len(v.CountryCode) > 0 { 9340 ok := object.Key("CountryCode") 9341 ok.String(string(v.CountryCode)) 9342 } 9343 9344 if v.Name != nil { 9345 ok := object.Key("Name") 9346 ok.String(*v.Name) 9347 } 9348 9349 return nil 9350} 9351 9352func awsRestjson1_serializeDocumentGutterStyle(v *types.GutterStyle, value smithyjson.Value) error { 9353 object := value.Object() 9354 defer object.Close() 9355 9356 if v.Show { 9357 ok := object.Key("Show") 9358 ok.Boolean(v.Show) 9359 } 9360 9361 return nil 9362} 9363 9364func awsRestjson1_serializeDocumentIdentityMap(v map[string][]string, value smithyjson.Value) error { 9365 object := value.Object() 9366 defer object.Close() 9367 9368 for key := range v { 9369 om := object.Key(key) 9370 if vv := v[key]; vv == nil { 9371 continue 9372 } 9373 if err := awsRestjson1_serializeDocumentIdentityNameList(v[key], om); err != nil { 9374 return err 9375 } 9376 } 9377 return nil 9378} 9379 9380func awsRestjson1_serializeDocumentIdentityNameList(v []string, value smithyjson.Value) error { 9381 array := value.Array() 9382 defer array.Close() 9383 9384 for i := range v { 9385 av := array.Value() 9386 av.String(v[i]) 9387 } 9388 return nil 9389} 9390 9391func awsRestjson1_serializeDocumentInputColumn(v *types.InputColumn, value smithyjson.Value) error { 9392 object := value.Object() 9393 defer object.Close() 9394 9395 if v.Name != nil { 9396 ok := object.Key("Name") 9397 ok.String(*v.Name) 9398 } 9399 9400 if len(v.Type) > 0 { 9401 ok := object.Key("Type") 9402 ok.String(string(v.Type)) 9403 } 9404 9405 return nil 9406} 9407 9408func awsRestjson1_serializeDocumentInputColumnList(v []types.InputColumn, value smithyjson.Value) error { 9409 array := value.Array() 9410 defer array.Close() 9411 9412 for i := range v { 9413 av := array.Value() 9414 if err := awsRestjson1_serializeDocumentInputColumn(&v[i], av); err != nil { 9415 return err 9416 } 9417 } 9418 return nil 9419} 9420 9421func awsRestjson1_serializeDocumentIntegerParameter(v *types.IntegerParameter, value smithyjson.Value) error { 9422 object := value.Object() 9423 defer object.Close() 9424 9425 if v.Name != nil { 9426 ok := object.Key("Name") 9427 ok.String(*v.Name) 9428 } 9429 9430 if v.Values != nil { 9431 ok := object.Key("Values") 9432 if err := awsRestjson1_serializeDocumentLongList(v.Values, ok); err != nil { 9433 return err 9434 } 9435 } 9436 9437 return nil 9438} 9439 9440func awsRestjson1_serializeDocumentIntegerParameterList(v []types.IntegerParameter, value smithyjson.Value) error { 9441 array := value.Array() 9442 defer array.Close() 9443 9444 for i := range v { 9445 av := array.Value() 9446 if err := awsRestjson1_serializeDocumentIntegerParameter(&v[i], av); err != nil { 9447 return err 9448 } 9449 } 9450 return nil 9451} 9452 9453func awsRestjson1_serializeDocumentJiraParameters(v *types.JiraParameters, value smithyjson.Value) error { 9454 object := value.Object() 9455 defer object.Close() 9456 9457 if v.SiteBaseUrl != nil { 9458 ok := object.Key("SiteBaseUrl") 9459 ok.String(*v.SiteBaseUrl) 9460 } 9461 9462 return nil 9463} 9464 9465func awsRestjson1_serializeDocumentJoinInstruction(v *types.JoinInstruction, value smithyjson.Value) error { 9466 object := value.Object() 9467 defer object.Close() 9468 9469 if v.LeftJoinKeyProperties != nil { 9470 ok := object.Key("LeftJoinKeyProperties") 9471 if err := awsRestjson1_serializeDocumentJoinKeyProperties(v.LeftJoinKeyProperties, ok); err != nil { 9472 return err 9473 } 9474 } 9475 9476 if v.LeftOperand != nil { 9477 ok := object.Key("LeftOperand") 9478 ok.String(*v.LeftOperand) 9479 } 9480 9481 if v.OnClause != nil { 9482 ok := object.Key("OnClause") 9483 ok.String(*v.OnClause) 9484 } 9485 9486 if v.RightJoinKeyProperties != nil { 9487 ok := object.Key("RightJoinKeyProperties") 9488 if err := awsRestjson1_serializeDocumentJoinKeyProperties(v.RightJoinKeyProperties, ok); err != nil { 9489 return err 9490 } 9491 } 9492 9493 if v.RightOperand != nil { 9494 ok := object.Key("RightOperand") 9495 ok.String(*v.RightOperand) 9496 } 9497 9498 if len(v.Type) > 0 { 9499 ok := object.Key("Type") 9500 ok.String(string(v.Type)) 9501 } 9502 9503 return nil 9504} 9505 9506func awsRestjson1_serializeDocumentJoinKeyProperties(v *types.JoinKeyProperties, value smithyjson.Value) error { 9507 object := value.Object() 9508 defer object.Close() 9509 9510 if v.UniqueKey { 9511 ok := object.Key("UniqueKey") 9512 ok.Boolean(v.UniqueKey) 9513 } 9514 9515 return nil 9516} 9517 9518func awsRestjson1_serializeDocumentLogicalTable(v *types.LogicalTable, value smithyjson.Value) error { 9519 object := value.Object() 9520 defer object.Close() 9521 9522 if v.Alias != nil { 9523 ok := object.Key("Alias") 9524 ok.String(*v.Alias) 9525 } 9526 9527 if v.DataTransforms != nil { 9528 ok := object.Key("DataTransforms") 9529 if err := awsRestjson1_serializeDocumentTransformOperationList(v.DataTransforms, ok); err != nil { 9530 return err 9531 } 9532 } 9533 9534 if v.Source != nil { 9535 ok := object.Key("Source") 9536 if err := awsRestjson1_serializeDocumentLogicalTableSource(v.Source, ok); err != nil { 9537 return err 9538 } 9539 } 9540 9541 return nil 9542} 9543 9544func awsRestjson1_serializeDocumentLogicalTableMap(v map[string]types.LogicalTable, value smithyjson.Value) error { 9545 object := value.Object() 9546 defer object.Close() 9547 9548 for key := range v { 9549 om := object.Key(key) 9550 mapVar := v[key] 9551 if err := awsRestjson1_serializeDocumentLogicalTable(&mapVar, om); err != nil { 9552 return err 9553 } 9554 } 9555 return nil 9556} 9557 9558func awsRestjson1_serializeDocumentLogicalTableSource(v *types.LogicalTableSource, value smithyjson.Value) error { 9559 object := value.Object() 9560 defer object.Close() 9561 9562 if v.JoinInstruction != nil { 9563 ok := object.Key("JoinInstruction") 9564 if err := awsRestjson1_serializeDocumentJoinInstruction(v.JoinInstruction, ok); err != nil { 9565 return err 9566 } 9567 } 9568 9569 if v.PhysicalTableId != nil { 9570 ok := object.Key("PhysicalTableId") 9571 ok.String(*v.PhysicalTableId) 9572 } 9573 9574 return nil 9575} 9576 9577func awsRestjson1_serializeDocumentLongList(v []int64, value smithyjson.Value) error { 9578 array := value.Array() 9579 defer array.Close() 9580 9581 for i := range v { 9582 av := array.Value() 9583 av.Long(v[i]) 9584 } 9585 return nil 9586} 9587 9588func awsRestjson1_serializeDocumentManifestFileLocation(v *types.ManifestFileLocation, value smithyjson.Value) error { 9589 object := value.Object() 9590 defer object.Close() 9591 9592 if v.Bucket != nil { 9593 ok := object.Key("Bucket") 9594 ok.String(*v.Bucket) 9595 } 9596 9597 if v.Key != nil { 9598 ok := object.Key("Key") 9599 ok.String(*v.Key) 9600 } 9601 9602 return nil 9603} 9604 9605func awsRestjson1_serializeDocumentMarginStyle(v *types.MarginStyle, value smithyjson.Value) error { 9606 object := value.Object() 9607 defer object.Close() 9608 9609 if v.Show { 9610 ok := object.Key("Show") 9611 ok.Boolean(v.Show) 9612 } 9613 9614 return nil 9615} 9616 9617func awsRestjson1_serializeDocumentMariaDbParameters(v *types.MariaDbParameters, value smithyjson.Value) error { 9618 object := value.Object() 9619 defer object.Close() 9620 9621 if v.Database != nil { 9622 ok := object.Key("Database") 9623 ok.String(*v.Database) 9624 } 9625 9626 if v.Host != nil { 9627 ok := object.Key("Host") 9628 ok.String(*v.Host) 9629 } 9630 9631 { 9632 ok := object.Key("Port") 9633 ok.Integer(v.Port) 9634 } 9635 9636 return nil 9637} 9638 9639func awsRestjson1_serializeDocumentMySqlParameters(v *types.MySqlParameters, value smithyjson.Value) error { 9640 object := value.Object() 9641 defer object.Close() 9642 9643 if v.Database != nil { 9644 ok := object.Key("Database") 9645 ok.String(*v.Database) 9646 } 9647 9648 if v.Host != nil { 9649 ok := object.Key("Host") 9650 ok.String(*v.Host) 9651 } 9652 9653 { 9654 ok := object.Key("Port") 9655 ok.Integer(v.Port) 9656 } 9657 9658 return nil 9659} 9660 9661func awsRestjson1_serializeDocumentOracleParameters(v *types.OracleParameters, value smithyjson.Value) error { 9662 object := value.Object() 9663 defer object.Close() 9664 9665 if v.Database != nil { 9666 ok := object.Key("Database") 9667 ok.String(*v.Database) 9668 } 9669 9670 if v.Host != nil { 9671 ok := object.Key("Host") 9672 ok.String(*v.Host) 9673 } 9674 9675 { 9676 ok := object.Key("Port") 9677 ok.Integer(v.Port) 9678 } 9679 9680 return nil 9681} 9682 9683func awsRestjson1_serializeDocumentParameters(v *types.Parameters, value smithyjson.Value) error { 9684 object := value.Object() 9685 defer object.Close() 9686 9687 if v.DateTimeParameters != nil { 9688 ok := object.Key("DateTimeParameters") 9689 if err := awsRestjson1_serializeDocumentDateTimeParameterList(v.DateTimeParameters, ok); err != nil { 9690 return err 9691 } 9692 } 9693 9694 if v.DecimalParameters != nil { 9695 ok := object.Key("DecimalParameters") 9696 if err := awsRestjson1_serializeDocumentDecimalParameterList(v.DecimalParameters, ok); err != nil { 9697 return err 9698 } 9699 } 9700 9701 if v.IntegerParameters != nil { 9702 ok := object.Key("IntegerParameters") 9703 if err := awsRestjson1_serializeDocumentIntegerParameterList(v.IntegerParameters, ok); err != nil { 9704 return err 9705 } 9706 } 9707 9708 if v.StringParameters != nil { 9709 ok := object.Key("StringParameters") 9710 if err := awsRestjson1_serializeDocumentStringParameterList(v.StringParameters, ok); err != nil { 9711 return err 9712 } 9713 } 9714 9715 return nil 9716} 9717 9718func awsRestjson1_serializeDocumentPhysicalTable(v types.PhysicalTable, value smithyjson.Value) error { 9719 object := value.Object() 9720 defer object.Close() 9721 9722 switch uv := v.(type) { 9723 case *types.PhysicalTableMemberCustomSql: 9724 av := object.Key("CustomSql") 9725 if err := awsRestjson1_serializeDocumentCustomSql(&uv.Value, av); err != nil { 9726 return err 9727 } 9728 9729 case *types.PhysicalTableMemberRelationalTable: 9730 av := object.Key("RelationalTable") 9731 if err := awsRestjson1_serializeDocumentRelationalTable(&uv.Value, av); err != nil { 9732 return err 9733 } 9734 9735 case *types.PhysicalTableMemberS3Source: 9736 av := object.Key("S3Source") 9737 if err := awsRestjson1_serializeDocumentS3Source(&uv.Value, av); err != nil { 9738 return err 9739 } 9740 9741 default: 9742 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 9743 9744 } 9745 return nil 9746} 9747 9748func awsRestjson1_serializeDocumentPhysicalTableMap(v map[string]types.PhysicalTable, value smithyjson.Value) error { 9749 object := value.Object() 9750 defer object.Close() 9751 9752 for key := range v { 9753 om := object.Key(key) 9754 if vv := v[key]; vv == nil { 9755 continue 9756 } 9757 if err := awsRestjson1_serializeDocumentPhysicalTable(v[key], om); err != nil { 9758 return err 9759 } 9760 } 9761 return nil 9762} 9763 9764func awsRestjson1_serializeDocumentPostgreSqlParameters(v *types.PostgreSqlParameters, value smithyjson.Value) error { 9765 object := value.Object() 9766 defer object.Close() 9767 9768 if v.Database != nil { 9769 ok := object.Key("Database") 9770 ok.String(*v.Database) 9771 } 9772 9773 if v.Host != nil { 9774 ok := object.Key("Host") 9775 ok.String(*v.Host) 9776 } 9777 9778 { 9779 ok := object.Key("Port") 9780 ok.Integer(v.Port) 9781 } 9782 9783 return nil 9784} 9785 9786func awsRestjson1_serializeDocumentPrestoParameters(v *types.PrestoParameters, value smithyjson.Value) error { 9787 object := value.Object() 9788 defer object.Close() 9789 9790 if v.Catalog != nil { 9791 ok := object.Key("Catalog") 9792 ok.String(*v.Catalog) 9793 } 9794 9795 if v.Host != nil { 9796 ok := object.Key("Host") 9797 ok.String(*v.Host) 9798 } 9799 9800 { 9801 ok := object.Key("Port") 9802 ok.Integer(v.Port) 9803 } 9804 9805 return nil 9806} 9807 9808func awsRestjson1_serializeDocumentPrincipalList(v []string, value smithyjson.Value) error { 9809 array := value.Array() 9810 defer array.Close() 9811 9812 for i := range v { 9813 av := array.Value() 9814 av.String(v[i]) 9815 } 9816 return nil 9817} 9818 9819func awsRestjson1_serializeDocumentProjectedColumnList(v []string, value smithyjson.Value) error { 9820 array := value.Array() 9821 defer array.Close() 9822 9823 for i := range v { 9824 av := array.Value() 9825 av.String(v[i]) 9826 } 9827 return nil 9828} 9829 9830func awsRestjson1_serializeDocumentProjectOperation(v *types.ProjectOperation, value smithyjson.Value) error { 9831 object := value.Object() 9832 defer object.Close() 9833 9834 if v.ProjectedColumns != nil { 9835 ok := object.Key("ProjectedColumns") 9836 if err := awsRestjson1_serializeDocumentProjectedColumnList(v.ProjectedColumns, ok); err != nil { 9837 return err 9838 } 9839 } 9840 9841 return nil 9842} 9843 9844func awsRestjson1_serializeDocumentRdsParameters(v *types.RdsParameters, value smithyjson.Value) error { 9845 object := value.Object() 9846 defer object.Close() 9847 9848 if v.Database != nil { 9849 ok := object.Key("Database") 9850 ok.String(*v.Database) 9851 } 9852 9853 if v.InstanceId != nil { 9854 ok := object.Key("InstanceId") 9855 ok.String(*v.InstanceId) 9856 } 9857 9858 return nil 9859} 9860 9861func awsRestjson1_serializeDocumentRedshiftParameters(v *types.RedshiftParameters, value smithyjson.Value) error { 9862 object := value.Object() 9863 defer object.Close() 9864 9865 if v.ClusterId != nil { 9866 ok := object.Key("ClusterId") 9867 ok.String(*v.ClusterId) 9868 } 9869 9870 if v.Database != nil { 9871 ok := object.Key("Database") 9872 ok.String(*v.Database) 9873 } 9874 9875 if v.Host != nil { 9876 ok := object.Key("Host") 9877 ok.String(*v.Host) 9878 } 9879 9880 if v.Port != 0 { 9881 ok := object.Key("Port") 9882 ok.Integer(v.Port) 9883 } 9884 9885 return nil 9886} 9887 9888func awsRestjson1_serializeDocumentRelationalTable(v *types.RelationalTable, value smithyjson.Value) error { 9889 object := value.Object() 9890 defer object.Close() 9891 9892 if v.Catalog != nil { 9893 ok := object.Key("Catalog") 9894 ok.String(*v.Catalog) 9895 } 9896 9897 if v.DataSourceArn != nil { 9898 ok := object.Key("DataSourceArn") 9899 ok.String(*v.DataSourceArn) 9900 } 9901 9902 if v.InputColumns != nil { 9903 ok := object.Key("InputColumns") 9904 if err := awsRestjson1_serializeDocumentInputColumnList(v.InputColumns, ok); err != nil { 9905 return err 9906 } 9907 } 9908 9909 if v.Name != nil { 9910 ok := object.Key("Name") 9911 ok.String(*v.Name) 9912 } 9913 9914 if v.Schema != nil { 9915 ok := object.Key("Schema") 9916 ok.String(*v.Schema) 9917 } 9918 9919 return nil 9920} 9921 9922func awsRestjson1_serializeDocumentRenameColumnOperation(v *types.RenameColumnOperation, value smithyjson.Value) error { 9923 object := value.Object() 9924 defer object.Close() 9925 9926 if v.ColumnName != nil { 9927 ok := object.Key("ColumnName") 9928 ok.String(*v.ColumnName) 9929 } 9930 9931 if v.NewColumnName != nil { 9932 ok := object.Key("NewColumnName") 9933 ok.String(*v.NewColumnName) 9934 } 9935 9936 return nil 9937} 9938 9939func awsRestjson1_serializeDocumentResourcePermission(v *types.ResourcePermission, value smithyjson.Value) error { 9940 object := value.Object() 9941 defer object.Close() 9942 9943 if v.Actions != nil { 9944 ok := object.Key("Actions") 9945 if err := awsRestjson1_serializeDocumentActionList(v.Actions, ok); err != nil { 9946 return err 9947 } 9948 } 9949 9950 if v.Principal != nil { 9951 ok := object.Key("Principal") 9952 ok.String(*v.Principal) 9953 } 9954 9955 return nil 9956} 9957 9958func awsRestjson1_serializeDocumentResourcePermissionList(v []types.ResourcePermission, value smithyjson.Value) error { 9959 array := value.Array() 9960 defer array.Close() 9961 9962 for i := range v { 9963 av := array.Value() 9964 if err := awsRestjson1_serializeDocumentResourcePermission(&v[i], av); err != nil { 9965 return err 9966 } 9967 } 9968 return nil 9969} 9970 9971func awsRestjson1_serializeDocumentRowLevelPermissionDataSet(v *types.RowLevelPermissionDataSet, value smithyjson.Value) error { 9972 object := value.Object() 9973 defer object.Close() 9974 9975 if v.Arn != nil { 9976 ok := object.Key("Arn") 9977 ok.String(*v.Arn) 9978 } 9979 9980 if v.Namespace != nil { 9981 ok := object.Key("Namespace") 9982 ok.String(*v.Namespace) 9983 } 9984 9985 if len(v.PermissionPolicy) > 0 { 9986 ok := object.Key("PermissionPolicy") 9987 ok.String(string(v.PermissionPolicy)) 9988 } 9989 9990 return nil 9991} 9992 9993func awsRestjson1_serializeDocumentS3Parameters(v *types.S3Parameters, value smithyjson.Value) error { 9994 object := value.Object() 9995 defer object.Close() 9996 9997 if v.ManifestFileLocation != nil { 9998 ok := object.Key("ManifestFileLocation") 9999 if err := awsRestjson1_serializeDocumentManifestFileLocation(v.ManifestFileLocation, ok); err != nil { 10000 return err 10001 } 10002 } 10003 10004 return nil 10005} 10006 10007func awsRestjson1_serializeDocumentS3Source(v *types.S3Source, value smithyjson.Value) error { 10008 object := value.Object() 10009 defer object.Close() 10010 10011 if v.DataSourceArn != nil { 10012 ok := object.Key("DataSourceArn") 10013 ok.String(*v.DataSourceArn) 10014 } 10015 10016 if v.InputColumns != nil { 10017 ok := object.Key("InputColumns") 10018 if err := awsRestjson1_serializeDocumentInputColumnList(v.InputColumns, ok); err != nil { 10019 return err 10020 } 10021 } 10022 10023 if v.UploadSettings != nil { 10024 ok := object.Key("UploadSettings") 10025 if err := awsRestjson1_serializeDocumentUploadSettings(v.UploadSettings, ok); err != nil { 10026 return err 10027 } 10028 } 10029 10030 return nil 10031} 10032 10033func awsRestjson1_serializeDocumentServiceNowParameters(v *types.ServiceNowParameters, value smithyjson.Value) error { 10034 object := value.Object() 10035 defer object.Close() 10036 10037 if v.SiteBaseUrl != nil { 10038 ok := object.Key("SiteBaseUrl") 10039 ok.String(*v.SiteBaseUrl) 10040 } 10041 10042 return nil 10043} 10044 10045func awsRestjson1_serializeDocumentSheetControlsOption(v *types.SheetControlsOption, value smithyjson.Value) error { 10046 object := value.Object() 10047 defer object.Close() 10048 10049 if len(v.VisibilityState) > 0 { 10050 ok := object.Key("VisibilityState") 10051 ok.String(string(v.VisibilityState)) 10052 } 10053 10054 return nil 10055} 10056 10057func awsRestjson1_serializeDocumentSheetStyle(v *types.SheetStyle, value smithyjson.Value) error { 10058 object := value.Object() 10059 defer object.Close() 10060 10061 if v.Tile != nil { 10062 ok := object.Key("Tile") 10063 if err := awsRestjson1_serializeDocumentTileStyle(v.Tile, ok); err != nil { 10064 return err 10065 } 10066 } 10067 10068 if v.TileLayout != nil { 10069 ok := object.Key("TileLayout") 10070 if err := awsRestjson1_serializeDocumentTileLayoutStyle(v.TileLayout, ok); err != nil { 10071 return err 10072 } 10073 } 10074 10075 return nil 10076} 10077 10078func awsRestjson1_serializeDocumentSnowflakeParameters(v *types.SnowflakeParameters, value smithyjson.Value) error { 10079 object := value.Object() 10080 defer object.Close() 10081 10082 if v.Database != nil { 10083 ok := object.Key("Database") 10084 ok.String(*v.Database) 10085 } 10086 10087 if v.Host != nil { 10088 ok := object.Key("Host") 10089 ok.String(*v.Host) 10090 } 10091 10092 if v.Warehouse != nil { 10093 ok := object.Key("Warehouse") 10094 ok.String(*v.Warehouse) 10095 } 10096 10097 return nil 10098} 10099 10100func awsRestjson1_serializeDocumentSparkParameters(v *types.SparkParameters, value smithyjson.Value) error { 10101 object := value.Object() 10102 defer object.Close() 10103 10104 if v.Host != nil { 10105 ok := object.Key("Host") 10106 ok.String(*v.Host) 10107 } 10108 10109 { 10110 ok := object.Key("Port") 10111 ok.Integer(v.Port) 10112 } 10113 10114 return nil 10115} 10116 10117func awsRestjson1_serializeDocumentSqlServerParameters(v *types.SqlServerParameters, value smithyjson.Value) error { 10118 object := value.Object() 10119 defer object.Close() 10120 10121 if v.Database != nil { 10122 ok := object.Key("Database") 10123 ok.String(*v.Database) 10124 } 10125 10126 if v.Host != nil { 10127 ok := object.Key("Host") 10128 ok.String(*v.Host) 10129 } 10130 10131 { 10132 ok := object.Key("Port") 10133 ok.Integer(v.Port) 10134 } 10135 10136 return nil 10137} 10138 10139func awsRestjson1_serializeDocumentSslProperties(v *types.SslProperties, value smithyjson.Value) error { 10140 object := value.Object() 10141 defer object.Close() 10142 10143 if v.DisableSsl { 10144 ok := object.Key("DisableSsl") 10145 ok.Boolean(v.DisableSsl) 10146 } 10147 10148 return nil 10149} 10150 10151func awsRestjson1_serializeDocumentStringList(v []string, value smithyjson.Value) error { 10152 array := value.Array() 10153 defer array.Close() 10154 10155 for i := range v { 10156 av := array.Value() 10157 av.String(v[i]) 10158 } 10159 return nil 10160} 10161 10162func awsRestjson1_serializeDocumentStringParameter(v *types.StringParameter, value smithyjson.Value) error { 10163 object := value.Object() 10164 defer object.Close() 10165 10166 if v.Name != nil { 10167 ok := object.Key("Name") 10168 ok.String(*v.Name) 10169 } 10170 10171 if v.Values != nil { 10172 ok := object.Key("Values") 10173 if err := awsRestjson1_serializeDocumentStringList(v.Values, ok); err != nil { 10174 return err 10175 } 10176 } 10177 10178 return nil 10179} 10180 10181func awsRestjson1_serializeDocumentStringParameterList(v []types.StringParameter, value smithyjson.Value) error { 10182 array := value.Array() 10183 defer array.Close() 10184 10185 for i := range v { 10186 av := array.Value() 10187 if err := awsRestjson1_serializeDocumentStringParameter(&v[i], av); err != nil { 10188 return err 10189 } 10190 } 10191 return nil 10192} 10193 10194func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 10195 object := value.Object() 10196 defer object.Close() 10197 10198 if v.Key != nil { 10199 ok := object.Key("Key") 10200 ok.String(*v.Key) 10201 } 10202 10203 if v.Value != nil { 10204 ok := object.Key("Value") 10205 ok.String(*v.Value) 10206 } 10207 10208 return nil 10209} 10210 10211func awsRestjson1_serializeDocumentTagColumnOperation(v *types.TagColumnOperation, value smithyjson.Value) error { 10212 object := value.Object() 10213 defer object.Close() 10214 10215 if v.ColumnName != nil { 10216 ok := object.Key("ColumnName") 10217 ok.String(*v.ColumnName) 10218 } 10219 10220 if v.Tags != nil { 10221 ok := object.Key("Tags") 10222 if err := awsRestjson1_serializeDocumentColumnTagList(v.Tags, ok); err != nil { 10223 return err 10224 } 10225 } 10226 10227 return nil 10228} 10229 10230func awsRestjson1_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error { 10231 array := value.Array() 10232 defer array.Close() 10233 10234 for i := range v { 10235 av := array.Value() 10236 if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil { 10237 return err 10238 } 10239 } 10240 return nil 10241} 10242 10243func awsRestjson1_serializeDocumentTemplateSourceAnalysis(v *types.TemplateSourceAnalysis, value smithyjson.Value) error { 10244 object := value.Object() 10245 defer object.Close() 10246 10247 if v.Arn != nil { 10248 ok := object.Key("Arn") 10249 ok.String(*v.Arn) 10250 } 10251 10252 if v.DataSetReferences != nil { 10253 ok := object.Key("DataSetReferences") 10254 if err := awsRestjson1_serializeDocumentDataSetReferenceList(v.DataSetReferences, ok); err != nil { 10255 return err 10256 } 10257 } 10258 10259 return nil 10260} 10261 10262func awsRestjson1_serializeDocumentTemplateSourceEntity(v *types.TemplateSourceEntity, value smithyjson.Value) error { 10263 object := value.Object() 10264 defer object.Close() 10265 10266 if v.SourceAnalysis != nil { 10267 ok := object.Key("SourceAnalysis") 10268 if err := awsRestjson1_serializeDocumentTemplateSourceAnalysis(v.SourceAnalysis, ok); err != nil { 10269 return err 10270 } 10271 } 10272 10273 if v.SourceTemplate != nil { 10274 ok := object.Key("SourceTemplate") 10275 if err := awsRestjson1_serializeDocumentTemplateSourceTemplate(v.SourceTemplate, ok); err != nil { 10276 return err 10277 } 10278 } 10279 10280 return nil 10281} 10282 10283func awsRestjson1_serializeDocumentTemplateSourceTemplate(v *types.TemplateSourceTemplate, value smithyjson.Value) error { 10284 object := value.Object() 10285 defer object.Close() 10286 10287 if v.Arn != nil { 10288 ok := object.Key("Arn") 10289 ok.String(*v.Arn) 10290 } 10291 10292 return nil 10293} 10294 10295func awsRestjson1_serializeDocumentTeradataParameters(v *types.TeradataParameters, value smithyjson.Value) error { 10296 object := value.Object() 10297 defer object.Close() 10298 10299 if v.Database != nil { 10300 ok := object.Key("Database") 10301 ok.String(*v.Database) 10302 } 10303 10304 if v.Host != nil { 10305 ok := object.Key("Host") 10306 ok.String(*v.Host) 10307 } 10308 10309 { 10310 ok := object.Key("Port") 10311 ok.Integer(v.Port) 10312 } 10313 10314 return nil 10315} 10316 10317func awsRestjson1_serializeDocumentThemeConfiguration(v *types.ThemeConfiguration, value smithyjson.Value) error { 10318 object := value.Object() 10319 defer object.Close() 10320 10321 if v.DataColorPalette != nil { 10322 ok := object.Key("DataColorPalette") 10323 if err := awsRestjson1_serializeDocumentDataColorPalette(v.DataColorPalette, ok); err != nil { 10324 return err 10325 } 10326 } 10327 10328 if v.Sheet != nil { 10329 ok := object.Key("Sheet") 10330 if err := awsRestjson1_serializeDocumentSheetStyle(v.Sheet, ok); err != nil { 10331 return err 10332 } 10333 } 10334 10335 if v.UIColorPalette != nil { 10336 ok := object.Key("UIColorPalette") 10337 if err := awsRestjson1_serializeDocumentUIColorPalette(v.UIColorPalette, ok); err != nil { 10338 return err 10339 } 10340 } 10341 10342 return nil 10343} 10344 10345func awsRestjson1_serializeDocumentTileLayoutStyle(v *types.TileLayoutStyle, value smithyjson.Value) error { 10346 object := value.Object() 10347 defer object.Close() 10348 10349 if v.Gutter != nil { 10350 ok := object.Key("Gutter") 10351 if err := awsRestjson1_serializeDocumentGutterStyle(v.Gutter, ok); err != nil { 10352 return err 10353 } 10354 } 10355 10356 if v.Margin != nil { 10357 ok := object.Key("Margin") 10358 if err := awsRestjson1_serializeDocumentMarginStyle(v.Margin, ok); err != nil { 10359 return err 10360 } 10361 } 10362 10363 return nil 10364} 10365 10366func awsRestjson1_serializeDocumentTileStyle(v *types.TileStyle, value smithyjson.Value) error { 10367 object := value.Object() 10368 defer object.Close() 10369 10370 if v.Border != nil { 10371 ok := object.Key("Border") 10372 if err := awsRestjson1_serializeDocumentBorderStyle(v.Border, ok); err != nil { 10373 return err 10374 } 10375 } 10376 10377 return nil 10378} 10379 10380func awsRestjson1_serializeDocumentTimestampList(v []time.Time, value smithyjson.Value) error { 10381 array := value.Array() 10382 defer array.Close() 10383 10384 for i := range v { 10385 av := array.Value() 10386 av.Double(smithytime.FormatEpochSeconds(v[i])) 10387 } 10388 return nil 10389} 10390 10391func awsRestjson1_serializeDocumentTransformOperation(v types.TransformOperation, value smithyjson.Value) error { 10392 object := value.Object() 10393 defer object.Close() 10394 10395 switch uv := v.(type) { 10396 case *types.TransformOperationMemberCastColumnTypeOperation: 10397 av := object.Key("CastColumnTypeOperation") 10398 if err := awsRestjson1_serializeDocumentCastColumnTypeOperation(&uv.Value, av); err != nil { 10399 return err 10400 } 10401 10402 case *types.TransformOperationMemberCreateColumnsOperation: 10403 av := object.Key("CreateColumnsOperation") 10404 if err := awsRestjson1_serializeDocumentCreateColumnsOperation(&uv.Value, av); err != nil { 10405 return err 10406 } 10407 10408 case *types.TransformOperationMemberFilterOperation: 10409 av := object.Key("FilterOperation") 10410 if err := awsRestjson1_serializeDocumentFilterOperation(&uv.Value, av); err != nil { 10411 return err 10412 } 10413 10414 case *types.TransformOperationMemberProjectOperation: 10415 av := object.Key("ProjectOperation") 10416 if err := awsRestjson1_serializeDocumentProjectOperation(&uv.Value, av); err != nil { 10417 return err 10418 } 10419 10420 case *types.TransformOperationMemberRenameColumnOperation: 10421 av := object.Key("RenameColumnOperation") 10422 if err := awsRestjson1_serializeDocumentRenameColumnOperation(&uv.Value, av); err != nil { 10423 return err 10424 } 10425 10426 case *types.TransformOperationMemberTagColumnOperation: 10427 av := object.Key("TagColumnOperation") 10428 if err := awsRestjson1_serializeDocumentTagColumnOperation(&uv.Value, av); err != nil { 10429 return err 10430 } 10431 10432 default: 10433 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 10434 10435 } 10436 return nil 10437} 10438 10439func awsRestjson1_serializeDocumentTransformOperationList(v []types.TransformOperation, value smithyjson.Value) error { 10440 array := value.Array() 10441 defer array.Close() 10442 10443 for i := range v { 10444 av := array.Value() 10445 if vv := v[i]; vv == nil { 10446 continue 10447 } 10448 if err := awsRestjson1_serializeDocumentTransformOperation(v[i], av); err != nil { 10449 return err 10450 } 10451 } 10452 return nil 10453} 10454 10455func awsRestjson1_serializeDocumentTwitterParameters(v *types.TwitterParameters, value smithyjson.Value) error { 10456 object := value.Object() 10457 defer object.Close() 10458 10459 { 10460 ok := object.Key("MaxRows") 10461 ok.Integer(v.MaxRows) 10462 } 10463 10464 if v.Query != nil { 10465 ok := object.Key("Query") 10466 ok.String(*v.Query) 10467 } 10468 10469 return nil 10470} 10471 10472func awsRestjson1_serializeDocumentUIColorPalette(v *types.UIColorPalette, value smithyjson.Value) error { 10473 object := value.Object() 10474 defer object.Close() 10475 10476 if v.Accent != nil { 10477 ok := object.Key("Accent") 10478 ok.String(*v.Accent) 10479 } 10480 10481 if v.AccentForeground != nil { 10482 ok := object.Key("AccentForeground") 10483 ok.String(*v.AccentForeground) 10484 } 10485 10486 if v.Danger != nil { 10487 ok := object.Key("Danger") 10488 ok.String(*v.Danger) 10489 } 10490 10491 if v.DangerForeground != nil { 10492 ok := object.Key("DangerForeground") 10493 ok.String(*v.DangerForeground) 10494 } 10495 10496 if v.Dimension != nil { 10497 ok := object.Key("Dimension") 10498 ok.String(*v.Dimension) 10499 } 10500 10501 if v.DimensionForeground != nil { 10502 ok := object.Key("DimensionForeground") 10503 ok.String(*v.DimensionForeground) 10504 } 10505 10506 if v.Measure != nil { 10507 ok := object.Key("Measure") 10508 ok.String(*v.Measure) 10509 } 10510 10511 if v.MeasureForeground != nil { 10512 ok := object.Key("MeasureForeground") 10513 ok.String(*v.MeasureForeground) 10514 } 10515 10516 if v.PrimaryBackground != nil { 10517 ok := object.Key("PrimaryBackground") 10518 ok.String(*v.PrimaryBackground) 10519 } 10520 10521 if v.PrimaryForeground != nil { 10522 ok := object.Key("PrimaryForeground") 10523 ok.String(*v.PrimaryForeground) 10524 } 10525 10526 if v.SecondaryBackground != nil { 10527 ok := object.Key("SecondaryBackground") 10528 ok.String(*v.SecondaryBackground) 10529 } 10530 10531 if v.SecondaryForeground != nil { 10532 ok := object.Key("SecondaryForeground") 10533 ok.String(*v.SecondaryForeground) 10534 } 10535 10536 if v.Success != nil { 10537 ok := object.Key("Success") 10538 ok.String(*v.Success) 10539 } 10540 10541 if v.SuccessForeground != nil { 10542 ok := object.Key("SuccessForeground") 10543 ok.String(*v.SuccessForeground) 10544 } 10545 10546 if v.Warning != nil { 10547 ok := object.Key("Warning") 10548 ok.String(*v.Warning) 10549 } 10550 10551 if v.WarningForeground != nil { 10552 ok := object.Key("WarningForeground") 10553 ok.String(*v.WarningForeground) 10554 } 10555 10556 return nil 10557} 10558 10559func awsRestjson1_serializeDocumentUpdateResourcePermissionList(v []types.ResourcePermission, value smithyjson.Value) error { 10560 array := value.Array() 10561 defer array.Close() 10562 10563 for i := range v { 10564 av := array.Value() 10565 if err := awsRestjson1_serializeDocumentResourcePermission(&v[i], av); err != nil { 10566 return err 10567 } 10568 } 10569 return nil 10570} 10571 10572func awsRestjson1_serializeDocumentUploadSettings(v *types.UploadSettings, value smithyjson.Value) error { 10573 object := value.Object() 10574 defer object.Close() 10575 10576 if v.ContainsHeader { 10577 ok := object.Key("ContainsHeader") 10578 ok.Boolean(v.ContainsHeader) 10579 } 10580 10581 if v.Delimiter != nil { 10582 ok := object.Key("Delimiter") 10583 ok.String(*v.Delimiter) 10584 } 10585 10586 if len(v.Format) > 0 { 10587 ok := object.Key("Format") 10588 ok.String(string(v.Format)) 10589 } 10590 10591 if v.StartFromRow != 0 { 10592 ok := object.Key("StartFromRow") 10593 ok.Integer(v.StartFromRow) 10594 } 10595 10596 if len(v.TextQualifier) > 0 { 10597 ok := object.Key("TextQualifier") 10598 ok.String(string(v.TextQualifier)) 10599 } 10600 10601 return nil 10602} 10603 10604func awsRestjson1_serializeDocumentVpcConnectionProperties(v *types.VpcConnectionProperties, value smithyjson.Value) error { 10605 object := value.Object() 10606 defer object.Close() 10607 10608 if v.VpcConnectionArn != nil { 10609 ok := object.Key("VpcConnectionArn") 10610 ok.String(*v.VpcConnectionArn) 10611 } 10612 10613 return nil 10614} 10615