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