1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package amplifybackend 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/amplifybackend/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15 "math" 16) 17 18type awsRestjson1_serializeOpCloneBackend struct { 19} 20 21func (*awsRestjson1_serializeOpCloneBackend) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpCloneBackend) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27) { 28 request, ok := in.Request.(*smithyhttp.Request) 29 if !ok { 30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 31 } 32 33 input, ok := in.Parameters.(*CloneBackendInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/environments/{BackendEnvironmentName}/clone") 40 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 41 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 42 request.Method = "POST" 43 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 44 if err != nil { 45 return out, metadata, &smithy.SerializationError{Err: err} 46 } 47 48 if err := awsRestjson1_serializeOpHttpBindingsCloneBackendInput(input, restEncoder); err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 restEncoder.SetHeader("Content-Type").String("application/json") 53 54 jsonEncoder := smithyjson.NewEncoder() 55 if err := awsRestjson1_serializeOpDocumentCloneBackendInput(input, jsonEncoder.Value); err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 in.Request = request 67 68 return next.HandleSerialize(ctx, in) 69} 70func awsRestjson1_serializeOpHttpBindingsCloneBackendInput(v *CloneBackendInput, encoder *httpbinding.Encoder) error { 71 if v == nil { 72 return fmt.Errorf("unsupported serialization of nil %T", v) 73 } 74 75 if v.AppId == nil || len(*v.AppId) == 0 { 76 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 77 } 78 if v.AppId != nil { 79 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 80 return err 81 } 82 } 83 84 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 85 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 86 } 87 if v.BackendEnvironmentName != nil { 88 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 89 return err 90 } 91 } 92 93 return nil 94} 95 96func awsRestjson1_serializeOpDocumentCloneBackendInput(v *CloneBackendInput, value smithyjson.Value) error { 97 object := value.Object() 98 defer object.Close() 99 100 if v.TargetEnvironmentName != nil { 101 ok := object.Key("targetEnvironmentName") 102 ok.String(*v.TargetEnvironmentName) 103 } 104 105 return nil 106} 107 108type awsRestjson1_serializeOpCreateBackend struct { 109} 110 111func (*awsRestjson1_serializeOpCreateBackend) ID() string { 112 return "OperationSerializer" 113} 114 115func (m *awsRestjson1_serializeOpCreateBackend) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 116 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 117) { 118 request, ok := in.Request.(*smithyhttp.Request) 119 if !ok { 120 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 121 } 122 123 input, ok := in.Parameters.(*CreateBackendInput) 124 _ = input 125 if !ok { 126 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 127 } 128 129 opPath, opQuery := httpbinding.SplitURI("/backend") 130 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 131 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 132 request.Method = "POST" 133 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 134 if err != nil { 135 return out, metadata, &smithy.SerializationError{Err: err} 136 } 137 138 restEncoder.SetHeader("Content-Type").String("application/json") 139 140 jsonEncoder := smithyjson.NewEncoder() 141 if err := awsRestjson1_serializeOpDocumentCreateBackendInput(input, jsonEncoder.Value); err != nil { 142 return out, metadata, &smithy.SerializationError{Err: err} 143 } 144 145 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 146 return out, metadata, &smithy.SerializationError{Err: err} 147 } 148 149 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 150 return out, metadata, &smithy.SerializationError{Err: err} 151 } 152 in.Request = request 153 154 return next.HandleSerialize(ctx, in) 155} 156func awsRestjson1_serializeOpHttpBindingsCreateBackendInput(v *CreateBackendInput, encoder *httpbinding.Encoder) error { 157 if v == nil { 158 return fmt.Errorf("unsupported serialization of nil %T", v) 159 } 160 161 return nil 162} 163 164func awsRestjson1_serializeOpDocumentCreateBackendInput(v *CreateBackendInput, value smithyjson.Value) error { 165 object := value.Object() 166 defer object.Close() 167 168 if v.AppId != nil { 169 ok := object.Key("appId") 170 ok.String(*v.AppId) 171 } 172 173 if v.AppName != nil { 174 ok := object.Key("appName") 175 ok.String(*v.AppName) 176 } 177 178 if v.BackendEnvironmentName != nil { 179 ok := object.Key("backendEnvironmentName") 180 ok.String(*v.BackendEnvironmentName) 181 } 182 183 if v.ResourceConfig != nil { 184 ok := object.Key("resourceConfig") 185 if err := awsRestjson1_serializeDocumentResourceConfig(v.ResourceConfig, ok); err != nil { 186 return err 187 } 188 } 189 190 if v.ResourceName != nil { 191 ok := object.Key("resourceName") 192 ok.String(*v.ResourceName) 193 } 194 195 return nil 196} 197 198type awsRestjson1_serializeOpCreateBackendAPI struct { 199} 200 201func (*awsRestjson1_serializeOpCreateBackendAPI) ID() string { 202 return "OperationSerializer" 203} 204 205func (m *awsRestjson1_serializeOpCreateBackendAPI) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 206 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 207) { 208 request, ok := in.Request.(*smithyhttp.Request) 209 if !ok { 210 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 211 } 212 213 input, ok := in.Parameters.(*CreateBackendAPIInput) 214 _ = input 215 if !ok { 216 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 217 } 218 219 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/api") 220 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 221 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 222 request.Method = "POST" 223 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 224 if err != nil { 225 return out, metadata, &smithy.SerializationError{Err: err} 226 } 227 228 if err := awsRestjson1_serializeOpHttpBindingsCreateBackendAPIInput(input, restEncoder); err != nil { 229 return out, metadata, &smithy.SerializationError{Err: err} 230 } 231 232 restEncoder.SetHeader("Content-Type").String("application/json") 233 234 jsonEncoder := smithyjson.NewEncoder() 235 if err := awsRestjson1_serializeOpDocumentCreateBackendAPIInput(input, jsonEncoder.Value); err != nil { 236 return out, metadata, &smithy.SerializationError{Err: err} 237 } 238 239 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 240 return out, metadata, &smithy.SerializationError{Err: err} 241 } 242 243 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 244 return out, metadata, &smithy.SerializationError{Err: err} 245 } 246 in.Request = request 247 248 return next.HandleSerialize(ctx, in) 249} 250func awsRestjson1_serializeOpHttpBindingsCreateBackendAPIInput(v *CreateBackendAPIInput, encoder *httpbinding.Encoder) error { 251 if v == nil { 252 return fmt.Errorf("unsupported serialization of nil %T", v) 253 } 254 255 if v.AppId == nil || len(*v.AppId) == 0 { 256 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 257 } 258 if v.AppId != nil { 259 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 260 return err 261 } 262 } 263 264 return nil 265} 266 267func awsRestjson1_serializeOpDocumentCreateBackendAPIInput(v *CreateBackendAPIInput, value smithyjson.Value) error { 268 object := value.Object() 269 defer object.Close() 270 271 if v.BackendEnvironmentName != nil { 272 ok := object.Key("backendEnvironmentName") 273 ok.String(*v.BackendEnvironmentName) 274 } 275 276 if v.ResourceConfig != nil { 277 ok := object.Key("resourceConfig") 278 if err := awsRestjson1_serializeDocumentBackendAPIResourceConfig(v.ResourceConfig, ok); err != nil { 279 return err 280 } 281 } 282 283 if v.ResourceName != nil { 284 ok := object.Key("resourceName") 285 ok.String(*v.ResourceName) 286 } 287 288 return nil 289} 290 291type awsRestjson1_serializeOpCreateBackendAuth struct { 292} 293 294func (*awsRestjson1_serializeOpCreateBackendAuth) ID() string { 295 return "OperationSerializer" 296} 297 298func (m *awsRestjson1_serializeOpCreateBackendAuth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 299 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 300) { 301 request, ok := in.Request.(*smithyhttp.Request) 302 if !ok { 303 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 304 } 305 306 input, ok := in.Parameters.(*CreateBackendAuthInput) 307 _ = input 308 if !ok { 309 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 310 } 311 312 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/auth") 313 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 314 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 315 request.Method = "POST" 316 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 317 if err != nil { 318 return out, metadata, &smithy.SerializationError{Err: err} 319 } 320 321 if err := awsRestjson1_serializeOpHttpBindingsCreateBackendAuthInput(input, restEncoder); err != nil { 322 return out, metadata, &smithy.SerializationError{Err: err} 323 } 324 325 restEncoder.SetHeader("Content-Type").String("application/json") 326 327 jsonEncoder := smithyjson.NewEncoder() 328 if err := awsRestjson1_serializeOpDocumentCreateBackendAuthInput(input, jsonEncoder.Value); err != nil { 329 return out, metadata, &smithy.SerializationError{Err: err} 330 } 331 332 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 333 return out, metadata, &smithy.SerializationError{Err: err} 334 } 335 336 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 337 return out, metadata, &smithy.SerializationError{Err: err} 338 } 339 in.Request = request 340 341 return next.HandleSerialize(ctx, in) 342} 343func awsRestjson1_serializeOpHttpBindingsCreateBackendAuthInput(v *CreateBackendAuthInput, encoder *httpbinding.Encoder) error { 344 if v == nil { 345 return fmt.Errorf("unsupported serialization of nil %T", v) 346 } 347 348 if v.AppId == nil || len(*v.AppId) == 0 { 349 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 350 } 351 if v.AppId != nil { 352 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 353 return err 354 } 355 } 356 357 return nil 358} 359 360func awsRestjson1_serializeOpDocumentCreateBackendAuthInput(v *CreateBackendAuthInput, value smithyjson.Value) error { 361 object := value.Object() 362 defer object.Close() 363 364 if v.BackendEnvironmentName != nil { 365 ok := object.Key("backendEnvironmentName") 366 ok.String(*v.BackendEnvironmentName) 367 } 368 369 if v.ResourceConfig != nil { 370 ok := object.Key("resourceConfig") 371 if err := awsRestjson1_serializeDocumentCreateBackendAuthResourceConfig(v.ResourceConfig, ok); err != nil { 372 return err 373 } 374 } 375 376 if v.ResourceName != nil { 377 ok := object.Key("resourceName") 378 ok.String(*v.ResourceName) 379 } 380 381 return nil 382} 383 384type awsRestjson1_serializeOpCreateBackendConfig struct { 385} 386 387func (*awsRestjson1_serializeOpCreateBackendConfig) ID() string { 388 return "OperationSerializer" 389} 390 391func (m *awsRestjson1_serializeOpCreateBackendConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 392 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 393) { 394 request, ok := in.Request.(*smithyhttp.Request) 395 if !ok { 396 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 397 } 398 399 input, ok := in.Parameters.(*CreateBackendConfigInput) 400 _ = input 401 if !ok { 402 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 403 } 404 405 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/config") 406 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 407 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 408 request.Method = "POST" 409 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 410 if err != nil { 411 return out, metadata, &smithy.SerializationError{Err: err} 412 } 413 414 if err := awsRestjson1_serializeOpHttpBindingsCreateBackendConfigInput(input, restEncoder); err != nil { 415 return out, metadata, &smithy.SerializationError{Err: err} 416 } 417 418 restEncoder.SetHeader("Content-Type").String("application/json") 419 420 jsonEncoder := smithyjson.NewEncoder() 421 if err := awsRestjson1_serializeOpDocumentCreateBackendConfigInput(input, jsonEncoder.Value); err != nil { 422 return out, metadata, &smithy.SerializationError{Err: err} 423 } 424 425 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 426 return out, metadata, &smithy.SerializationError{Err: err} 427 } 428 429 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 430 return out, metadata, &smithy.SerializationError{Err: err} 431 } 432 in.Request = request 433 434 return next.HandleSerialize(ctx, in) 435} 436func awsRestjson1_serializeOpHttpBindingsCreateBackendConfigInput(v *CreateBackendConfigInput, encoder *httpbinding.Encoder) error { 437 if v == nil { 438 return fmt.Errorf("unsupported serialization of nil %T", v) 439 } 440 441 if v.AppId == nil || len(*v.AppId) == 0 { 442 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 443 } 444 if v.AppId != nil { 445 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 446 return err 447 } 448 } 449 450 return nil 451} 452 453func awsRestjson1_serializeOpDocumentCreateBackendConfigInput(v *CreateBackendConfigInput, value smithyjson.Value) error { 454 object := value.Object() 455 defer object.Close() 456 457 if v.BackendManagerAppId != nil { 458 ok := object.Key("backendManagerAppId") 459 ok.String(*v.BackendManagerAppId) 460 } 461 462 return nil 463} 464 465type awsRestjson1_serializeOpCreateToken struct { 466} 467 468func (*awsRestjson1_serializeOpCreateToken) ID() string { 469 return "OperationSerializer" 470} 471 472func (m *awsRestjson1_serializeOpCreateToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 473 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 474) { 475 request, ok := in.Request.(*smithyhttp.Request) 476 if !ok { 477 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 478 } 479 480 input, ok := in.Parameters.(*CreateTokenInput) 481 _ = input 482 if !ok { 483 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 484 } 485 486 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/challenge") 487 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 488 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 489 request.Method = "POST" 490 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 491 if err != nil { 492 return out, metadata, &smithy.SerializationError{Err: err} 493 } 494 495 if err := awsRestjson1_serializeOpHttpBindingsCreateTokenInput(input, restEncoder); err != nil { 496 return out, metadata, &smithy.SerializationError{Err: err} 497 } 498 499 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 500 return out, metadata, &smithy.SerializationError{Err: err} 501 } 502 in.Request = request 503 504 return next.HandleSerialize(ctx, in) 505} 506func awsRestjson1_serializeOpHttpBindingsCreateTokenInput(v *CreateTokenInput, encoder *httpbinding.Encoder) error { 507 if v == nil { 508 return fmt.Errorf("unsupported serialization of nil %T", v) 509 } 510 511 if v.AppId == nil || len(*v.AppId) == 0 { 512 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 513 } 514 if v.AppId != nil { 515 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 516 return err 517 } 518 } 519 520 return nil 521} 522 523type awsRestjson1_serializeOpDeleteBackend struct { 524} 525 526func (*awsRestjson1_serializeOpDeleteBackend) ID() string { 527 return "OperationSerializer" 528} 529 530func (m *awsRestjson1_serializeOpDeleteBackend) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 531 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 532) { 533 request, ok := in.Request.(*smithyhttp.Request) 534 if !ok { 535 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 536 } 537 538 input, ok := in.Parameters.(*DeleteBackendInput) 539 _ = input 540 if !ok { 541 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 542 } 543 544 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/environments/{BackendEnvironmentName}/remove") 545 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 546 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 547 request.Method = "POST" 548 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 549 if err != nil { 550 return out, metadata, &smithy.SerializationError{Err: err} 551 } 552 553 if err := awsRestjson1_serializeOpHttpBindingsDeleteBackendInput(input, restEncoder); err != nil { 554 return out, metadata, &smithy.SerializationError{Err: err} 555 } 556 557 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 558 return out, metadata, &smithy.SerializationError{Err: err} 559 } 560 in.Request = request 561 562 return next.HandleSerialize(ctx, in) 563} 564func awsRestjson1_serializeOpHttpBindingsDeleteBackendInput(v *DeleteBackendInput, encoder *httpbinding.Encoder) error { 565 if v == nil { 566 return fmt.Errorf("unsupported serialization of nil %T", v) 567 } 568 569 if v.AppId == nil || len(*v.AppId) == 0 { 570 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 571 } 572 if v.AppId != nil { 573 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 574 return err 575 } 576 } 577 578 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 579 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 580 } 581 if v.BackendEnvironmentName != nil { 582 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 583 return err 584 } 585 } 586 587 return nil 588} 589 590type awsRestjson1_serializeOpDeleteBackendAPI struct { 591} 592 593func (*awsRestjson1_serializeOpDeleteBackendAPI) ID() string { 594 return "OperationSerializer" 595} 596 597func (m *awsRestjson1_serializeOpDeleteBackendAPI) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 598 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 599) { 600 request, ok := in.Request.(*smithyhttp.Request) 601 if !ok { 602 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 603 } 604 605 input, ok := in.Parameters.(*DeleteBackendAPIInput) 606 _ = input 607 if !ok { 608 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 609 } 610 611 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/api/{BackendEnvironmentName}/remove") 612 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 613 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 614 request.Method = "POST" 615 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 616 if err != nil { 617 return out, metadata, &smithy.SerializationError{Err: err} 618 } 619 620 if err := awsRestjson1_serializeOpHttpBindingsDeleteBackendAPIInput(input, restEncoder); err != nil { 621 return out, metadata, &smithy.SerializationError{Err: err} 622 } 623 624 restEncoder.SetHeader("Content-Type").String("application/json") 625 626 jsonEncoder := smithyjson.NewEncoder() 627 if err := awsRestjson1_serializeOpDocumentDeleteBackendAPIInput(input, jsonEncoder.Value); err != nil { 628 return out, metadata, &smithy.SerializationError{Err: err} 629 } 630 631 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 632 return out, metadata, &smithy.SerializationError{Err: err} 633 } 634 635 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 636 return out, metadata, &smithy.SerializationError{Err: err} 637 } 638 in.Request = request 639 640 return next.HandleSerialize(ctx, in) 641} 642func awsRestjson1_serializeOpHttpBindingsDeleteBackendAPIInput(v *DeleteBackendAPIInput, encoder *httpbinding.Encoder) error { 643 if v == nil { 644 return fmt.Errorf("unsupported serialization of nil %T", v) 645 } 646 647 if v.AppId == nil || len(*v.AppId) == 0 { 648 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 649 } 650 if v.AppId != nil { 651 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 652 return err 653 } 654 } 655 656 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 657 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 658 } 659 if v.BackendEnvironmentName != nil { 660 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 661 return err 662 } 663 } 664 665 return nil 666} 667 668func awsRestjson1_serializeOpDocumentDeleteBackendAPIInput(v *DeleteBackendAPIInput, value smithyjson.Value) error { 669 object := value.Object() 670 defer object.Close() 671 672 if v.ResourceConfig != nil { 673 ok := object.Key("resourceConfig") 674 if err := awsRestjson1_serializeDocumentBackendAPIResourceConfig(v.ResourceConfig, ok); err != nil { 675 return err 676 } 677 } 678 679 if v.ResourceName != nil { 680 ok := object.Key("resourceName") 681 ok.String(*v.ResourceName) 682 } 683 684 return nil 685} 686 687type awsRestjson1_serializeOpDeleteBackendAuth struct { 688} 689 690func (*awsRestjson1_serializeOpDeleteBackendAuth) ID() string { 691 return "OperationSerializer" 692} 693 694func (m *awsRestjson1_serializeOpDeleteBackendAuth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 695 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 696) { 697 request, ok := in.Request.(*smithyhttp.Request) 698 if !ok { 699 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 700 } 701 702 input, ok := in.Parameters.(*DeleteBackendAuthInput) 703 _ = input 704 if !ok { 705 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 706 } 707 708 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/auth/{BackendEnvironmentName}/remove") 709 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 710 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 711 request.Method = "POST" 712 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 713 if err != nil { 714 return out, metadata, &smithy.SerializationError{Err: err} 715 } 716 717 if err := awsRestjson1_serializeOpHttpBindingsDeleteBackendAuthInput(input, restEncoder); err != nil { 718 return out, metadata, &smithy.SerializationError{Err: err} 719 } 720 721 restEncoder.SetHeader("Content-Type").String("application/json") 722 723 jsonEncoder := smithyjson.NewEncoder() 724 if err := awsRestjson1_serializeOpDocumentDeleteBackendAuthInput(input, jsonEncoder.Value); err != nil { 725 return out, metadata, &smithy.SerializationError{Err: err} 726 } 727 728 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 729 return out, metadata, &smithy.SerializationError{Err: err} 730 } 731 732 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 733 return out, metadata, &smithy.SerializationError{Err: err} 734 } 735 in.Request = request 736 737 return next.HandleSerialize(ctx, in) 738} 739func awsRestjson1_serializeOpHttpBindingsDeleteBackendAuthInput(v *DeleteBackendAuthInput, encoder *httpbinding.Encoder) error { 740 if v == nil { 741 return fmt.Errorf("unsupported serialization of nil %T", v) 742 } 743 744 if v.AppId == nil || len(*v.AppId) == 0 { 745 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 746 } 747 if v.AppId != nil { 748 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 749 return err 750 } 751 } 752 753 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 754 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 755 } 756 if v.BackendEnvironmentName != nil { 757 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 758 return err 759 } 760 } 761 762 return nil 763} 764 765func awsRestjson1_serializeOpDocumentDeleteBackendAuthInput(v *DeleteBackendAuthInput, value smithyjson.Value) error { 766 object := value.Object() 767 defer object.Close() 768 769 if v.ResourceName != nil { 770 ok := object.Key("resourceName") 771 ok.String(*v.ResourceName) 772 } 773 774 return nil 775} 776 777type awsRestjson1_serializeOpDeleteToken struct { 778} 779 780func (*awsRestjson1_serializeOpDeleteToken) ID() string { 781 return "OperationSerializer" 782} 783 784func (m *awsRestjson1_serializeOpDeleteToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 785 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 786) { 787 request, ok := in.Request.(*smithyhttp.Request) 788 if !ok { 789 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 790 } 791 792 input, ok := in.Parameters.(*DeleteTokenInput) 793 _ = input 794 if !ok { 795 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 796 } 797 798 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/challenge/{SessionId}/remove") 799 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 800 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 801 request.Method = "POST" 802 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 803 if err != nil { 804 return out, metadata, &smithy.SerializationError{Err: err} 805 } 806 807 if err := awsRestjson1_serializeOpHttpBindingsDeleteTokenInput(input, restEncoder); err != nil { 808 return out, metadata, &smithy.SerializationError{Err: err} 809 } 810 811 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 812 return out, metadata, &smithy.SerializationError{Err: err} 813 } 814 in.Request = request 815 816 return next.HandleSerialize(ctx, in) 817} 818func awsRestjson1_serializeOpHttpBindingsDeleteTokenInput(v *DeleteTokenInput, encoder *httpbinding.Encoder) error { 819 if v == nil { 820 return fmt.Errorf("unsupported serialization of nil %T", v) 821 } 822 823 if v.AppId == nil || len(*v.AppId) == 0 { 824 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 825 } 826 if v.AppId != nil { 827 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 828 return err 829 } 830 } 831 832 if v.SessionId == nil || len(*v.SessionId) == 0 { 833 return &smithy.SerializationError{Err: fmt.Errorf("input member SessionId must not be empty")} 834 } 835 if v.SessionId != nil { 836 if err := encoder.SetURI("SessionId").String(*v.SessionId); err != nil { 837 return err 838 } 839 } 840 841 return nil 842} 843 844type awsRestjson1_serializeOpGenerateBackendAPIModels struct { 845} 846 847func (*awsRestjson1_serializeOpGenerateBackendAPIModels) ID() string { 848 return "OperationSerializer" 849} 850 851func (m *awsRestjson1_serializeOpGenerateBackendAPIModels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 852 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 853) { 854 request, ok := in.Request.(*smithyhttp.Request) 855 if !ok { 856 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 857 } 858 859 input, ok := in.Parameters.(*GenerateBackendAPIModelsInput) 860 _ = input 861 if !ok { 862 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 863 } 864 865 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/api/{BackendEnvironmentName}/generateModels") 866 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 867 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 868 request.Method = "POST" 869 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 870 if err != nil { 871 return out, metadata, &smithy.SerializationError{Err: err} 872 } 873 874 if err := awsRestjson1_serializeOpHttpBindingsGenerateBackendAPIModelsInput(input, restEncoder); err != nil { 875 return out, metadata, &smithy.SerializationError{Err: err} 876 } 877 878 restEncoder.SetHeader("Content-Type").String("application/json") 879 880 jsonEncoder := smithyjson.NewEncoder() 881 if err := awsRestjson1_serializeOpDocumentGenerateBackendAPIModelsInput(input, jsonEncoder.Value); err != nil { 882 return out, metadata, &smithy.SerializationError{Err: err} 883 } 884 885 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 886 return out, metadata, &smithy.SerializationError{Err: err} 887 } 888 889 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 890 return out, metadata, &smithy.SerializationError{Err: err} 891 } 892 in.Request = request 893 894 return next.HandleSerialize(ctx, in) 895} 896func awsRestjson1_serializeOpHttpBindingsGenerateBackendAPIModelsInput(v *GenerateBackendAPIModelsInput, encoder *httpbinding.Encoder) error { 897 if v == nil { 898 return fmt.Errorf("unsupported serialization of nil %T", v) 899 } 900 901 if v.AppId == nil || len(*v.AppId) == 0 { 902 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 903 } 904 if v.AppId != nil { 905 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 906 return err 907 } 908 } 909 910 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 911 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 912 } 913 if v.BackendEnvironmentName != nil { 914 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 915 return err 916 } 917 } 918 919 return nil 920} 921 922func awsRestjson1_serializeOpDocumentGenerateBackendAPIModelsInput(v *GenerateBackendAPIModelsInput, value smithyjson.Value) error { 923 object := value.Object() 924 defer object.Close() 925 926 if v.ResourceName != nil { 927 ok := object.Key("resourceName") 928 ok.String(*v.ResourceName) 929 } 930 931 return nil 932} 933 934type awsRestjson1_serializeOpGetBackend struct { 935} 936 937func (*awsRestjson1_serializeOpGetBackend) ID() string { 938 return "OperationSerializer" 939} 940 941func (m *awsRestjson1_serializeOpGetBackend) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 942 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 943) { 944 request, ok := in.Request.(*smithyhttp.Request) 945 if !ok { 946 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 947 } 948 949 input, ok := in.Parameters.(*GetBackendInput) 950 _ = input 951 if !ok { 952 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 953 } 954 955 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/details") 956 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 957 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 958 request.Method = "POST" 959 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 960 if err != nil { 961 return out, metadata, &smithy.SerializationError{Err: err} 962 } 963 964 if err := awsRestjson1_serializeOpHttpBindingsGetBackendInput(input, restEncoder); err != nil { 965 return out, metadata, &smithy.SerializationError{Err: err} 966 } 967 968 restEncoder.SetHeader("Content-Type").String("application/json") 969 970 jsonEncoder := smithyjson.NewEncoder() 971 if err := awsRestjson1_serializeOpDocumentGetBackendInput(input, jsonEncoder.Value); err != nil { 972 return out, metadata, &smithy.SerializationError{Err: err} 973 } 974 975 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 976 return out, metadata, &smithy.SerializationError{Err: err} 977 } 978 979 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 980 return out, metadata, &smithy.SerializationError{Err: err} 981 } 982 in.Request = request 983 984 return next.HandleSerialize(ctx, in) 985} 986func awsRestjson1_serializeOpHttpBindingsGetBackendInput(v *GetBackendInput, encoder *httpbinding.Encoder) error { 987 if v == nil { 988 return fmt.Errorf("unsupported serialization of nil %T", v) 989 } 990 991 if v.AppId == nil || len(*v.AppId) == 0 { 992 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 993 } 994 if v.AppId != nil { 995 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 996 return err 997 } 998 } 999 1000 return nil 1001} 1002 1003func awsRestjson1_serializeOpDocumentGetBackendInput(v *GetBackendInput, value smithyjson.Value) error { 1004 object := value.Object() 1005 defer object.Close() 1006 1007 if v.BackendEnvironmentName != nil { 1008 ok := object.Key("backendEnvironmentName") 1009 ok.String(*v.BackendEnvironmentName) 1010 } 1011 1012 return nil 1013} 1014 1015type awsRestjson1_serializeOpGetBackendAPI struct { 1016} 1017 1018func (*awsRestjson1_serializeOpGetBackendAPI) ID() string { 1019 return "OperationSerializer" 1020} 1021 1022func (m *awsRestjson1_serializeOpGetBackendAPI) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1023 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1024) { 1025 request, ok := in.Request.(*smithyhttp.Request) 1026 if !ok { 1027 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1028 } 1029 1030 input, ok := in.Parameters.(*GetBackendAPIInput) 1031 _ = input 1032 if !ok { 1033 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1034 } 1035 1036 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/api/{BackendEnvironmentName}/details") 1037 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1038 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1039 request.Method = "POST" 1040 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1041 if err != nil { 1042 return out, metadata, &smithy.SerializationError{Err: err} 1043 } 1044 1045 if err := awsRestjson1_serializeOpHttpBindingsGetBackendAPIInput(input, restEncoder); err != nil { 1046 return out, metadata, &smithy.SerializationError{Err: err} 1047 } 1048 1049 restEncoder.SetHeader("Content-Type").String("application/json") 1050 1051 jsonEncoder := smithyjson.NewEncoder() 1052 if err := awsRestjson1_serializeOpDocumentGetBackendAPIInput(input, jsonEncoder.Value); err != nil { 1053 return out, metadata, &smithy.SerializationError{Err: err} 1054 } 1055 1056 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1057 return out, metadata, &smithy.SerializationError{Err: err} 1058 } 1059 1060 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1061 return out, metadata, &smithy.SerializationError{Err: err} 1062 } 1063 in.Request = request 1064 1065 return next.HandleSerialize(ctx, in) 1066} 1067func awsRestjson1_serializeOpHttpBindingsGetBackendAPIInput(v *GetBackendAPIInput, encoder *httpbinding.Encoder) error { 1068 if v == nil { 1069 return fmt.Errorf("unsupported serialization of nil %T", v) 1070 } 1071 1072 if v.AppId == nil || len(*v.AppId) == 0 { 1073 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1074 } 1075 if v.AppId != nil { 1076 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1077 return err 1078 } 1079 } 1080 1081 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1082 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1083 } 1084 if v.BackendEnvironmentName != nil { 1085 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1086 return err 1087 } 1088 } 1089 1090 return nil 1091} 1092 1093func awsRestjson1_serializeOpDocumentGetBackendAPIInput(v *GetBackendAPIInput, value smithyjson.Value) error { 1094 object := value.Object() 1095 defer object.Close() 1096 1097 if v.ResourceConfig != nil { 1098 ok := object.Key("resourceConfig") 1099 if err := awsRestjson1_serializeDocumentBackendAPIResourceConfig(v.ResourceConfig, ok); err != nil { 1100 return err 1101 } 1102 } 1103 1104 if v.ResourceName != nil { 1105 ok := object.Key("resourceName") 1106 ok.String(*v.ResourceName) 1107 } 1108 1109 return nil 1110} 1111 1112type awsRestjson1_serializeOpGetBackendAPIModels struct { 1113} 1114 1115func (*awsRestjson1_serializeOpGetBackendAPIModels) ID() string { 1116 return "OperationSerializer" 1117} 1118 1119func (m *awsRestjson1_serializeOpGetBackendAPIModels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1120 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1121) { 1122 request, ok := in.Request.(*smithyhttp.Request) 1123 if !ok { 1124 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1125 } 1126 1127 input, ok := in.Parameters.(*GetBackendAPIModelsInput) 1128 _ = input 1129 if !ok { 1130 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1131 } 1132 1133 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/api/{BackendEnvironmentName}/getModels") 1134 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1135 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1136 request.Method = "POST" 1137 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1138 if err != nil { 1139 return out, metadata, &smithy.SerializationError{Err: err} 1140 } 1141 1142 if err := awsRestjson1_serializeOpHttpBindingsGetBackendAPIModelsInput(input, restEncoder); err != nil { 1143 return out, metadata, &smithy.SerializationError{Err: err} 1144 } 1145 1146 restEncoder.SetHeader("Content-Type").String("application/json") 1147 1148 jsonEncoder := smithyjson.NewEncoder() 1149 if err := awsRestjson1_serializeOpDocumentGetBackendAPIModelsInput(input, jsonEncoder.Value); err != nil { 1150 return out, metadata, &smithy.SerializationError{Err: err} 1151 } 1152 1153 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1154 return out, metadata, &smithy.SerializationError{Err: err} 1155 } 1156 1157 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1158 return out, metadata, &smithy.SerializationError{Err: err} 1159 } 1160 in.Request = request 1161 1162 return next.HandleSerialize(ctx, in) 1163} 1164func awsRestjson1_serializeOpHttpBindingsGetBackendAPIModelsInput(v *GetBackendAPIModelsInput, encoder *httpbinding.Encoder) error { 1165 if v == nil { 1166 return fmt.Errorf("unsupported serialization of nil %T", v) 1167 } 1168 1169 if v.AppId == nil || len(*v.AppId) == 0 { 1170 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1171 } 1172 if v.AppId != nil { 1173 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1174 return err 1175 } 1176 } 1177 1178 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1179 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1180 } 1181 if v.BackendEnvironmentName != nil { 1182 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1183 return err 1184 } 1185 } 1186 1187 return nil 1188} 1189 1190func awsRestjson1_serializeOpDocumentGetBackendAPIModelsInput(v *GetBackendAPIModelsInput, value smithyjson.Value) error { 1191 object := value.Object() 1192 defer object.Close() 1193 1194 if v.ResourceName != nil { 1195 ok := object.Key("resourceName") 1196 ok.String(*v.ResourceName) 1197 } 1198 1199 return nil 1200} 1201 1202type awsRestjson1_serializeOpGetBackendAuth struct { 1203} 1204 1205func (*awsRestjson1_serializeOpGetBackendAuth) ID() string { 1206 return "OperationSerializer" 1207} 1208 1209func (m *awsRestjson1_serializeOpGetBackendAuth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1210 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1211) { 1212 request, ok := in.Request.(*smithyhttp.Request) 1213 if !ok { 1214 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1215 } 1216 1217 input, ok := in.Parameters.(*GetBackendAuthInput) 1218 _ = input 1219 if !ok { 1220 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1221 } 1222 1223 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/auth/{BackendEnvironmentName}/details") 1224 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1225 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1226 request.Method = "POST" 1227 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1228 if err != nil { 1229 return out, metadata, &smithy.SerializationError{Err: err} 1230 } 1231 1232 if err := awsRestjson1_serializeOpHttpBindingsGetBackendAuthInput(input, restEncoder); err != nil { 1233 return out, metadata, &smithy.SerializationError{Err: err} 1234 } 1235 1236 restEncoder.SetHeader("Content-Type").String("application/json") 1237 1238 jsonEncoder := smithyjson.NewEncoder() 1239 if err := awsRestjson1_serializeOpDocumentGetBackendAuthInput(input, jsonEncoder.Value); err != nil { 1240 return out, metadata, &smithy.SerializationError{Err: err} 1241 } 1242 1243 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1244 return out, metadata, &smithy.SerializationError{Err: err} 1245 } 1246 1247 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1248 return out, metadata, &smithy.SerializationError{Err: err} 1249 } 1250 in.Request = request 1251 1252 return next.HandleSerialize(ctx, in) 1253} 1254func awsRestjson1_serializeOpHttpBindingsGetBackendAuthInput(v *GetBackendAuthInput, encoder *httpbinding.Encoder) error { 1255 if v == nil { 1256 return fmt.Errorf("unsupported serialization of nil %T", v) 1257 } 1258 1259 if v.AppId == nil || len(*v.AppId) == 0 { 1260 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1261 } 1262 if v.AppId != nil { 1263 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1264 return err 1265 } 1266 } 1267 1268 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1269 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1270 } 1271 if v.BackendEnvironmentName != nil { 1272 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1273 return err 1274 } 1275 } 1276 1277 return nil 1278} 1279 1280func awsRestjson1_serializeOpDocumentGetBackendAuthInput(v *GetBackendAuthInput, value smithyjson.Value) error { 1281 object := value.Object() 1282 defer object.Close() 1283 1284 if v.ResourceName != nil { 1285 ok := object.Key("resourceName") 1286 ok.String(*v.ResourceName) 1287 } 1288 1289 return nil 1290} 1291 1292type awsRestjson1_serializeOpGetBackendJob struct { 1293} 1294 1295func (*awsRestjson1_serializeOpGetBackendJob) ID() string { 1296 return "OperationSerializer" 1297} 1298 1299func (m *awsRestjson1_serializeOpGetBackendJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1300 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1301) { 1302 request, ok := in.Request.(*smithyhttp.Request) 1303 if !ok { 1304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1305 } 1306 1307 input, ok := in.Parameters.(*GetBackendJobInput) 1308 _ = input 1309 if !ok { 1310 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1311 } 1312 1313 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/job/{BackendEnvironmentName}/{JobId}") 1314 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1315 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1316 request.Method = "GET" 1317 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1318 if err != nil { 1319 return out, metadata, &smithy.SerializationError{Err: err} 1320 } 1321 1322 if err := awsRestjson1_serializeOpHttpBindingsGetBackendJobInput(input, restEncoder); err != nil { 1323 return out, metadata, &smithy.SerializationError{Err: err} 1324 } 1325 1326 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1327 return out, metadata, &smithy.SerializationError{Err: err} 1328 } 1329 in.Request = request 1330 1331 return next.HandleSerialize(ctx, in) 1332} 1333func awsRestjson1_serializeOpHttpBindingsGetBackendJobInput(v *GetBackendJobInput, encoder *httpbinding.Encoder) error { 1334 if v == nil { 1335 return fmt.Errorf("unsupported serialization of nil %T", v) 1336 } 1337 1338 if v.AppId == nil || len(*v.AppId) == 0 { 1339 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1340 } 1341 if v.AppId != nil { 1342 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1343 return err 1344 } 1345 } 1346 1347 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1348 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1349 } 1350 if v.BackendEnvironmentName != nil { 1351 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1352 return err 1353 } 1354 } 1355 1356 if v.JobId == nil || len(*v.JobId) == 0 { 1357 return &smithy.SerializationError{Err: fmt.Errorf("input member JobId must not be empty")} 1358 } 1359 if v.JobId != nil { 1360 if err := encoder.SetURI("JobId").String(*v.JobId); err != nil { 1361 return err 1362 } 1363 } 1364 1365 return nil 1366} 1367 1368type awsRestjson1_serializeOpGetToken struct { 1369} 1370 1371func (*awsRestjson1_serializeOpGetToken) ID() string { 1372 return "OperationSerializer" 1373} 1374 1375func (m *awsRestjson1_serializeOpGetToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1376 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1377) { 1378 request, ok := in.Request.(*smithyhttp.Request) 1379 if !ok { 1380 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1381 } 1382 1383 input, ok := in.Parameters.(*GetTokenInput) 1384 _ = input 1385 if !ok { 1386 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1387 } 1388 1389 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/challenge/{SessionId}") 1390 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1391 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1392 request.Method = "GET" 1393 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1394 if err != nil { 1395 return out, metadata, &smithy.SerializationError{Err: err} 1396 } 1397 1398 if err := awsRestjson1_serializeOpHttpBindingsGetTokenInput(input, restEncoder); err != nil { 1399 return out, metadata, &smithy.SerializationError{Err: err} 1400 } 1401 1402 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1403 return out, metadata, &smithy.SerializationError{Err: err} 1404 } 1405 in.Request = request 1406 1407 return next.HandleSerialize(ctx, in) 1408} 1409func awsRestjson1_serializeOpHttpBindingsGetTokenInput(v *GetTokenInput, encoder *httpbinding.Encoder) error { 1410 if v == nil { 1411 return fmt.Errorf("unsupported serialization of nil %T", v) 1412 } 1413 1414 if v.AppId == nil || len(*v.AppId) == 0 { 1415 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1416 } 1417 if v.AppId != nil { 1418 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1419 return err 1420 } 1421 } 1422 1423 if v.SessionId == nil || len(*v.SessionId) == 0 { 1424 return &smithy.SerializationError{Err: fmt.Errorf("input member SessionId must not be empty")} 1425 } 1426 if v.SessionId != nil { 1427 if err := encoder.SetURI("SessionId").String(*v.SessionId); err != nil { 1428 return err 1429 } 1430 } 1431 1432 return nil 1433} 1434 1435type awsRestjson1_serializeOpImportBackendAuth struct { 1436} 1437 1438func (*awsRestjson1_serializeOpImportBackendAuth) ID() string { 1439 return "OperationSerializer" 1440} 1441 1442func (m *awsRestjson1_serializeOpImportBackendAuth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1443 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1444) { 1445 request, ok := in.Request.(*smithyhttp.Request) 1446 if !ok { 1447 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1448 } 1449 1450 input, ok := in.Parameters.(*ImportBackendAuthInput) 1451 _ = input 1452 if !ok { 1453 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1454 } 1455 1456 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/auth/{BackendEnvironmentName}/import") 1457 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1458 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1459 request.Method = "POST" 1460 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1461 if err != nil { 1462 return out, metadata, &smithy.SerializationError{Err: err} 1463 } 1464 1465 if err := awsRestjson1_serializeOpHttpBindingsImportBackendAuthInput(input, restEncoder); err != nil { 1466 return out, metadata, &smithy.SerializationError{Err: err} 1467 } 1468 1469 restEncoder.SetHeader("Content-Type").String("application/json") 1470 1471 jsonEncoder := smithyjson.NewEncoder() 1472 if err := awsRestjson1_serializeOpDocumentImportBackendAuthInput(input, jsonEncoder.Value); err != nil { 1473 return out, metadata, &smithy.SerializationError{Err: err} 1474 } 1475 1476 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1477 return out, metadata, &smithy.SerializationError{Err: err} 1478 } 1479 1480 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1481 return out, metadata, &smithy.SerializationError{Err: err} 1482 } 1483 in.Request = request 1484 1485 return next.HandleSerialize(ctx, in) 1486} 1487func awsRestjson1_serializeOpHttpBindingsImportBackendAuthInput(v *ImportBackendAuthInput, encoder *httpbinding.Encoder) error { 1488 if v == nil { 1489 return fmt.Errorf("unsupported serialization of nil %T", v) 1490 } 1491 1492 if v.AppId == nil || len(*v.AppId) == 0 { 1493 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1494 } 1495 if v.AppId != nil { 1496 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1497 return err 1498 } 1499 } 1500 1501 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1502 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1503 } 1504 if v.BackendEnvironmentName != nil { 1505 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1506 return err 1507 } 1508 } 1509 1510 return nil 1511} 1512 1513func awsRestjson1_serializeOpDocumentImportBackendAuthInput(v *ImportBackendAuthInput, value smithyjson.Value) error { 1514 object := value.Object() 1515 defer object.Close() 1516 1517 if v.IdentityPoolId != nil { 1518 ok := object.Key("identityPoolId") 1519 ok.String(*v.IdentityPoolId) 1520 } 1521 1522 if v.NativeClientId != nil { 1523 ok := object.Key("nativeClientId") 1524 ok.String(*v.NativeClientId) 1525 } 1526 1527 if v.UserPoolId != nil { 1528 ok := object.Key("userPoolId") 1529 ok.String(*v.UserPoolId) 1530 } 1531 1532 if v.WebClientId != nil { 1533 ok := object.Key("webClientId") 1534 ok.String(*v.WebClientId) 1535 } 1536 1537 return nil 1538} 1539 1540type awsRestjson1_serializeOpListBackendJobs struct { 1541} 1542 1543func (*awsRestjson1_serializeOpListBackendJobs) ID() string { 1544 return "OperationSerializer" 1545} 1546 1547func (m *awsRestjson1_serializeOpListBackendJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1548 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1549) { 1550 request, ok := in.Request.(*smithyhttp.Request) 1551 if !ok { 1552 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1553 } 1554 1555 input, ok := in.Parameters.(*ListBackendJobsInput) 1556 _ = input 1557 if !ok { 1558 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1559 } 1560 1561 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/job/{BackendEnvironmentName}") 1562 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1563 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1564 request.Method = "POST" 1565 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1566 if err != nil { 1567 return out, metadata, &smithy.SerializationError{Err: err} 1568 } 1569 1570 if err := awsRestjson1_serializeOpHttpBindingsListBackendJobsInput(input, restEncoder); err != nil { 1571 return out, metadata, &smithy.SerializationError{Err: err} 1572 } 1573 1574 restEncoder.SetHeader("Content-Type").String("application/json") 1575 1576 jsonEncoder := smithyjson.NewEncoder() 1577 if err := awsRestjson1_serializeOpDocumentListBackendJobsInput(input, jsonEncoder.Value); err != nil { 1578 return out, metadata, &smithy.SerializationError{Err: err} 1579 } 1580 1581 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1582 return out, metadata, &smithy.SerializationError{Err: err} 1583 } 1584 1585 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1586 return out, metadata, &smithy.SerializationError{Err: err} 1587 } 1588 in.Request = request 1589 1590 return next.HandleSerialize(ctx, in) 1591} 1592func awsRestjson1_serializeOpHttpBindingsListBackendJobsInput(v *ListBackendJobsInput, encoder *httpbinding.Encoder) error { 1593 if v == nil { 1594 return fmt.Errorf("unsupported serialization of nil %T", v) 1595 } 1596 1597 if v.AppId == nil || len(*v.AppId) == 0 { 1598 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1599 } 1600 if v.AppId != nil { 1601 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1602 return err 1603 } 1604 } 1605 1606 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1607 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1608 } 1609 if v.BackendEnvironmentName != nil { 1610 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1611 return err 1612 } 1613 } 1614 1615 return nil 1616} 1617 1618func awsRestjson1_serializeOpDocumentListBackendJobsInput(v *ListBackendJobsInput, value smithyjson.Value) error { 1619 object := value.Object() 1620 defer object.Close() 1621 1622 if v.JobId != nil { 1623 ok := object.Key("jobId") 1624 ok.String(*v.JobId) 1625 } 1626 1627 if v.MaxResults != 0 { 1628 ok := object.Key("maxResults") 1629 ok.Integer(v.MaxResults) 1630 } 1631 1632 if v.NextToken != nil { 1633 ok := object.Key("nextToken") 1634 ok.String(*v.NextToken) 1635 } 1636 1637 if v.Operation != nil { 1638 ok := object.Key("operation") 1639 ok.String(*v.Operation) 1640 } 1641 1642 if v.Status != nil { 1643 ok := object.Key("status") 1644 ok.String(*v.Status) 1645 } 1646 1647 return nil 1648} 1649 1650type awsRestjson1_serializeOpRemoveAllBackends struct { 1651} 1652 1653func (*awsRestjson1_serializeOpRemoveAllBackends) ID() string { 1654 return "OperationSerializer" 1655} 1656 1657func (m *awsRestjson1_serializeOpRemoveAllBackends) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1658 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1659) { 1660 request, ok := in.Request.(*smithyhttp.Request) 1661 if !ok { 1662 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1663 } 1664 1665 input, ok := in.Parameters.(*RemoveAllBackendsInput) 1666 _ = input 1667 if !ok { 1668 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1669 } 1670 1671 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/remove") 1672 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1673 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1674 request.Method = "POST" 1675 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1676 if err != nil { 1677 return out, metadata, &smithy.SerializationError{Err: err} 1678 } 1679 1680 if err := awsRestjson1_serializeOpHttpBindingsRemoveAllBackendsInput(input, restEncoder); err != nil { 1681 return out, metadata, &smithy.SerializationError{Err: err} 1682 } 1683 1684 restEncoder.SetHeader("Content-Type").String("application/json") 1685 1686 jsonEncoder := smithyjson.NewEncoder() 1687 if err := awsRestjson1_serializeOpDocumentRemoveAllBackendsInput(input, jsonEncoder.Value); err != nil { 1688 return out, metadata, &smithy.SerializationError{Err: err} 1689 } 1690 1691 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1692 return out, metadata, &smithy.SerializationError{Err: err} 1693 } 1694 1695 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1696 return out, metadata, &smithy.SerializationError{Err: err} 1697 } 1698 in.Request = request 1699 1700 return next.HandleSerialize(ctx, in) 1701} 1702func awsRestjson1_serializeOpHttpBindingsRemoveAllBackendsInput(v *RemoveAllBackendsInput, encoder *httpbinding.Encoder) error { 1703 if v == nil { 1704 return fmt.Errorf("unsupported serialization of nil %T", v) 1705 } 1706 1707 if v.AppId == nil || len(*v.AppId) == 0 { 1708 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1709 } 1710 if v.AppId != nil { 1711 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1712 return err 1713 } 1714 } 1715 1716 return nil 1717} 1718 1719func awsRestjson1_serializeOpDocumentRemoveAllBackendsInput(v *RemoveAllBackendsInput, value smithyjson.Value) error { 1720 object := value.Object() 1721 defer object.Close() 1722 1723 if v.CleanAmplifyApp { 1724 ok := object.Key("cleanAmplifyApp") 1725 ok.Boolean(v.CleanAmplifyApp) 1726 } 1727 1728 return nil 1729} 1730 1731type awsRestjson1_serializeOpRemoveBackendConfig struct { 1732} 1733 1734func (*awsRestjson1_serializeOpRemoveBackendConfig) ID() string { 1735 return "OperationSerializer" 1736} 1737 1738func (m *awsRestjson1_serializeOpRemoveBackendConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1739 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1740) { 1741 request, ok := in.Request.(*smithyhttp.Request) 1742 if !ok { 1743 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1744 } 1745 1746 input, ok := in.Parameters.(*RemoveBackendConfigInput) 1747 _ = input 1748 if !ok { 1749 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1750 } 1751 1752 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/config/remove") 1753 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1754 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1755 request.Method = "POST" 1756 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1757 if err != nil { 1758 return out, metadata, &smithy.SerializationError{Err: err} 1759 } 1760 1761 if err := awsRestjson1_serializeOpHttpBindingsRemoveBackendConfigInput(input, restEncoder); err != nil { 1762 return out, metadata, &smithy.SerializationError{Err: err} 1763 } 1764 1765 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1766 return out, metadata, &smithy.SerializationError{Err: err} 1767 } 1768 in.Request = request 1769 1770 return next.HandleSerialize(ctx, in) 1771} 1772func awsRestjson1_serializeOpHttpBindingsRemoveBackendConfigInput(v *RemoveBackendConfigInput, encoder *httpbinding.Encoder) error { 1773 if v == nil { 1774 return fmt.Errorf("unsupported serialization of nil %T", v) 1775 } 1776 1777 if v.AppId == nil || len(*v.AppId) == 0 { 1778 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1779 } 1780 if v.AppId != nil { 1781 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1782 return err 1783 } 1784 } 1785 1786 return nil 1787} 1788 1789type awsRestjson1_serializeOpUpdateBackendAPI struct { 1790} 1791 1792func (*awsRestjson1_serializeOpUpdateBackendAPI) ID() string { 1793 return "OperationSerializer" 1794} 1795 1796func (m *awsRestjson1_serializeOpUpdateBackendAPI) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1797 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1798) { 1799 request, ok := in.Request.(*smithyhttp.Request) 1800 if !ok { 1801 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1802 } 1803 1804 input, ok := in.Parameters.(*UpdateBackendAPIInput) 1805 _ = input 1806 if !ok { 1807 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1808 } 1809 1810 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/api/{BackendEnvironmentName}") 1811 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1812 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1813 request.Method = "POST" 1814 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1815 if err != nil { 1816 return out, metadata, &smithy.SerializationError{Err: err} 1817 } 1818 1819 if err := awsRestjson1_serializeOpHttpBindingsUpdateBackendAPIInput(input, restEncoder); err != nil { 1820 return out, metadata, &smithy.SerializationError{Err: err} 1821 } 1822 1823 restEncoder.SetHeader("Content-Type").String("application/json") 1824 1825 jsonEncoder := smithyjson.NewEncoder() 1826 if err := awsRestjson1_serializeOpDocumentUpdateBackendAPIInput(input, jsonEncoder.Value); err != nil { 1827 return out, metadata, &smithy.SerializationError{Err: err} 1828 } 1829 1830 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1831 return out, metadata, &smithy.SerializationError{Err: err} 1832 } 1833 1834 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1835 return out, metadata, &smithy.SerializationError{Err: err} 1836 } 1837 in.Request = request 1838 1839 return next.HandleSerialize(ctx, in) 1840} 1841func awsRestjson1_serializeOpHttpBindingsUpdateBackendAPIInput(v *UpdateBackendAPIInput, encoder *httpbinding.Encoder) error { 1842 if v == nil { 1843 return fmt.Errorf("unsupported serialization of nil %T", v) 1844 } 1845 1846 if v.AppId == nil || len(*v.AppId) == 0 { 1847 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1848 } 1849 if v.AppId != nil { 1850 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1851 return err 1852 } 1853 } 1854 1855 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1856 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1857 } 1858 if v.BackendEnvironmentName != nil { 1859 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1860 return err 1861 } 1862 } 1863 1864 return nil 1865} 1866 1867func awsRestjson1_serializeOpDocumentUpdateBackendAPIInput(v *UpdateBackendAPIInput, value smithyjson.Value) error { 1868 object := value.Object() 1869 defer object.Close() 1870 1871 if v.ResourceConfig != nil { 1872 ok := object.Key("resourceConfig") 1873 if err := awsRestjson1_serializeDocumentBackendAPIResourceConfig(v.ResourceConfig, ok); err != nil { 1874 return err 1875 } 1876 } 1877 1878 if v.ResourceName != nil { 1879 ok := object.Key("resourceName") 1880 ok.String(*v.ResourceName) 1881 } 1882 1883 return nil 1884} 1885 1886type awsRestjson1_serializeOpUpdateBackendAuth struct { 1887} 1888 1889func (*awsRestjson1_serializeOpUpdateBackendAuth) ID() string { 1890 return "OperationSerializer" 1891} 1892 1893func (m *awsRestjson1_serializeOpUpdateBackendAuth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1894 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1895) { 1896 request, ok := in.Request.(*smithyhttp.Request) 1897 if !ok { 1898 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1899 } 1900 1901 input, ok := in.Parameters.(*UpdateBackendAuthInput) 1902 _ = input 1903 if !ok { 1904 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1905 } 1906 1907 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/auth/{BackendEnvironmentName}") 1908 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1909 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1910 request.Method = "POST" 1911 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1912 if err != nil { 1913 return out, metadata, &smithy.SerializationError{Err: err} 1914 } 1915 1916 if err := awsRestjson1_serializeOpHttpBindingsUpdateBackendAuthInput(input, restEncoder); err != nil { 1917 return out, metadata, &smithy.SerializationError{Err: err} 1918 } 1919 1920 restEncoder.SetHeader("Content-Type").String("application/json") 1921 1922 jsonEncoder := smithyjson.NewEncoder() 1923 if err := awsRestjson1_serializeOpDocumentUpdateBackendAuthInput(input, jsonEncoder.Value); err != nil { 1924 return out, metadata, &smithy.SerializationError{Err: err} 1925 } 1926 1927 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1928 return out, metadata, &smithy.SerializationError{Err: err} 1929 } 1930 1931 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1932 return out, metadata, &smithy.SerializationError{Err: err} 1933 } 1934 in.Request = request 1935 1936 return next.HandleSerialize(ctx, in) 1937} 1938func awsRestjson1_serializeOpHttpBindingsUpdateBackendAuthInput(v *UpdateBackendAuthInput, encoder *httpbinding.Encoder) error { 1939 if v == nil { 1940 return fmt.Errorf("unsupported serialization of nil %T", v) 1941 } 1942 1943 if v.AppId == nil || len(*v.AppId) == 0 { 1944 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 1945 } 1946 if v.AppId != nil { 1947 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 1948 return err 1949 } 1950 } 1951 1952 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 1953 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 1954 } 1955 if v.BackendEnvironmentName != nil { 1956 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 1957 return err 1958 } 1959 } 1960 1961 return nil 1962} 1963 1964func awsRestjson1_serializeOpDocumentUpdateBackendAuthInput(v *UpdateBackendAuthInput, value smithyjson.Value) error { 1965 object := value.Object() 1966 defer object.Close() 1967 1968 if v.ResourceConfig != nil { 1969 ok := object.Key("resourceConfig") 1970 if err := awsRestjson1_serializeDocumentUpdateBackendAuthResourceConfig(v.ResourceConfig, ok); err != nil { 1971 return err 1972 } 1973 } 1974 1975 if v.ResourceName != nil { 1976 ok := object.Key("resourceName") 1977 ok.String(*v.ResourceName) 1978 } 1979 1980 return nil 1981} 1982 1983type awsRestjson1_serializeOpUpdateBackendConfig struct { 1984} 1985 1986func (*awsRestjson1_serializeOpUpdateBackendConfig) ID() string { 1987 return "OperationSerializer" 1988} 1989 1990func (m *awsRestjson1_serializeOpUpdateBackendConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1991 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1992) { 1993 request, ok := in.Request.(*smithyhttp.Request) 1994 if !ok { 1995 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1996 } 1997 1998 input, ok := in.Parameters.(*UpdateBackendConfigInput) 1999 _ = input 2000 if !ok { 2001 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2002 } 2003 2004 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/config/update") 2005 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2006 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2007 request.Method = "POST" 2008 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2009 if err != nil { 2010 return out, metadata, &smithy.SerializationError{Err: err} 2011 } 2012 2013 if err := awsRestjson1_serializeOpHttpBindingsUpdateBackendConfigInput(input, restEncoder); err != nil { 2014 return out, metadata, &smithy.SerializationError{Err: err} 2015 } 2016 2017 restEncoder.SetHeader("Content-Type").String("application/json") 2018 2019 jsonEncoder := smithyjson.NewEncoder() 2020 if err := awsRestjson1_serializeOpDocumentUpdateBackendConfigInput(input, jsonEncoder.Value); err != nil { 2021 return out, metadata, &smithy.SerializationError{Err: err} 2022 } 2023 2024 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2025 return out, metadata, &smithy.SerializationError{Err: err} 2026 } 2027 2028 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2029 return out, metadata, &smithy.SerializationError{Err: err} 2030 } 2031 in.Request = request 2032 2033 return next.HandleSerialize(ctx, in) 2034} 2035func awsRestjson1_serializeOpHttpBindingsUpdateBackendConfigInput(v *UpdateBackendConfigInput, encoder *httpbinding.Encoder) error { 2036 if v == nil { 2037 return fmt.Errorf("unsupported serialization of nil %T", v) 2038 } 2039 2040 if v.AppId == nil || len(*v.AppId) == 0 { 2041 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 2042 } 2043 if v.AppId != nil { 2044 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 2045 return err 2046 } 2047 } 2048 2049 return nil 2050} 2051 2052func awsRestjson1_serializeOpDocumentUpdateBackendConfigInput(v *UpdateBackendConfigInput, value smithyjson.Value) error { 2053 object := value.Object() 2054 defer object.Close() 2055 2056 if v.LoginAuthConfig != nil { 2057 ok := object.Key("loginAuthConfig") 2058 if err := awsRestjson1_serializeDocumentLoginAuthConfigReqObj(v.LoginAuthConfig, ok); err != nil { 2059 return err 2060 } 2061 } 2062 2063 return nil 2064} 2065 2066type awsRestjson1_serializeOpUpdateBackendJob struct { 2067} 2068 2069func (*awsRestjson1_serializeOpUpdateBackendJob) ID() string { 2070 return "OperationSerializer" 2071} 2072 2073func (m *awsRestjson1_serializeOpUpdateBackendJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2074 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2075) { 2076 request, ok := in.Request.(*smithyhttp.Request) 2077 if !ok { 2078 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2079 } 2080 2081 input, ok := in.Parameters.(*UpdateBackendJobInput) 2082 _ = input 2083 if !ok { 2084 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2085 } 2086 2087 opPath, opQuery := httpbinding.SplitURI("/backend/{AppId}/job/{BackendEnvironmentName}/{JobId}") 2088 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2089 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2090 request.Method = "POST" 2091 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2092 if err != nil { 2093 return out, metadata, &smithy.SerializationError{Err: err} 2094 } 2095 2096 if err := awsRestjson1_serializeOpHttpBindingsUpdateBackendJobInput(input, restEncoder); err != nil { 2097 return out, metadata, &smithy.SerializationError{Err: err} 2098 } 2099 2100 restEncoder.SetHeader("Content-Type").String("application/json") 2101 2102 jsonEncoder := smithyjson.NewEncoder() 2103 if err := awsRestjson1_serializeOpDocumentUpdateBackendJobInput(input, jsonEncoder.Value); err != nil { 2104 return out, metadata, &smithy.SerializationError{Err: err} 2105 } 2106 2107 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2108 return out, metadata, &smithy.SerializationError{Err: err} 2109 } 2110 2111 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2112 return out, metadata, &smithy.SerializationError{Err: err} 2113 } 2114 in.Request = request 2115 2116 return next.HandleSerialize(ctx, in) 2117} 2118func awsRestjson1_serializeOpHttpBindingsUpdateBackendJobInput(v *UpdateBackendJobInput, encoder *httpbinding.Encoder) error { 2119 if v == nil { 2120 return fmt.Errorf("unsupported serialization of nil %T", v) 2121 } 2122 2123 if v.AppId == nil || len(*v.AppId) == 0 { 2124 return &smithy.SerializationError{Err: fmt.Errorf("input member AppId must not be empty")} 2125 } 2126 if v.AppId != nil { 2127 if err := encoder.SetURI("AppId").String(*v.AppId); err != nil { 2128 return err 2129 } 2130 } 2131 2132 if v.BackendEnvironmentName == nil || len(*v.BackendEnvironmentName) == 0 { 2133 return &smithy.SerializationError{Err: fmt.Errorf("input member BackendEnvironmentName must not be empty")} 2134 } 2135 if v.BackendEnvironmentName != nil { 2136 if err := encoder.SetURI("BackendEnvironmentName").String(*v.BackendEnvironmentName); err != nil { 2137 return err 2138 } 2139 } 2140 2141 if v.JobId == nil || len(*v.JobId) == 0 { 2142 return &smithy.SerializationError{Err: fmt.Errorf("input member JobId must not be empty")} 2143 } 2144 if v.JobId != nil { 2145 if err := encoder.SetURI("JobId").String(*v.JobId); err != nil { 2146 return err 2147 } 2148 } 2149 2150 return nil 2151} 2152 2153func awsRestjson1_serializeOpDocumentUpdateBackendJobInput(v *UpdateBackendJobInput, value smithyjson.Value) error { 2154 object := value.Object() 2155 defer object.Close() 2156 2157 if v.Operation != nil { 2158 ok := object.Key("operation") 2159 ok.String(*v.Operation) 2160 } 2161 2162 if v.Status != nil { 2163 ok := object.Key("status") 2164 ok.String(*v.Status) 2165 } 2166 2167 return nil 2168} 2169 2170func awsRestjson1_serializeDocumentBackendAPIAppSyncAuthSettings(v *types.BackendAPIAppSyncAuthSettings, value smithyjson.Value) error { 2171 object := value.Object() 2172 defer object.Close() 2173 2174 if v.CognitoUserPoolId != nil { 2175 ok := object.Key("cognitoUserPoolId") 2176 ok.String(*v.CognitoUserPoolId) 2177 } 2178 2179 if v.Description != nil { 2180 ok := object.Key("description") 2181 ok.String(*v.Description) 2182 } 2183 2184 if v.ExpirationTime != 0 { 2185 ok := object.Key("expirationTime") 2186 switch { 2187 case math.IsNaN(v.ExpirationTime): 2188 ok.String("NaN") 2189 2190 case math.IsInf(v.ExpirationTime, 1): 2191 ok.String("Infinity") 2192 2193 case math.IsInf(v.ExpirationTime, -1): 2194 ok.String("-Infinity") 2195 2196 default: 2197 ok.Double(v.ExpirationTime) 2198 2199 } 2200 } 2201 2202 if v.OpenIDAuthTTL != nil { 2203 ok := object.Key("openIDAuthTTL") 2204 ok.String(*v.OpenIDAuthTTL) 2205 } 2206 2207 if v.OpenIDClientId != nil { 2208 ok := object.Key("openIDClientId") 2209 ok.String(*v.OpenIDClientId) 2210 } 2211 2212 if v.OpenIDIatTTL != nil { 2213 ok := object.Key("openIDIatTTL") 2214 ok.String(*v.OpenIDIatTTL) 2215 } 2216 2217 if v.OpenIDIssueURL != nil { 2218 ok := object.Key("openIDIssueURL") 2219 ok.String(*v.OpenIDIssueURL) 2220 } 2221 2222 if v.OpenIDProviderName != nil { 2223 ok := object.Key("openIDProviderName") 2224 ok.String(*v.OpenIDProviderName) 2225 } 2226 2227 return nil 2228} 2229 2230func awsRestjson1_serializeDocumentBackendAPIAuthType(v *types.BackendAPIAuthType, value smithyjson.Value) error { 2231 object := value.Object() 2232 defer object.Close() 2233 2234 if len(v.Mode) > 0 { 2235 ok := object.Key("mode") 2236 ok.String(string(v.Mode)) 2237 } 2238 2239 if v.Settings != nil { 2240 ok := object.Key("settings") 2241 if err := awsRestjson1_serializeDocumentBackendAPIAppSyncAuthSettings(v.Settings, ok); err != nil { 2242 return err 2243 } 2244 } 2245 2246 return nil 2247} 2248 2249func awsRestjson1_serializeDocumentBackendAPIConflictResolution(v *types.BackendAPIConflictResolution, value smithyjson.Value) error { 2250 object := value.Object() 2251 defer object.Close() 2252 2253 if len(v.ResolutionStrategy) > 0 { 2254 ok := object.Key("resolutionStrategy") 2255 ok.String(string(v.ResolutionStrategy)) 2256 } 2257 2258 return nil 2259} 2260 2261func awsRestjson1_serializeDocumentBackendAPIResourceConfig(v *types.BackendAPIResourceConfig, value smithyjson.Value) error { 2262 object := value.Object() 2263 defer object.Close() 2264 2265 if v.AdditionalAuthTypes != nil { 2266 ok := object.Key("additionalAuthTypes") 2267 if err := awsRestjson1_serializeDocumentListOfBackendAPIAuthType(v.AdditionalAuthTypes, ok); err != nil { 2268 return err 2269 } 2270 } 2271 2272 if v.ApiName != nil { 2273 ok := object.Key("apiName") 2274 ok.String(*v.ApiName) 2275 } 2276 2277 if v.ConflictResolution != nil { 2278 ok := object.Key("conflictResolution") 2279 if err := awsRestjson1_serializeDocumentBackendAPIConflictResolution(v.ConflictResolution, ok); err != nil { 2280 return err 2281 } 2282 } 2283 2284 if v.DefaultAuthType != nil { 2285 ok := object.Key("defaultAuthType") 2286 if err := awsRestjson1_serializeDocumentBackendAPIAuthType(v.DefaultAuthType, ok); err != nil { 2287 return err 2288 } 2289 } 2290 2291 if v.Service != nil { 2292 ok := object.Key("service") 2293 ok.String(*v.Service) 2294 } 2295 2296 if v.TransformSchema != nil { 2297 ok := object.Key("transformSchema") 2298 ok.String(*v.TransformSchema) 2299 } 2300 2301 return nil 2302} 2303 2304func awsRestjson1_serializeDocumentBackendAuthAppleProviderConfig(v *types.BackendAuthAppleProviderConfig, value smithyjson.Value) error { 2305 object := value.Object() 2306 defer object.Close() 2307 2308 if v.ClientId != nil { 2309 ok := object.Key("client_id") 2310 ok.String(*v.ClientId) 2311 } 2312 2313 if v.KeyId != nil { 2314 ok := object.Key("key_id") 2315 ok.String(*v.KeyId) 2316 } 2317 2318 if v.PrivateKey != nil { 2319 ok := object.Key("private_key") 2320 ok.String(*v.PrivateKey) 2321 } 2322 2323 if v.TeamId != nil { 2324 ok := object.Key("team_id") 2325 ok.String(*v.TeamId) 2326 } 2327 2328 return nil 2329} 2330 2331func awsRestjson1_serializeDocumentBackendAuthSocialProviderConfig(v *types.BackendAuthSocialProviderConfig, value smithyjson.Value) error { 2332 object := value.Object() 2333 defer object.Close() 2334 2335 if v.ClientId != nil { 2336 ok := object.Key("client_id") 2337 ok.String(*v.ClientId) 2338 } 2339 2340 if v.ClientSecret != nil { 2341 ok := object.Key("client_secret") 2342 ok.String(*v.ClientSecret) 2343 } 2344 2345 return nil 2346} 2347 2348func awsRestjson1_serializeDocumentCreateBackendAuthForgotPasswordConfig(v *types.CreateBackendAuthForgotPasswordConfig, value smithyjson.Value) error { 2349 object := value.Object() 2350 defer object.Close() 2351 2352 if len(v.DeliveryMethod) > 0 { 2353 ok := object.Key("deliveryMethod") 2354 ok.String(string(v.DeliveryMethod)) 2355 } 2356 2357 if v.EmailSettings != nil { 2358 ok := object.Key("emailSettings") 2359 if err := awsRestjson1_serializeDocumentEmailSettings(v.EmailSettings, ok); err != nil { 2360 return err 2361 } 2362 } 2363 2364 if v.SmsSettings != nil { 2365 ok := object.Key("smsSettings") 2366 if err := awsRestjson1_serializeDocumentSmsSettings(v.SmsSettings, ok); err != nil { 2367 return err 2368 } 2369 } 2370 2371 return nil 2372} 2373 2374func awsRestjson1_serializeDocumentCreateBackendAuthIdentityPoolConfig(v *types.CreateBackendAuthIdentityPoolConfig, value smithyjson.Value) error { 2375 object := value.Object() 2376 defer object.Close() 2377 2378 if v.IdentityPoolName != nil { 2379 ok := object.Key("identityPoolName") 2380 ok.String(*v.IdentityPoolName) 2381 } 2382 2383 { 2384 ok := object.Key("unauthenticatedLogin") 2385 ok.Boolean(v.UnauthenticatedLogin) 2386 } 2387 2388 return nil 2389} 2390 2391func awsRestjson1_serializeDocumentCreateBackendAuthMFAConfig(v *types.CreateBackendAuthMFAConfig, value smithyjson.Value) error { 2392 object := value.Object() 2393 defer object.Close() 2394 2395 if len(v.MFAMode) > 0 { 2396 ok := object.Key("MFAMode") 2397 ok.String(string(v.MFAMode)) 2398 } 2399 2400 if v.Settings != nil { 2401 ok := object.Key("settings") 2402 if err := awsRestjson1_serializeDocumentSettings(v.Settings, ok); err != nil { 2403 return err 2404 } 2405 } 2406 2407 return nil 2408} 2409 2410func awsRestjson1_serializeDocumentCreateBackendAuthOAuthConfig(v *types.CreateBackendAuthOAuthConfig, value smithyjson.Value) error { 2411 object := value.Object() 2412 defer object.Close() 2413 2414 if v.DomainPrefix != nil { 2415 ok := object.Key("domainPrefix") 2416 ok.String(*v.DomainPrefix) 2417 } 2418 2419 if len(v.OAuthGrantType) > 0 { 2420 ok := object.Key("oAuthGrantType") 2421 ok.String(string(v.OAuthGrantType)) 2422 } 2423 2424 if v.OAuthScopes != nil { 2425 ok := object.Key("oAuthScopes") 2426 if err := awsRestjson1_serializeDocumentListOfOAuthScopesElement(v.OAuthScopes, ok); err != nil { 2427 return err 2428 } 2429 } 2430 2431 if v.RedirectSignInURIs != nil { 2432 ok := object.Key("redirectSignInURIs") 2433 if err := awsRestjson1_serializeDocumentListOf__string(v.RedirectSignInURIs, ok); err != nil { 2434 return err 2435 } 2436 } 2437 2438 if v.RedirectSignOutURIs != nil { 2439 ok := object.Key("redirectSignOutURIs") 2440 if err := awsRestjson1_serializeDocumentListOf__string(v.RedirectSignOutURIs, ok); err != nil { 2441 return err 2442 } 2443 } 2444 2445 if v.SocialProviderSettings != nil { 2446 ok := object.Key("socialProviderSettings") 2447 if err := awsRestjson1_serializeDocumentSocialProviderSettings(v.SocialProviderSettings, ok); err != nil { 2448 return err 2449 } 2450 } 2451 2452 return nil 2453} 2454 2455func awsRestjson1_serializeDocumentCreateBackendAuthPasswordPolicyConfig(v *types.CreateBackendAuthPasswordPolicyConfig, value smithyjson.Value) error { 2456 object := value.Object() 2457 defer object.Close() 2458 2459 if v.AdditionalConstraints != nil { 2460 ok := object.Key("additionalConstraints") 2461 if err := awsRestjson1_serializeDocumentListOfAdditionalConstraintsElement(v.AdditionalConstraints, ok); err != nil { 2462 return err 2463 } 2464 } 2465 2466 { 2467 ok := object.Key("minimumLength") 2468 switch { 2469 case math.IsNaN(v.MinimumLength): 2470 ok.String("NaN") 2471 2472 case math.IsInf(v.MinimumLength, 1): 2473 ok.String("Infinity") 2474 2475 case math.IsInf(v.MinimumLength, -1): 2476 ok.String("-Infinity") 2477 2478 default: 2479 ok.Double(v.MinimumLength) 2480 2481 } 2482 } 2483 2484 return nil 2485} 2486 2487func awsRestjson1_serializeDocumentCreateBackendAuthResourceConfig(v *types.CreateBackendAuthResourceConfig, value smithyjson.Value) error { 2488 object := value.Object() 2489 defer object.Close() 2490 2491 if len(v.AuthResources) > 0 { 2492 ok := object.Key("authResources") 2493 ok.String(string(v.AuthResources)) 2494 } 2495 2496 if v.IdentityPoolConfigs != nil { 2497 ok := object.Key("identityPoolConfigs") 2498 if err := awsRestjson1_serializeDocumentCreateBackendAuthIdentityPoolConfig(v.IdentityPoolConfigs, ok); err != nil { 2499 return err 2500 } 2501 } 2502 2503 if len(v.Service) > 0 { 2504 ok := object.Key("service") 2505 ok.String(string(v.Service)) 2506 } 2507 2508 if v.UserPoolConfigs != nil { 2509 ok := object.Key("userPoolConfigs") 2510 if err := awsRestjson1_serializeDocumentCreateBackendAuthUserPoolConfig(v.UserPoolConfigs, ok); err != nil { 2511 return err 2512 } 2513 } 2514 2515 return nil 2516} 2517 2518func awsRestjson1_serializeDocumentCreateBackendAuthUserPoolConfig(v *types.CreateBackendAuthUserPoolConfig, value smithyjson.Value) error { 2519 object := value.Object() 2520 defer object.Close() 2521 2522 if v.ForgotPassword != nil { 2523 ok := object.Key("forgotPassword") 2524 if err := awsRestjson1_serializeDocumentCreateBackendAuthForgotPasswordConfig(v.ForgotPassword, ok); err != nil { 2525 return err 2526 } 2527 } 2528 2529 if v.Mfa != nil { 2530 ok := object.Key("mfa") 2531 if err := awsRestjson1_serializeDocumentCreateBackendAuthMFAConfig(v.Mfa, ok); err != nil { 2532 return err 2533 } 2534 } 2535 2536 if v.OAuth != nil { 2537 ok := object.Key("oAuth") 2538 if err := awsRestjson1_serializeDocumentCreateBackendAuthOAuthConfig(v.OAuth, ok); err != nil { 2539 return err 2540 } 2541 } 2542 2543 if v.PasswordPolicy != nil { 2544 ok := object.Key("passwordPolicy") 2545 if err := awsRestjson1_serializeDocumentCreateBackendAuthPasswordPolicyConfig(v.PasswordPolicy, ok); err != nil { 2546 return err 2547 } 2548 } 2549 2550 if v.RequiredSignUpAttributes != nil { 2551 ok := object.Key("requiredSignUpAttributes") 2552 if err := awsRestjson1_serializeDocumentListOfRequiredSignUpAttributesElement(v.RequiredSignUpAttributes, ok); err != nil { 2553 return err 2554 } 2555 } 2556 2557 if len(v.SignInMethod) > 0 { 2558 ok := object.Key("signInMethod") 2559 ok.String(string(v.SignInMethod)) 2560 } 2561 2562 if v.UserPoolName != nil { 2563 ok := object.Key("userPoolName") 2564 ok.String(*v.UserPoolName) 2565 } 2566 2567 return nil 2568} 2569 2570func awsRestjson1_serializeDocumentEmailSettings(v *types.EmailSettings, value smithyjson.Value) error { 2571 object := value.Object() 2572 defer object.Close() 2573 2574 if v.EmailMessage != nil { 2575 ok := object.Key("emailMessage") 2576 ok.String(*v.EmailMessage) 2577 } 2578 2579 if v.EmailSubject != nil { 2580 ok := object.Key("emailSubject") 2581 ok.String(*v.EmailSubject) 2582 } 2583 2584 return nil 2585} 2586 2587func awsRestjson1_serializeDocumentListOf__string(v []string, value smithyjson.Value) error { 2588 array := value.Array() 2589 defer array.Close() 2590 2591 for i := range v { 2592 av := array.Value() 2593 av.String(v[i]) 2594 } 2595 return nil 2596} 2597 2598func awsRestjson1_serializeDocumentListOfAdditionalConstraintsElement(v []types.AdditionalConstraintsElement, value smithyjson.Value) error { 2599 array := value.Array() 2600 defer array.Close() 2601 2602 for i := range v { 2603 av := array.Value() 2604 av.String(string(v[i])) 2605 } 2606 return nil 2607} 2608 2609func awsRestjson1_serializeDocumentListOfBackendAPIAuthType(v []types.BackendAPIAuthType, value smithyjson.Value) error { 2610 array := value.Array() 2611 defer array.Close() 2612 2613 for i := range v { 2614 av := array.Value() 2615 if err := awsRestjson1_serializeDocumentBackendAPIAuthType(&v[i], av); err != nil { 2616 return err 2617 } 2618 } 2619 return nil 2620} 2621 2622func awsRestjson1_serializeDocumentListOfMfaTypesElement(v []types.MfaTypesElement, value smithyjson.Value) error { 2623 array := value.Array() 2624 defer array.Close() 2625 2626 for i := range v { 2627 av := array.Value() 2628 av.String(string(v[i])) 2629 } 2630 return nil 2631} 2632 2633func awsRestjson1_serializeDocumentListOfOAuthScopesElement(v []types.OAuthScopesElement, value smithyjson.Value) error { 2634 array := value.Array() 2635 defer array.Close() 2636 2637 for i := range v { 2638 av := array.Value() 2639 av.String(string(v[i])) 2640 } 2641 return nil 2642} 2643 2644func awsRestjson1_serializeDocumentListOfRequiredSignUpAttributesElement(v []types.RequiredSignUpAttributesElement, value smithyjson.Value) error { 2645 array := value.Array() 2646 defer array.Close() 2647 2648 for i := range v { 2649 av := array.Value() 2650 av.String(string(v[i])) 2651 } 2652 return nil 2653} 2654 2655func awsRestjson1_serializeDocumentLoginAuthConfigReqObj(v *types.LoginAuthConfigReqObj, value smithyjson.Value) error { 2656 object := value.Object() 2657 defer object.Close() 2658 2659 if v.AwsCognitoIdentityPoolId != nil { 2660 ok := object.Key("aws_cognito_identity_pool_id") 2661 ok.String(*v.AwsCognitoIdentityPoolId) 2662 } 2663 2664 if v.AwsCognitoRegion != nil { 2665 ok := object.Key("aws_cognito_region") 2666 ok.String(*v.AwsCognitoRegion) 2667 } 2668 2669 if v.AwsUserPoolsId != nil { 2670 ok := object.Key("aws_user_pools_id") 2671 ok.String(*v.AwsUserPoolsId) 2672 } 2673 2674 if v.AwsUserPoolsWebClientId != nil { 2675 ok := object.Key("aws_user_pools_web_client_id") 2676 ok.String(*v.AwsUserPoolsWebClientId) 2677 } 2678 2679 return nil 2680} 2681 2682func awsRestjson1_serializeDocumentResourceConfig(v *types.ResourceConfig, value smithyjson.Value) error { 2683 object := value.Object() 2684 defer object.Close() 2685 2686 return nil 2687} 2688 2689func awsRestjson1_serializeDocumentSettings(v *types.Settings, value smithyjson.Value) error { 2690 object := value.Object() 2691 defer object.Close() 2692 2693 if v.MfaTypes != nil { 2694 ok := object.Key("mfaTypes") 2695 if err := awsRestjson1_serializeDocumentListOfMfaTypesElement(v.MfaTypes, ok); err != nil { 2696 return err 2697 } 2698 } 2699 2700 if v.SmsMessage != nil { 2701 ok := object.Key("smsMessage") 2702 ok.String(*v.SmsMessage) 2703 } 2704 2705 return nil 2706} 2707 2708func awsRestjson1_serializeDocumentSmsSettings(v *types.SmsSettings, value smithyjson.Value) error { 2709 object := value.Object() 2710 defer object.Close() 2711 2712 if v.SmsMessage != nil { 2713 ok := object.Key("smsMessage") 2714 ok.String(*v.SmsMessage) 2715 } 2716 2717 return nil 2718} 2719 2720func awsRestjson1_serializeDocumentSocialProviderSettings(v *types.SocialProviderSettings, value smithyjson.Value) error { 2721 object := value.Object() 2722 defer object.Close() 2723 2724 if v.Facebook != nil { 2725 ok := object.Key("Facebook") 2726 if err := awsRestjson1_serializeDocumentBackendAuthSocialProviderConfig(v.Facebook, ok); err != nil { 2727 return err 2728 } 2729 } 2730 2731 if v.Google != nil { 2732 ok := object.Key("Google") 2733 if err := awsRestjson1_serializeDocumentBackendAuthSocialProviderConfig(v.Google, ok); err != nil { 2734 return err 2735 } 2736 } 2737 2738 if v.LoginWithAmazon != nil { 2739 ok := object.Key("LoginWithAmazon") 2740 if err := awsRestjson1_serializeDocumentBackendAuthSocialProviderConfig(v.LoginWithAmazon, ok); err != nil { 2741 return err 2742 } 2743 } 2744 2745 if v.SignInWithApple != nil { 2746 ok := object.Key("SignInWithApple") 2747 if err := awsRestjson1_serializeDocumentBackendAuthAppleProviderConfig(v.SignInWithApple, ok); err != nil { 2748 return err 2749 } 2750 } 2751 2752 return nil 2753} 2754 2755func awsRestjson1_serializeDocumentUpdateBackendAuthForgotPasswordConfig(v *types.UpdateBackendAuthForgotPasswordConfig, value smithyjson.Value) error { 2756 object := value.Object() 2757 defer object.Close() 2758 2759 if len(v.DeliveryMethod) > 0 { 2760 ok := object.Key("deliveryMethod") 2761 ok.String(string(v.DeliveryMethod)) 2762 } 2763 2764 if v.EmailSettings != nil { 2765 ok := object.Key("emailSettings") 2766 if err := awsRestjson1_serializeDocumentEmailSettings(v.EmailSettings, ok); err != nil { 2767 return err 2768 } 2769 } 2770 2771 if v.SmsSettings != nil { 2772 ok := object.Key("smsSettings") 2773 if err := awsRestjson1_serializeDocumentSmsSettings(v.SmsSettings, ok); err != nil { 2774 return err 2775 } 2776 } 2777 2778 return nil 2779} 2780 2781func awsRestjson1_serializeDocumentUpdateBackendAuthIdentityPoolConfig(v *types.UpdateBackendAuthIdentityPoolConfig, value smithyjson.Value) error { 2782 object := value.Object() 2783 defer object.Close() 2784 2785 if v.UnauthenticatedLogin { 2786 ok := object.Key("unauthenticatedLogin") 2787 ok.Boolean(v.UnauthenticatedLogin) 2788 } 2789 2790 return nil 2791} 2792 2793func awsRestjson1_serializeDocumentUpdateBackendAuthMFAConfig(v *types.UpdateBackendAuthMFAConfig, value smithyjson.Value) error { 2794 object := value.Object() 2795 defer object.Close() 2796 2797 if len(v.MFAMode) > 0 { 2798 ok := object.Key("MFAMode") 2799 ok.String(string(v.MFAMode)) 2800 } 2801 2802 if v.Settings != nil { 2803 ok := object.Key("settings") 2804 if err := awsRestjson1_serializeDocumentSettings(v.Settings, ok); err != nil { 2805 return err 2806 } 2807 } 2808 2809 return nil 2810} 2811 2812func awsRestjson1_serializeDocumentUpdateBackendAuthOAuthConfig(v *types.UpdateBackendAuthOAuthConfig, value smithyjson.Value) error { 2813 object := value.Object() 2814 defer object.Close() 2815 2816 if v.DomainPrefix != nil { 2817 ok := object.Key("domainPrefix") 2818 ok.String(*v.DomainPrefix) 2819 } 2820 2821 if len(v.OAuthGrantType) > 0 { 2822 ok := object.Key("oAuthGrantType") 2823 ok.String(string(v.OAuthGrantType)) 2824 } 2825 2826 if v.OAuthScopes != nil { 2827 ok := object.Key("oAuthScopes") 2828 if err := awsRestjson1_serializeDocumentListOfOAuthScopesElement(v.OAuthScopes, ok); err != nil { 2829 return err 2830 } 2831 } 2832 2833 if v.RedirectSignInURIs != nil { 2834 ok := object.Key("redirectSignInURIs") 2835 if err := awsRestjson1_serializeDocumentListOf__string(v.RedirectSignInURIs, ok); err != nil { 2836 return err 2837 } 2838 } 2839 2840 if v.RedirectSignOutURIs != nil { 2841 ok := object.Key("redirectSignOutURIs") 2842 if err := awsRestjson1_serializeDocumentListOf__string(v.RedirectSignOutURIs, ok); err != nil { 2843 return err 2844 } 2845 } 2846 2847 if v.SocialProviderSettings != nil { 2848 ok := object.Key("socialProviderSettings") 2849 if err := awsRestjson1_serializeDocumentSocialProviderSettings(v.SocialProviderSettings, ok); err != nil { 2850 return err 2851 } 2852 } 2853 2854 return nil 2855} 2856 2857func awsRestjson1_serializeDocumentUpdateBackendAuthPasswordPolicyConfig(v *types.UpdateBackendAuthPasswordPolicyConfig, value smithyjson.Value) error { 2858 object := value.Object() 2859 defer object.Close() 2860 2861 if v.AdditionalConstraints != nil { 2862 ok := object.Key("additionalConstraints") 2863 if err := awsRestjson1_serializeDocumentListOfAdditionalConstraintsElement(v.AdditionalConstraints, ok); err != nil { 2864 return err 2865 } 2866 } 2867 2868 if v.MinimumLength != 0 { 2869 ok := object.Key("minimumLength") 2870 switch { 2871 case math.IsNaN(v.MinimumLength): 2872 ok.String("NaN") 2873 2874 case math.IsInf(v.MinimumLength, 1): 2875 ok.String("Infinity") 2876 2877 case math.IsInf(v.MinimumLength, -1): 2878 ok.String("-Infinity") 2879 2880 default: 2881 ok.Double(v.MinimumLength) 2882 2883 } 2884 } 2885 2886 return nil 2887} 2888 2889func awsRestjson1_serializeDocumentUpdateBackendAuthResourceConfig(v *types.UpdateBackendAuthResourceConfig, value smithyjson.Value) error { 2890 object := value.Object() 2891 defer object.Close() 2892 2893 if len(v.AuthResources) > 0 { 2894 ok := object.Key("authResources") 2895 ok.String(string(v.AuthResources)) 2896 } 2897 2898 if v.IdentityPoolConfigs != nil { 2899 ok := object.Key("identityPoolConfigs") 2900 if err := awsRestjson1_serializeDocumentUpdateBackendAuthIdentityPoolConfig(v.IdentityPoolConfigs, ok); err != nil { 2901 return err 2902 } 2903 } 2904 2905 if len(v.Service) > 0 { 2906 ok := object.Key("service") 2907 ok.String(string(v.Service)) 2908 } 2909 2910 if v.UserPoolConfigs != nil { 2911 ok := object.Key("userPoolConfigs") 2912 if err := awsRestjson1_serializeDocumentUpdateBackendAuthUserPoolConfig(v.UserPoolConfigs, ok); err != nil { 2913 return err 2914 } 2915 } 2916 2917 return nil 2918} 2919 2920func awsRestjson1_serializeDocumentUpdateBackendAuthUserPoolConfig(v *types.UpdateBackendAuthUserPoolConfig, value smithyjson.Value) error { 2921 object := value.Object() 2922 defer object.Close() 2923 2924 if v.ForgotPassword != nil { 2925 ok := object.Key("forgotPassword") 2926 if err := awsRestjson1_serializeDocumentUpdateBackendAuthForgotPasswordConfig(v.ForgotPassword, ok); err != nil { 2927 return err 2928 } 2929 } 2930 2931 if v.Mfa != nil { 2932 ok := object.Key("mfa") 2933 if err := awsRestjson1_serializeDocumentUpdateBackendAuthMFAConfig(v.Mfa, ok); err != nil { 2934 return err 2935 } 2936 } 2937 2938 if v.OAuth != nil { 2939 ok := object.Key("oAuth") 2940 if err := awsRestjson1_serializeDocumentUpdateBackendAuthOAuthConfig(v.OAuth, ok); err != nil { 2941 return err 2942 } 2943 } 2944 2945 if v.PasswordPolicy != nil { 2946 ok := object.Key("passwordPolicy") 2947 if err := awsRestjson1_serializeDocumentUpdateBackendAuthPasswordPolicyConfig(v.PasswordPolicy, ok); err != nil { 2948 return err 2949 } 2950 } 2951 2952 return nil 2953} 2954