1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package workspaces 4 5import ( 6 "bytes" 7 "context" 8 "encoding/json" 9 "fmt" 10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 11 "github.com/aws/aws-sdk-go-v2/service/workspaces/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsAwsjson11_deserializeOpAssociateConnectionAlias struct { 23} 24 25func (*awsAwsjson11_deserializeOpAssociateConnectionAlias) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAssociateConnectionAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateConnectionAlias(response, &metadata) 44 } 45 output := &AssociateConnectionAliasOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentAssociateConnectionAliasOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorAssociateConnectionAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("AccessDeniedException", errorCode): 121 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 122 123 case strings.EqualFold("InvalidParameterValuesException", errorCode): 124 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 125 126 case strings.EqualFold("InvalidResourceStateException", errorCode): 127 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 128 129 case strings.EqualFold("OperationNotSupportedException", errorCode): 130 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 131 132 case strings.EqualFold("ResourceAssociatedException", errorCode): 133 return awsAwsjson11_deserializeErrorResourceAssociatedException(response, errorBody) 134 135 case strings.EqualFold("ResourceNotFoundException", errorCode): 136 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 137 138 default: 139 genericError := &smithy.GenericAPIError{ 140 Code: errorCode, 141 Message: errorMessage, 142 } 143 return genericError 144 145 } 146} 147 148type awsAwsjson11_deserializeOpAssociateIpGroups struct { 149} 150 151func (*awsAwsjson11_deserializeOpAssociateIpGroups) ID() string { 152 return "OperationDeserializer" 153} 154 155func (m *awsAwsjson11_deserializeOpAssociateIpGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 156 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 157) { 158 out, metadata, err = next.HandleDeserialize(ctx, in) 159 if err != nil { 160 return out, metadata, err 161 } 162 163 response, ok := out.RawResponse.(*smithyhttp.Response) 164 if !ok { 165 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 166 } 167 168 if response.StatusCode < 200 || response.StatusCode >= 300 { 169 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateIpGroups(response, &metadata) 170 } 171 output := &AssociateIpGroupsOutput{} 172 out.Result = output 173 174 var buff [1024]byte 175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 176 177 body := io.TeeReader(response.Body, ringBuffer) 178 decoder := json.NewDecoder(body) 179 decoder.UseNumber() 180 var shape interface{} 181 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 182 var snapshot bytes.Buffer 183 io.Copy(&snapshot, ringBuffer) 184 err = &smithy.DeserializationError{ 185 Err: fmt.Errorf("failed to decode response body, %w", err), 186 Snapshot: snapshot.Bytes(), 187 } 188 return out, metadata, err 189 } 190 191 err = awsAwsjson11_deserializeOpDocumentAssociateIpGroupsOutput(&output, shape) 192 if err != nil { 193 var snapshot bytes.Buffer 194 io.Copy(&snapshot, ringBuffer) 195 err = &smithy.DeserializationError{ 196 Err: fmt.Errorf("failed to decode response body, %w", err), 197 Snapshot: snapshot.Bytes(), 198 } 199 return out, metadata, err 200 } 201 202 return out, metadata, err 203} 204 205func awsAwsjson11_deserializeOpErrorAssociateIpGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 206 var errorBuffer bytes.Buffer 207 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 208 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 209 } 210 errorBody := bytes.NewReader(errorBuffer.Bytes()) 211 212 errorCode := "UnknownError" 213 errorMessage := errorCode 214 215 code := response.Header.Get("X-Amzn-ErrorType") 216 if len(code) != 0 { 217 errorCode = restjson.SanitizeErrorCode(code) 218 } 219 220 var buff [1024]byte 221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 222 223 body := io.TeeReader(errorBody, ringBuffer) 224 decoder := json.NewDecoder(body) 225 decoder.UseNumber() 226 code, message, err := restjson.GetErrorInfo(decoder) 227 if err != nil { 228 var snapshot bytes.Buffer 229 io.Copy(&snapshot, ringBuffer) 230 err = &smithy.DeserializationError{ 231 Err: fmt.Errorf("failed to decode response body, %w", err), 232 Snapshot: snapshot.Bytes(), 233 } 234 return err 235 } 236 237 errorBody.Seek(0, io.SeekStart) 238 if len(code) != 0 { 239 errorCode = restjson.SanitizeErrorCode(code) 240 } 241 if len(message) != 0 { 242 errorMessage = message 243 } 244 245 switch { 246 case strings.EqualFold("AccessDeniedException", errorCode): 247 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 248 249 case strings.EqualFold("InvalidParameterValuesException", errorCode): 250 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 251 252 case strings.EqualFold("InvalidResourceStateException", errorCode): 253 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 254 255 case strings.EqualFold("OperationNotSupportedException", errorCode): 256 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 257 258 case strings.EqualFold("ResourceLimitExceededException", errorCode): 259 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 260 261 case strings.EqualFold("ResourceNotFoundException", errorCode): 262 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 263 264 default: 265 genericError := &smithy.GenericAPIError{ 266 Code: errorCode, 267 Message: errorMessage, 268 } 269 return genericError 270 271 } 272} 273 274type awsAwsjson11_deserializeOpAuthorizeIpRules struct { 275} 276 277func (*awsAwsjson11_deserializeOpAuthorizeIpRules) ID() string { 278 return "OperationDeserializer" 279} 280 281func (m *awsAwsjson11_deserializeOpAuthorizeIpRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 282 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 283) { 284 out, metadata, err = next.HandleDeserialize(ctx, in) 285 if err != nil { 286 return out, metadata, err 287 } 288 289 response, ok := out.RawResponse.(*smithyhttp.Response) 290 if !ok { 291 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 292 } 293 294 if response.StatusCode < 200 || response.StatusCode >= 300 { 295 return out, metadata, awsAwsjson11_deserializeOpErrorAuthorizeIpRules(response, &metadata) 296 } 297 output := &AuthorizeIpRulesOutput{} 298 out.Result = output 299 300 var buff [1024]byte 301 ringBuffer := smithyio.NewRingBuffer(buff[:]) 302 303 body := io.TeeReader(response.Body, ringBuffer) 304 decoder := json.NewDecoder(body) 305 decoder.UseNumber() 306 var shape interface{} 307 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 308 var snapshot bytes.Buffer 309 io.Copy(&snapshot, ringBuffer) 310 err = &smithy.DeserializationError{ 311 Err: fmt.Errorf("failed to decode response body, %w", err), 312 Snapshot: snapshot.Bytes(), 313 } 314 return out, metadata, err 315 } 316 317 err = awsAwsjson11_deserializeOpDocumentAuthorizeIpRulesOutput(&output, shape) 318 if err != nil { 319 var snapshot bytes.Buffer 320 io.Copy(&snapshot, ringBuffer) 321 err = &smithy.DeserializationError{ 322 Err: fmt.Errorf("failed to decode response body, %w", err), 323 Snapshot: snapshot.Bytes(), 324 } 325 return out, metadata, err 326 } 327 328 return out, metadata, err 329} 330 331func awsAwsjson11_deserializeOpErrorAuthorizeIpRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { 332 var errorBuffer bytes.Buffer 333 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 334 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 335 } 336 errorBody := bytes.NewReader(errorBuffer.Bytes()) 337 338 errorCode := "UnknownError" 339 errorMessage := errorCode 340 341 code := response.Header.Get("X-Amzn-ErrorType") 342 if len(code) != 0 { 343 errorCode = restjson.SanitizeErrorCode(code) 344 } 345 346 var buff [1024]byte 347 ringBuffer := smithyio.NewRingBuffer(buff[:]) 348 349 body := io.TeeReader(errorBody, ringBuffer) 350 decoder := json.NewDecoder(body) 351 decoder.UseNumber() 352 code, message, err := restjson.GetErrorInfo(decoder) 353 if err != nil { 354 var snapshot bytes.Buffer 355 io.Copy(&snapshot, ringBuffer) 356 err = &smithy.DeserializationError{ 357 Err: fmt.Errorf("failed to decode response body, %w", err), 358 Snapshot: snapshot.Bytes(), 359 } 360 return err 361 } 362 363 errorBody.Seek(0, io.SeekStart) 364 if len(code) != 0 { 365 errorCode = restjson.SanitizeErrorCode(code) 366 } 367 if len(message) != 0 { 368 errorMessage = message 369 } 370 371 switch { 372 case strings.EqualFold("AccessDeniedException", errorCode): 373 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 374 375 case strings.EqualFold("InvalidParameterValuesException", errorCode): 376 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 377 378 case strings.EqualFold("InvalidResourceStateException", errorCode): 379 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 380 381 case strings.EqualFold("ResourceLimitExceededException", errorCode): 382 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 383 384 case strings.EqualFold("ResourceNotFoundException", errorCode): 385 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 386 387 default: 388 genericError := &smithy.GenericAPIError{ 389 Code: errorCode, 390 Message: errorMessage, 391 } 392 return genericError 393 394 } 395} 396 397type awsAwsjson11_deserializeOpCopyWorkspaceImage struct { 398} 399 400func (*awsAwsjson11_deserializeOpCopyWorkspaceImage) ID() string { 401 return "OperationDeserializer" 402} 403 404func (m *awsAwsjson11_deserializeOpCopyWorkspaceImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 405 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 406) { 407 out, metadata, err = next.HandleDeserialize(ctx, in) 408 if err != nil { 409 return out, metadata, err 410 } 411 412 response, ok := out.RawResponse.(*smithyhttp.Response) 413 if !ok { 414 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 415 } 416 417 if response.StatusCode < 200 || response.StatusCode >= 300 { 418 return out, metadata, awsAwsjson11_deserializeOpErrorCopyWorkspaceImage(response, &metadata) 419 } 420 output := &CopyWorkspaceImageOutput{} 421 out.Result = output 422 423 var buff [1024]byte 424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 425 426 body := io.TeeReader(response.Body, ringBuffer) 427 decoder := json.NewDecoder(body) 428 decoder.UseNumber() 429 var shape interface{} 430 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 431 var snapshot bytes.Buffer 432 io.Copy(&snapshot, ringBuffer) 433 err = &smithy.DeserializationError{ 434 Err: fmt.Errorf("failed to decode response body, %w", err), 435 Snapshot: snapshot.Bytes(), 436 } 437 return out, metadata, err 438 } 439 440 err = awsAwsjson11_deserializeOpDocumentCopyWorkspaceImageOutput(&output, shape) 441 if err != nil { 442 var snapshot bytes.Buffer 443 io.Copy(&snapshot, ringBuffer) 444 err = &smithy.DeserializationError{ 445 Err: fmt.Errorf("failed to decode response body, %w", err), 446 Snapshot: snapshot.Bytes(), 447 } 448 return out, metadata, err 449 } 450 451 return out, metadata, err 452} 453 454func awsAwsjson11_deserializeOpErrorCopyWorkspaceImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 455 var errorBuffer bytes.Buffer 456 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 457 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 458 } 459 errorBody := bytes.NewReader(errorBuffer.Bytes()) 460 461 errorCode := "UnknownError" 462 errorMessage := errorCode 463 464 code := response.Header.Get("X-Amzn-ErrorType") 465 if len(code) != 0 { 466 errorCode = restjson.SanitizeErrorCode(code) 467 } 468 469 var buff [1024]byte 470 ringBuffer := smithyio.NewRingBuffer(buff[:]) 471 472 body := io.TeeReader(errorBody, ringBuffer) 473 decoder := json.NewDecoder(body) 474 decoder.UseNumber() 475 code, message, err := restjson.GetErrorInfo(decoder) 476 if err != nil { 477 var snapshot bytes.Buffer 478 io.Copy(&snapshot, ringBuffer) 479 err = &smithy.DeserializationError{ 480 Err: fmt.Errorf("failed to decode response body, %w", err), 481 Snapshot: snapshot.Bytes(), 482 } 483 return err 484 } 485 486 errorBody.Seek(0, io.SeekStart) 487 if len(code) != 0 { 488 errorCode = restjson.SanitizeErrorCode(code) 489 } 490 if len(message) != 0 { 491 errorMessage = message 492 } 493 494 switch { 495 case strings.EqualFold("AccessDeniedException", errorCode): 496 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 497 498 case strings.EqualFold("InvalidParameterValuesException", errorCode): 499 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 500 501 case strings.EqualFold("OperationNotSupportedException", errorCode): 502 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 503 504 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 505 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 506 507 case strings.EqualFold("ResourceLimitExceededException", errorCode): 508 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 509 510 case strings.EqualFold("ResourceNotFoundException", errorCode): 511 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 512 513 case strings.EqualFold("ResourceUnavailableException", errorCode): 514 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 515 516 default: 517 genericError := &smithy.GenericAPIError{ 518 Code: errorCode, 519 Message: errorMessage, 520 } 521 return genericError 522 523 } 524} 525 526type awsAwsjson11_deserializeOpCreateConnectionAlias struct { 527} 528 529func (*awsAwsjson11_deserializeOpCreateConnectionAlias) ID() string { 530 return "OperationDeserializer" 531} 532 533func (m *awsAwsjson11_deserializeOpCreateConnectionAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 534 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 535) { 536 out, metadata, err = next.HandleDeserialize(ctx, in) 537 if err != nil { 538 return out, metadata, err 539 } 540 541 response, ok := out.RawResponse.(*smithyhttp.Response) 542 if !ok { 543 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 544 } 545 546 if response.StatusCode < 200 || response.StatusCode >= 300 { 547 return out, metadata, awsAwsjson11_deserializeOpErrorCreateConnectionAlias(response, &metadata) 548 } 549 output := &CreateConnectionAliasOutput{} 550 out.Result = output 551 552 var buff [1024]byte 553 ringBuffer := smithyio.NewRingBuffer(buff[:]) 554 555 body := io.TeeReader(response.Body, ringBuffer) 556 decoder := json.NewDecoder(body) 557 decoder.UseNumber() 558 var shape interface{} 559 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 560 var snapshot bytes.Buffer 561 io.Copy(&snapshot, ringBuffer) 562 err = &smithy.DeserializationError{ 563 Err: fmt.Errorf("failed to decode response body, %w", err), 564 Snapshot: snapshot.Bytes(), 565 } 566 return out, metadata, err 567 } 568 569 err = awsAwsjson11_deserializeOpDocumentCreateConnectionAliasOutput(&output, shape) 570 if err != nil { 571 var snapshot bytes.Buffer 572 io.Copy(&snapshot, ringBuffer) 573 err = &smithy.DeserializationError{ 574 Err: fmt.Errorf("failed to decode response body, %w", err), 575 Snapshot: snapshot.Bytes(), 576 } 577 return out, metadata, err 578 } 579 580 return out, metadata, err 581} 582 583func awsAwsjson11_deserializeOpErrorCreateConnectionAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 584 var errorBuffer bytes.Buffer 585 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 586 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 587 } 588 errorBody := bytes.NewReader(errorBuffer.Bytes()) 589 590 errorCode := "UnknownError" 591 errorMessage := errorCode 592 593 code := response.Header.Get("X-Amzn-ErrorType") 594 if len(code) != 0 { 595 errorCode = restjson.SanitizeErrorCode(code) 596 } 597 598 var buff [1024]byte 599 ringBuffer := smithyio.NewRingBuffer(buff[:]) 600 601 body := io.TeeReader(errorBody, ringBuffer) 602 decoder := json.NewDecoder(body) 603 decoder.UseNumber() 604 code, message, err := restjson.GetErrorInfo(decoder) 605 if err != nil { 606 var snapshot bytes.Buffer 607 io.Copy(&snapshot, ringBuffer) 608 err = &smithy.DeserializationError{ 609 Err: fmt.Errorf("failed to decode response body, %w", err), 610 Snapshot: snapshot.Bytes(), 611 } 612 return err 613 } 614 615 errorBody.Seek(0, io.SeekStart) 616 if len(code) != 0 { 617 errorCode = restjson.SanitizeErrorCode(code) 618 } 619 if len(message) != 0 { 620 errorMessage = message 621 } 622 623 switch { 624 case strings.EqualFold("AccessDeniedException", errorCode): 625 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 626 627 case strings.EqualFold("InvalidParameterValuesException", errorCode): 628 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 629 630 case strings.EqualFold("InvalidResourceStateException", errorCode): 631 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 632 633 case strings.EqualFold("OperationNotSupportedException", errorCode): 634 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 635 636 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 637 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 638 639 case strings.EqualFold("ResourceLimitExceededException", errorCode): 640 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 641 642 default: 643 genericError := &smithy.GenericAPIError{ 644 Code: errorCode, 645 Message: errorMessage, 646 } 647 return genericError 648 649 } 650} 651 652type awsAwsjson11_deserializeOpCreateIpGroup struct { 653} 654 655func (*awsAwsjson11_deserializeOpCreateIpGroup) ID() string { 656 return "OperationDeserializer" 657} 658 659func (m *awsAwsjson11_deserializeOpCreateIpGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 660 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 661) { 662 out, metadata, err = next.HandleDeserialize(ctx, in) 663 if err != nil { 664 return out, metadata, err 665 } 666 667 response, ok := out.RawResponse.(*smithyhttp.Response) 668 if !ok { 669 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 670 } 671 672 if response.StatusCode < 200 || response.StatusCode >= 300 { 673 return out, metadata, awsAwsjson11_deserializeOpErrorCreateIpGroup(response, &metadata) 674 } 675 output := &CreateIpGroupOutput{} 676 out.Result = output 677 678 var buff [1024]byte 679 ringBuffer := smithyio.NewRingBuffer(buff[:]) 680 681 body := io.TeeReader(response.Body, ringBuffer) 682 decoder := json.NewDecoder(body) 683 decoder.UseNumber() 684 var shape interface{} 685 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 686 var snapshot bytes.Buffer 687 io.Copy(&snapshot, ringBuffer) 688 err = &smithy.DeserializationError{ 689 Err: fmt.Errorf("failed to decode response body, %w", err), 690 Snapshot: snapshot.Bytes(), 691 } 692 return out, metadata, err 693 } 694 695 err = awsAwsjson11_deserializeOpDocumentCreateIpGroupOutput(&output, shape) 696 if err != nil { 697 var snapshot bytes.Buffer 698 io.Copy(&snapshot, ringBuffer) 699 err = &smithy.DeserializationError{ 700 Err: fmt.Errorf("failed to decode response body, %w", err), 701 Snapshot: snapshot.Bytes(), 702 } 703 return out, metadata, err 704 } 705 706 return out, metadata, err 707} 708 709func awsAwsjson11_deserializeOpErrorCreateIpGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 710 var errorBuffer bytes.Buffer 711 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 712 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 713 } 714 errorBody := bytes.NewReader(errorBuffer.Bytes()) 715 716 errorCode := "UnknownError" 717 errorMessage := errorCode 718 719 code := response.Header.Get("X-Amzn-ErrorType") 720 if len(code) != 0 { 721 errorCode = restjson.SanitizeErrorCode(code) 722 } 723 724 var buff [1024]byte 725 ringBuffer := smithyio.NewRingBuffer(buff[:]) 726 727 body := io.TeeReader(errorBody, ringBuffer) 728 decoder := json.NewDecoder(body) 729 decoder.UseNumber() 730 code, message, err := restjson.GetErrorInfo(decoder) 731 if err != nil { 732 var snapshot bytes.Buffer 733 io.Copy(&snapshot, ringBuffer) 734 err = &smithy.DeserializationError{ 735 Err: fmt.Errorf("failed to decode response body, %w", err), 736 Snapshot: snapshot.Bytes(), 737 } 738 return err 739 } 740 741 errorBody.Seek(0, io.SeekStart) 742 if len(code) != 0 { 743 errorCode = restjson.SanitizeErrorCode(code) 744 } 745 if len(message) != 0 { 746 errorMessage = message 747 } 748 749 switch { 750 case strings.EqualFold("AccessDeniedException", errorCode): 751 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 752 753 case strings.EqualFold("InvalidParameterValuesException", errorCode): 754 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 755 756 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 757 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 758 759 case strings.EqualFold("ResourceCreationFailedException", errorCode): 760 return awsAwsjson11_deserializeErrorResourceCreationFailedException(response, errorBody) 761 762 case strings.EqualFold("ResourceLimitExceededException", errorCode): 763 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 764 765 default: 766 genericError := &smithy.GenericAPIError{ 767 Code: errorCode, 768 Message: errorMessage, 769 } 770 return genericError 771 772 } 773} 774 775type awsAwsjson11_deserializeOpCreateTags struct { 776} 777 778func (*awsAwsjson11_deserializeOpCreateTags) ID() string { 779 return "OperationDeserializer" 780} 781 782func (m *awsAwsjson11_deserializeOpCreateTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 783 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 784) { 785 out, metadata, err = next.HandleDeserialize(ctx, in) 786 if err != nil { 787 return out, metadata, err 788 } 789 790 response, ok := out.RawResponse.(*smithyhttp.Response) 791 if !ok { 792 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 793 } 794 795 if response.StatusCode < 200 || response.StatusCode >= 300 { 796 return out, metadata, awsAwsjson11_deserializeOpErrorCreateTags(response, &metadata) 797 } 798 output := &CreateTagsOutput{} 799 out.Result = output 800 801 var buff [1024]byte 802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 803 804 body := io.TeeReader(response.Body, ringBuffer) 805 decoder := json.NewDecoder(body) 806 decoder.UseNumber() 807 var shape interface{} 808 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 809 var snapshot bytes.Buffer 810 io.Copy(&snapshot, ringBuffer) 811 err = &smithy.DeserializationError{ 812 Err: fmt.Errorf("failed to decode response body, %w", err), 813 Snapshot: snapshot.Bytes(), 814 } 815 return out, metadata, err 816 } 817 818 err = awsAwsjson11_deserializeOpDocumentCreateTagsOutput(&output, shape) 819 if err != nil { 820 var snapshot bytes.Buffer 821 io.Copy(&snapshot, ringBuffer) 822 err = &smithy.DeserializationError{ 823 Err: fmt.Errorf("failed to decode response body, %w", err), 824 Snapshot: snapshot.Bytes(), 825 } 826 return out, metadata, err 827 } 828 829 return out, metadata, err 830} 831 832func awsAwsjson11_deserializeOpErrorCreateTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 833 var errorBuffer bytes.Buffer 834 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 835 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 836 } 837 errorBody := bytes.NewReader(errorBuffer.Bytes()) 838 839 errorCode := "UnknownError" 840 errorMessage := errorCode 841 842 code := response.Header.Get("X-Amzn-ErrorType") 843 if len(code) != 0 { 844 errorCode = restjson.SanitizeErrorCode(code) 845 } 846 847 var buff [1024]byte 848 ringBuffer := smithyio.NewRingBuffer(buff[:]) 849 850 body := io.TeeReader(errorBody, ringBuffer) 851 decoder := json.NewDecoder(body) 852 decoder.UseNumber() 853 code, message, err := restjson.GetErrorInfo(decoder) 854 if err != nil { 855 var snapshot bytes.Buffer 856 io.Copy(&snapshot, ringBuffer) 857 err = &smithy.DeserializationError{ 858 Err: fmt.Errorf("failed to decode response body, %w", err), 859 Snapshot: snapshot.Bytes(), 860 } 861 return err 862 } 863 864 errorBody.Seek(0, io.SeekStart) 865 if len(code) != 0 { 866 errorCode = restjson.SanitizeErrorCode(code) 867 } 868 if len(message) != 0 { 869 errorMessage = message 870 } 871 872 switch { 873 case strings.EqualFold("InvalidParameterValuesException", errorCode): 874 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 875 876 case strings.EqualFold("ResourceLimitExceededException", errorCode): 877 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 878 879 case strings.EqualFold("ResourceNotFoundException", errorCode): 880 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 881 882 default: 883 genericError := &smithy.GenericAPIError{ 884 Code: errorCode, 885 Message: errorMessage, 886 } 887 return genericError 888 889 } 890} 891 892type awsAwsjson11_deserializeOpCreateWorkspaceBundle struct { 893} 894 895func (*awsAwsjson11_deserializeOpCreateWorkspaceBundle) ID() string { 896 return "OperationDeserializer" 897} 898 899func (m *awsAwsjson11_deserializeOpCreateWorkspaceBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 900 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 901) { 902 out, metadata, err = next.HandleDeserialize(ctx, in) 903 if err != nil { 904 return out, metadata, err 905 } 906 907 response, ok := out.RawResponse.(*smithyhttp.Response) 908 if !ok { 909 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 910 } 911 912 if response.StatusCode < 200 || response.StatusCode >= 300 { 913 return out, metadata, awsAwsjson11_deserializeOpErrorCreateWorkspaceBundle(response, &metadata) 914 } 915 output := &CreateWorkspaceBundleOutput{} 916 out.Result = output 917 918 var buff [1024]byte 919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 920 921 body := io.TeeReader(response.Body, ringBuffer) 922 decoder := json.NewDecoder(body) 923 decoder.UseNumber() 924 var shape interface{} 925 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 926 var snapshot bytes.Buffer 927 io.Copy(&snapshot, ringBuffer) 928 err = &smithy.DeserializationError{ 929 Err: fmt.Errorf("failed to decode response body, %w", err), 930 Snapshot: snapshot.Bytes(), 931 } 932 return out, metadata, err 933 } 934 935 err = awsAwsjson11_deserializeOpDocumentCreateWorkspaceBundleOutput(&output, shape) 936 if err != nil { 937 var snapshot bytes.Buffer 938 io.Copy(&snapshot, ringBuffer) 939 err = &smithy.DeserializationError{ 940 Err: fmt.Errorf("failed to decode response body, %w", err), 941 Snapshot: snapshot.Bytes(), 942 } 943 return out, metadata, err 944 } 945 946 return out, metadata, err 947} 948 949func awsAwsjson11_deserializeOpErrorCreateWorkspaceBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error { 950 var errorBuffer bytes.Buffer 951 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 952 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 953 } 954 errorBody := bytes.NewReader(errorBuffer.Bytes()) 955 956 errorCode := "UnknownError" 957 errorMessage := errorCode 958 959 code := response.Header.Get("X-Amzn-ErrorType") 960 if len(code) != 0 { 961 errorCode = restjson.SanitizeErrorCode(code) 962 } 963 964 var buff [1024]byte 965 ringBuffer := smithyio.NewRingBuffer(buff[:]) 966 967 body := io.TeeReader(errorBody, ringBuffer) 968 decoder := json.NewDecoder(body) 969 decoder.UseNumber() 970 code, message, err := restjson.GetErrorInfo(decoder) 971 if err != nil { 972 var snapshot bytes.Buffer 973 io.Copy(&snapshot, ringBuffer) 974 err = &smithy.DeserializationError{ 975 Err: fmt.Errorf("failed to decode response body, %w", err), 976 Snapshot: snapshot.Bytes(), 977 } 978 return err 979 } 980 981 errorBody.Seek(0, io.SeekStart) 982 if len(code) != 0 { 983 errorCode = restjson.SanitizeErrorCode(code) 984 } 985 if len(message) != 0 { 986 errorMessage = message 987 } 988 989 switch { 990 case strings.EqualFold("AccessDeniedException", errorCode): 991 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 992 993 case strings.EqualFold("InvalidParameterValuesException", errorCode): 994 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 995 996 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 997 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 998 999 case strings.EqualFold("ResourceLimitExceededException", errorCode): 1000 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 1001 1002 case strings.EqualFold("ResourceNotFoundException", errorCode): 1003 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1004 1005 case strings.EqualFold("ResourceUnavailableException", errorCode): 1006 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 1007 1008 default: 1009 genericError := &smithy.GenericAPIError{ 1010 Code: errorCode, 1011 Message: errorMessage, 1012 } 1013 return genericError 1014 1015 } 1016} 1017 1018type awsAwsjson11_deserializeOpCreateWorkspaces struct { 1019} 1020 1021func (*awsAwsjson11_deserializeOpCreateWorkspaces) ID() string { 1022 return "OperationDeserializer" 1023} 1024 1025func (m *awsAwsjson11_deserializeOpCreateWorkspaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1026 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1027) { 1028 out, metadata, err = next.HandleDeserialize(ctx, in) 1029 if err != nil { 1030 return out, metadata, err 1031 } 1032 1033 response, ok := out.RawResponse.(*smithyhttp.Response) 1034 if !ok { 1035 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1036 } 1037 1038 if response.StatusCode < 200 || response.StatusCode >= 300 { 1039 return out, metadata, awsAwsjson11_deserializeOpErrorCreateWorkspaces(response, &metadata) 1040 } 1041 output := &CreateWorkspacesOutput{} 1042 out.Result = output 1043 1044 var buff [1024]byte 1045 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1046 1047 body := io.TeeReader(response.Body, ringBuffer) 1048 decoder := json.NewDecoder(body) 1049 decoder.UseNumber() 1050 var shape interface{} 1051 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1052 var snapshot bytes.Buffer 1053 io.Copy(&snapshot, ringBuffer) 1054 err = &smithy.DeserializationError{ 1055 Err: fmt.Errorf("failed to decode response body, %w", err), 1056 Snapshot: snapshot.Bytes(), 1057 } 1058 return out, metadata, err 1059 } 1060 1061 err = awsAwsjson11_deserializeOpDocumentCreateWorkspacesOutput(&output, shape) 1062 if err != nil { 1063 var snapshot bytes.Buffer 1064 io.Copy(&snapshot, ringBuffer) 1065 err = &smithy.DeserializationError{ 1066 Err: fmt.Errorf("failed to decode response body, %w", err), 1067 Snapshot: snapshot.Bytes(), 1068 } 1069 return out, metadata, err 1070 } 1071 1072 return out, metadata, err 1073} 1074 1075func awsAwsjson11_deserializeOpErrorCreateWorkspaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1076 var errorBuffer bytes.Buffer 1077 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1078 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1079 } 1080 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1081 1082 errorCode := "UnknownError" 1083 errorMessage := errorCode 1084 1085 code := response.Header.Get("X-Amzn-ErrorType") 1086 if len(code) != 0 { 1087 errorCode = restjson.SanitizeErrorCode(code) 1088 } 1089 1090 var buff [1024]byte 1091 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1092 1093 body := io.TeeReader(errorBody, ringBuffer) 1094 decoder := json.NewDecoder(body) 1095 decoder.UseNumber() 1096 code, message, err := restjson.GetErrorInfo(decoder) 1097 if err != nil { 1098 var snapshot bytes.Buffer 1099 io.Copy(&snapshot, ringBuffer) 1100 err = &smithy.DeserializationError{ 1101 Err: fmt.Errorf("failed to decode response body, %w", err), 1102 Snapshot: snapshot.Bytes(), 1103 } 1104 return err 1105 } 1106 1107 errorBody.Seek(0, io.SeekStart) 1108 if len(code) != 0 { 1109 errorCode = restjson.SanitizeErrorCode(code) 1110 } 1111 if len(message) != 0 { 1112 errorMessage = message 1113 } 1114 1115 switch { 1116 case strings.EqualFold("InvalidParameterValuesException", errorCode): 1117 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 1118 1119 case strings.EqualFold("ResourceLimitExceededException", errorCode): 1120 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 1121 1122 default: 1123 genericError := &smithy.GenericAPIError{ 1124 Code: errorCode, 1125 Message: errorMessage, 1126 } 1127 return genericError 1128 1129 } 1130} 1131 1132type awsAwsjson11_deserializeOpDeleteConnectionAlias struct { 1133} 1134 1135func (*awsAwsjson11_deserializeOpDeleteConnectionAlias) ID() string { 1136 return "OperationDeserializer" 1137} 1138 1139func (m *awsAwsjson11_deserializeOpDeleteConnectionAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1140 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1141) { 1142 out, metadata, err = next.HandleDeserialize(ctx, in) 1143 if err != nil { 1144 return out, metadata, err 1145 } 1146 1147 response, ok := out.RawResponse.(*smithyhttp.Response) 1148 if !ok { 1149 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1150 } 1151 1152 if response.StatusCode < 200 || response.StatusCode >= 300 { 1153 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteConnectionAlias(response, &metadata) 1154 } 1155 output := &DeleteConnectionAliasOutput{} 1156 out.Result = output 1157 1158 var buff [1024]byte 1159 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1160 1161 body := io.TeeReader(response.Body, ringBuffer) 1162 decoder := json.NewDecoder(body) 1163 decoder.UseNumber() 1164 var shape interface{} 1165 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1166 var snapshot bytes.Buffer 1167 io.Copy(&snapshot, ringBuffer) 1168 err = &smithy.DeserializationError{ 1169 Err: fmt.Errorf("failed to decode response body, %w", err), 1170 Snapshot: snapshot.Bytes(), 1171 } 1172 return out, metadata, err 1173 } 1174 1175 err = awsAwsjson11_deserializeOpDocumentDeleteConnectionAliasOutput(&output, shape) 1176 if err != nil { 1177 var snapshot bytes.Buffer 1178 io.Copy(&snapshot, ringBuffer) 1179 err = &smithy.DeserializationError{ 1180 Err: fmt.Errorf("failed to decode response body, %w", err), 1181 Snapshot: snapshot.Bytes(), 1182 } 1183 return out, metadata, err 1184 } 1185 1186 return out, metadata, err 1187} 1188 1189func awsAwsjson11_deserializeOpErrorDeleteConnectionAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1190 var errorBuffer bytes.Buffer 1191 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1192 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1193 } 1194 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1195 1196 errorCode := "UnknownError" 1197 errorMessage := errorCode 1198 1199 code := response.Header.Get("X-Amzn-ErrorType") 1200 if len(code) != 0 { 1201 errorCode = restjson.SanitizeErrorCode(code) 1202 } 1203 1204 var buff [1024]byte 1205 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1206 1207 body := io.TeeReader(errorBody, ringBuffer) 1208 decoder := json.NewDecoder(body) 1209 decoder.UseNumber() 1210 code, message, err := restjson.GetErrorInfo(decoder) 1211 if err != nil { 1212 var snapshot bytes.Buffer 1213 io.Copy(&snapshot, ringBuffer) 1214 err = &smithy.DeserializationError{ 1215 Err: fmt.Errorf("failed to decode response body, %w", err), 1216 Snapshot: snapshot.Bytes(), 1217 } 1218 return err 1219 } 1220 1221 errorBody.Seek(0, io.SeekStart) 1222 if len(code) != 0 { 1223 errorCode = restjson.SanitizeErrorCode(code) 1224 } 1225 if len(message) != 0 { 1226 errorMessage = message 1227 } 1228 1229 switch { 1230 case strings.EqualFold("AccessDeniedException", errorCode): 1231 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1232 1233 case strings.EqualFold("InvalidParameterValuesException", errorCode): 1234 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 1235 1236 case strings.EqualFold("InvalidResourceStateException", errorCode): 1237 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 1238 1239 case strings.EqualFold("OperationNotSupportedException", errorCode): 1240 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 1241 1242 case strings.EqualFold("ResourceAssociatedException", errorCode): 1243 return awsAwsjson11_deserializeErrorResourceAssociatedException(response, errorBody) 1244 1245 case strings.EqualFold("ResourceNotFoundException", errorCode): 1246 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1247 1248 default: 1249 genericError := &smithy.GenericAPIError{ 1250 Code: errorCode, 1251 Message: errorMessage, 1252 } 1253 return genericError 1254 1255 } 1256} 1257 1258type awsAwsjson11_deserializeOpDeleteIpGroup struct { 1259} 1260 1261func (*awsAwsjson11_deserializeOpDeleteIpGroup) ID() string { 1262 return "OperationDeserializer" 1263} 1264 1265func (m *awsAwsjson11_deserializeOpDeleteIpGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1266 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1267) { 1268 out, metadata, err = next.HandleDeserialize(ctx, in) 1269 if err != nil { 1270 return out, metadata, err 1271 } 1272 1273 response, ok := out.RawResponse.(*smithyhttp.Response) 1274 if !ok { 1275 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1276 } 1277 1278 if response.StatusCode < 200 || response.StatusCode >= 300 { 1279 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteIpGroup(response, &metadata) 1280 } 1281 output := &DeleteIpGroupOutput{} 1282 out.Result = output 1283 1284 var buff [1024]byte 1285 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1286 1287 body := io.TeeReader(response.Body, ringBuffer) 1288 decoder := json.NewDecoder(body) 1289 decoder.UseNumber() 1290 var shape interface{} 1291 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1292 var snapshot bytes.Buffer 1293 io.Copy(&snapshot, ringBuffer) 1294 err = &smithy.DeserializationError{ 1295 Err: fmt.Errorf("failed to decode response body, %w", err), 1296 Snapshot: snapshot.Bytes(), 1297 } 1298 return out, metadata, err 1299 } 1300 1301 err = awsAwsjson11_deserializeOpDocumentDeleteIpGroupOutput(&output, shape) 1302 if err != nil { 1303 var snapshot bytes.Buffer 1304 io.Copy(&snapshot, ringBuffer) 1305 err = &smithy.DeserializationError{ 1306 Err: fmt.Errorf("failed to decode response body, %w", err), 1307 Snapshot: snapshot.Bytes(), 1308 } 1309 return out, metadata, err 1310 } 1311 1312 return out, metadata, err 1313} 1314 1315func awsAwsjson11_deserializeOpErrorDeleteIpGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1316 var errorBuffer bytes.Buffer 1317 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1318 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1319 } 1320 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1321 1322 errorCode := "UnknownError" 1323 errorMessage := errorCode 1324 1325 code := response.Header.Get("X-Amzn-ErrorType") 1326 if len(code) != 0 { 1327 errorCode = restjson.SanitizeErrorCode(code) 1328 } 1329 1330 var buff [1024]byte 1331 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1332 1333 body := io.TeeReader(errorBody, ringBuffer) 1334 decoder := json.NewDecoder(body) 1335 decoder.UseNumber() 1336 code, message, err := restjson.GetErrorInfo(decoder) 1337 if err != nil { 1338 var snapshot bytes.Buffer 1339 io.Copy(&snapshot, ringBuffer) 1340 err = &smithy.DeserializationError{ 1341 Err: fmt.Errorf("failed to decode response body, %w", err), 1342 Snapshot: snapshot.Bytes(), 1343 } 1344 return err 1345 } 1346 1347 errorBody.Seek(0, io.SeekStart) 1348 if len(code) != 0 { 1349 errorCode = restjson.SanitizeErrorCode(code) 1350 } 1351 if len(message) != 0 { 1352 errorMessage = message 1353 } 1354 1355 switch { 1356 case strings.EqualFold("AccessDeniedException", errorCode): 1357 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1358 1359 case strings.EqualFold("InvalidParameterValuesException", errorCode): 1360 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 1361 1362 case strings.EqualFold("ResourceAssociatedException", errorCode): 1363 return awsAwsjson11_deserializeErrorResourceAssociatedException(response, errorBody) 1364 1365 case strings.EqualFold("ResourceNotFoundException", errorCode): 1366 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1367 1368 default: 1369 genericError := &smithy.GenericAPIError{ 1370 Code: errorCode, 1371 Message: errorMessage, 1372 } 1373 return genericError 1374 1375 } 1376} 1377 1378type awsAwsjson11_deserializeOpDeleteTags struct { 1379} 1380 1381func (*awsAwsjson11_deserializeOpDeleteTags) ID() string { 1382 return "OperationDeserializer" 1383} 1384 1385func (m *awsAwsjson11_deserializeOpDeleteTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1386 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1387) { 1388 out, metadata, err = next.HandleDeserialize(ctx, in) 1389 if err != nil { 1390 return out, metadata, err 1391 } 1392 1393 response, ok := out.RawResponse.(*smithyhttp.Response) 1394 if !ok { 1395 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1396 } 1397 1398 if response.StatusCode < 200 || response.StatusCode >= 300 { 1399 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTags(response, &metadata) 1400 } 1401 output := &DeleteTagsOutput{} 1402 out.Result = output 1403 1404 var buff [1024]byte 1405 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1406 1407 body := io.TeeReader(response.Body, ringBuffer) 1408 decoder := json.NewDecoder(body) 1409 decoder.UseNumber() 1410 var shape interface{} 1411 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1412 var snapshot bytes.Buffer 1413 io.Copy(&snapshot, ringBuffer) 1414 err = &smithy.DeserializationError{ 1415 Err: fmt.Errorf("failed to decode response body, %w", err), 1416 Snapshot: snapshot.Bytes(), 1417 } 1418 return out, metadata, err 1419 } 1420 1421 err = awsAwsjson11_deserializeOpDocumentDeleteTagsOutput(&output, shape) 1422 if err != nil { 1423 var snapshot bytes.Buffer 1424 io.Copy(&snapshot, ringBuffer) 1425 err = &smithy.DeserializationError{ 1426 Err: fmt.Errorf("failed to decode response body, %w", err), 1427 Snapshot: snapshot.Bytes(), 1428 } 1429 return out, metadata, err 1430 } 1431 1432 return out, metadata, err 1433} 1434 1435func awsAwsjson11_deserializeOpErrorDeleteTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1436 var errorBuffer bytes.Buffer 1437 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1438 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1439 } 1440 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1441 1442 errorCode := "UnknownError" 1443 errorMessage := errorCode 1444 1445 code := response.Header.Get("X-Amzn-ErrorType") 1446 if len(code) != 0 { 1447 errorCode = restjson.SanitizeErrorCode(code) 1448 } 1449 1450 var buff [1024]byte 1451 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1452 1453 body := io.TeeReader(errorBody, ringBuffer) 1454 decoder := json.NewDecoder(body) 1455 decoder.UseNumber() 1456 code, message, err := restjson.GetErrorInfo(decoder) 1457 if err != nil { 1458 var snapshot bytes.Buffer 1459 io.Copy(&snapshot, ringBuffer) 1460 err = &smithy.DeserializationError{ 1461 Err: fmt.Errorf("failed to decode response body, %w", err), 1462 Snapshot: snapshot.Bytes(), 1463 } 1464 return err 1465 } 1466 1467 errorBody.Seek(0, io.SeekStart) 1468 if len(code) != 0 { 1469 errorCode = restjson.SanitizeErrorCode(code) 1470 } 1471 if len(message) != 0 { 1472 errorMessage = message 1473 } 1474 1475 switch { 1476 case strings.EqualFold("InvalidParameterValuesException", errorCode): 1477 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 1478 1479 case strings.EqualFold("ResourceNotFoundException", errorCode): 1480 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1481 1482 default: 1483 genericError := &smithy.GenericAPIError{ 1484 Code: errorCode, 1485 Message: errorMessage, 1486 } 1487 return genericError 1488 1489 } 1490} 1491 1492type awsAwsjson11_deserializeOpDeleteWorkspaceBundle struct { 1493} 1494 1495func (*awsAwsjson11_deserializeOpDeleteWorkspaceBundle) ID() string { 1496 return "OperationDeserializer" 1497} 1498 1499func (m *awsAwsjson11_deserializeOpDeleteWorkspaceBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1500 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1501) { 1502 out, metadata, err = next.HandleDeserialize(ctx, in) 1503 if err != nil { 1504 return out, metadata, err 1505 } 1506 1507 response, ok := out.RawResponse.(*smithyhttp.Response) 1508 if !ok { 1509 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1510 } 1511 1512 if response.StatusCode < 200 || response.StatusCode >= 300 { 1513 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteWorkspaceBundle(response, &metadata) 1514 } 1515 output := &DeleteWorkspaceBundleOutput{} 1516 out.Result = output 1517 1518 var buff [1024]byte 1519 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1520 1521 body := io.TeeReader(response.Body, ringBuffer) 1522 decoder := json.NewDecoder(body) 1523 decoder.UseNumber() 1524 var shape interface{} 1525 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1526 var snapshot bytes.Buffer 1527 io.Copy(&snapshot, ringBuffer) 1528 err = &smithy.DeserializationError{ 1529 Err: fmt.Errorf("failed to decode response body, %w", err), 1530 Snapshot: snapshot.Bytes(), 1531 } 1532 return out, metadata, err 1533 } 1534 1535 err = awsAwsjson11_deserializeOpDocumentDeleteWorkspaceBundleOutput(&output, shape) 1536 if err != nil { 1537 var snapshot bytes.Buffer 1538 io.Copy(&snapshot, ringBuffer) 1539 err = &smithy.DeserializationError{ 1540 Err: fmt.Errorf("failed to decode response body, %w", err), 1541 Snapshot: snapshot.Bytes(), 1542 } 1543 return out, metadata, err 1544 } 1545 1546 return out, metadata, err 1547} 1548 1549func awsAwsjson11_deserializeOpErrorDeleteWorkspaceBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1550 var errorBuffer bytes.Buffer 1551 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1552 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1553 } 1554 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1555 1556 errorCode := "UnknownError" 1557 errorMessage := errorCode 1558 1559 code := response.Header.Get("X-Amzn-ErrorType") 1560 if len(code) != 0 { 1561 errorCode = restjson.SanitizeErrorCode(code) 1562 } 1563 1564 var buff [1024]byte 1565 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1566 1567 body := io.TeeReader(errorBody, ringBuffer) 1568 decoder := json.NewDecoder(body) 1569 decoder.UseNumber() 1570 code, message, err := restjson.GetErrorInfo(decoder) 1571 if err != nil { 1572 var snapshot bytes.Buffer 1573 io.Copy(&snapshot, ringBuffer) 1574 err = &smithy.DeserializationError{ 1575 Err: fmt.Errorf("failed to decode response body, %w", err), 1576 Snapshot: snapshot.Bytes(), 1577 } 1578 return err 1579 } 1580 1581 errorBody.Seek(0, io.SeekStart) 1582 if len(code) != 0 { 1583 errorCode = restjson.SanitizeErrorCode(code) 1584 } 1585 if len(message) != 0 { 1586 errorMessage = message 1587 } 1588 1589 switch { 1590 case strings.EqualFold("AccessDeniedException", errorCode): 1591 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1592 1593 case strings.EqualFold("InvalidParameterValuesException", errorCode): 1594 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 1595 1596 case strings.EqualFold("ResourceAssociatedException", errorCode): 1597 return awsAwsjson11_deserializeErrorResourceAssociatedException(response, errorBody) 1598 1599 case strings.EqualFold("ResourceNotFoundException", errorCode): 1600 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1601 1602 default: 1603 genericError := &smithy.GenericAPIError{ 1604 Code: errorCode, 1605 Message: errorMessage, 1606 } 1607 return genericError 1608 1609 } 1610} 1611 1612type awsAwsjson11_deserializeOpDeleteWorkspaceImage struct { 1613} 1614 1615func (*awsAwsjson11_deserializeOpDeleteWorkspaceImage) ID() string { 1616 return "OperationDeserializer" 1617} 1618 1619func (m *awsAwsjson11_deserializeOpDeleteWorkspaceImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1620 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1621) { 1622 out, metadata, err = next.HandleDeserialize(ctx, in) 1623 if err != nil { 1624 return out, metadata, err 1625 } 1626 1627 response, ok := out.RawResponse.(*smithyhttp.Response) 1628 if !ok { 1629 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1630 } 1631 1632 if response.StatusCode < 200 || response.StatusCode >= 300 { 1633 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteWorkspaceImage(response, &metadata) 1634 } 1635 output := &DeleteWorkspaceImageOutput{} 1636 out.Result = output 1637 1638 var buff [1024]byte 1639 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1640 1641 body := io.TeeReader(response.Body, ringBuffer) 1642 decoder := json.NewDecoder(body) 1643 decoder.UseNumber() 1644 var shape interface{} 1645 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1646 var snapshot bytes.Buffer 1647 io.Copy(&snapshot, ringBuffer) 1648 err = &smithy.DeserializationError{ 1649 Err: fmt.Errorf("failed to decode response body, %w", err), 1650 Snapshot: snapshot.Bytes(), 1651 } 1652 return out, metadata, err 1653 } 1654 1655 err = awsAwsjson11_deserializeOpDocumentDeleteWorkspaceImageOutput(&output, shape) 1656 if err != nil { 1657 var snapshot bytes.Buffer 1658 io.Copy(&snapshot, ringBuffer) 1659 err = &smithy.DeserializationError{ 1660 Err: fmt.Errorf("failed to decode response body, %w", err), 1661 Snapshot: snapshot.Bytes(), 1662 } 1663 return out, metadata, err 1664 } 1665 1666 return out, metadata, err 1667} 1668 1669func awsAwsjson11_deserializeOpErrorDeleteWorkspaceImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1670 var errorBuffer bytes.Buffer 1671 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1672 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1673 } 1674 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1675 1676 errorCode := "UnknownError" 1677 errorMessage := errorCode 1678 1679 code := response.Header.Get("X-Amzn-ErrorType") 1680 if len(code) != 0 { 1681 errorCode = restjson.SanitizeErrorCode(code) 1682 } 1683 1684 var buff [1024]byte 1685 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1686 1687 body := io.TeeReader(errorBody, ringBuffer) 1688 decoder := json.NewDecoder(body) 1689 decoder.UseNumber() 1690 code, message, err := restjson.GetErrorInfo(decoder) 1691 if err != nil { 1692 var snapshot bytes.Buffer 1693 io.Copy(&snapshot, ringBuffer) 1694 err = &smithy.DeserializationError{ 1695 Err: fmt.Errorf("failed to decode response body, %w", err), 1696 Snapshot: snapshot.Bytes(), 1697 } 1698 return err 1699 } 1700 1701 errorBody.Seek(0, io.SeekStart) 1702 if len(code) != 0 { 1703 errorCode = restjson.SanitizeErrorCode(code) 1704 } 1705 if len(message) != 0 { 1706 errorMessage = message 1707 } 1708 1709 switch { 1710 case strings.EqualFold("AccessDeniedException", errorCode): 1711 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1712 1713 case strings.EqualFold("InvalidResourceStateException", errorCode): 1714 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 1715 1716 case strings.EqualFold("ResourceAssociatedException", errorCode): 1717 return awsAwsjson11_deserializeErrorResourceAssociatedException(response, errorBody) 1718 1719 default: 1720 genericError := &smithy.GenericAPIError{ 1721 Code: errorCode, 1722 Message: errorMessage, 1723 } 1724 return genericError 1725 1726 } 1727} 1728 1729type awsAwsjson11_deserializeOpDeregisterWorkspaceDirectory struct { 1730} 1731 1732func (*awsAwsjson11_deserializeOpDeregisterWorkspaceDirectory) ID() string { 1733 return "OperationDeserializer" 1734} 1735 1736func (m *awsAwsjson11_deserializeOpDeregisterWorkspaceDirectory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1737 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1738) { 1739 out, metadata, err = next.HandleDeserialize(ctx, in) 1740 if err != nil { 1741 return out, metadata, err 1742 } 1743 1744 response, ok := out.RawResponse.(*smithyhttp.Response) 1745 if !ok { 1746 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1747 } 1748 1749 if response.StatusCode < 200 || response.StatusCode >= 300 { 1750 return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterWorkspaceDirectory(response, &metadata) 1751 } 1752 output := &DeregisterWorkspaceDirectoryOutput{} 1753 out.Result = output 1754 1755 var buff [1024]byte 1756 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1757 1758 body := io.TeeReader(response.Body, ringBuffer) 1759 decoder := json.NewDecoder(body) 1760 decoder.UseNumber() 1761 var shape interface{} 1762 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1763 var snapshot bytes.Buffer 1764 io.Copy(&snapshot, ringBuffer) 1765 err = &smithy.DeserializationError{ 1766 Err: fmt.Errorf("failed to decode response body, %w", err), 1767 Snapshot: snapshot.Bytes(), 1768 } 1769 return out, metadata, err 1770 } 1771 1772 err = awsAwsjson11_deserializeOpDocumentDeregisterWorkspaceDirectoryOutput(&output, shape) 1773 if err != nil { 1774 var snapshot bytes.Buffer 1775 io.Copy(&snapshot, ringBuffer) 1776 err = &smithy.DeserializationError{ 1777 Err: fmt.Errorf("failed to decode response body, %w", err), 1778 Snapshot: snapshot.Bytes(), 1779 } 1780 return out, metadata, err 1781 } 1782 1783 return out, metadata, err 1784} 1785 1786func awsAwsjson11_deserializeOpErrorDeregisterWorkspaceDirectory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1787 var errorBuffer bytes.Buffer 1788 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1789 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1790 } 1791 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1792 1793 errorCode := "UnknownError" 1794 errorMessage := errorCode 1795 1796 code := response.Header.Get("X-Amzn-ErrorType") 1797 if len(code) != 0 { 1798 errorCode = restjson.SanitizeErrorCode(code) 1799 } 1800 1801 var buff [1024]byte 1802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1803 1804 body := io.TeeReader(errorBody, ringBuffer) 1805 decoder := json.NewDecoder(body) 1806 decoder.UseNumber() 1807 code, message, err := restjson.GetErrorInfo(decoder) 1808 if err != nil { 1809 var snapshot bytes.Buffer 1810 io.Copy(&snapshot, ringBuffer) 1811 err = &smithy.DeserializationError{ 1812 Err: fmt.Errorf("failed to decode response body, %w", err), 1813 Snapshot: snapshot.Bytes(), 1814 } 1815 return err 1816 } 1817 1818 errorBody.Seek(0, io.SeekStart) 1819 if len(code) != 0 { 1820 errorCode = restjson.SanitizeErrorCode(code) 1821 } 1822 if len(message) != 0 { 1823 errorMessage = message 1824 } 1825 1826 switch { 1827 case strings.EqualFold("AccessDeniedException", errorCode): 1828 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1829 1830 case strings.EqualFold("InvalidParameterValuesException", errorCode): 1831 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 1832 1833 case strings.EqualFold("InvalidResourceStateException", errorCode): 1834 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 1835 1836 case strings.EqualFold("OperationNotSupportedException", errorCode): 1837 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 1838 1839 case strings.EqualFold("ResourceNotFoundException", errorCode): 1840 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1841 1842 default: 1843 genericError := &smithy.GenericAPIError{ 1844 Code: errorCode, 1845 Message: errorMessage, 1846 } 1847 return genericError 1848 1849 } 1850} 1851 1852type awsAwsjson11_deserializeOpDescribeAccount struct { 1853} 1854 1855func (*awsAwsjson11_deserializeOpDescribeAccount) ID() string { 1856 return "OperationDeserializer" 1857} 1858 1859func (m *awsAwsjson11_deserializeOpDescribeAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1860 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1861) { 1862 out, metadata, err = next.HandleDeserialize(ctx, in) 1863 if err != nil { 1864 return out, metadata, err 1865 } 1866 1867 response, ok := out.RawResponse.(*smithyhttp.Response) 1868 if !ok { 1869 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1870 } 1871 1872 if response.StatusCode < 200 || response.StatusCode >= 300 { 1873 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccount(response, &metadata) 1874 } 1875 output := &DescribeAccountOutput{} 1876 out.Result = output 1877 1878 var buff [1024]byte 1879 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1880 1881 body := io.TeeReader(response.Body, ringBuffer) 1882 decoder := json.NewDecoder(body) 1883 decoder.UseNumber() 1884 var shape interface{} 1885 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1886 var snapshot bytes.Buffer 1887 io.Copy(&snapshot, ringBuffer) 1888 err = &smithy.DeserializationError{ 1889 Err: fmt.Errorf("failed to decode response body, %w", err), 1890 Snapshot: snapshot.Bytes(), 1891 } 1892 return out, metadata, err 1893 } 1894 1895 err = awsAwsjson11_deserializeOpDocumentDescribeAccountOutput(&output, shape) 1896 if err != nil { 1897 var snapshot bytes.Buffer 1898 io.Copy(&snapshot, ringBuffer) 1899 err = &smithy.DeserializationError{ 1900 Err: fmt.Errorf("failed to decode response body, %w", err), 1901 Snapshot: snapshot.Bytes(), 1902 } 1903 return out, metadata, err 1904 } 1905 1906 return out, metadata, err 1907} 1908 1909func awsAwsjson11_deserializeOpErrorDescribeAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1910 var errorBuffer bytes.Buffer 1911 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1912 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1913 } 1914 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1915 1916 errorCode := "UnknownError" 1917 errorMessage := errorCode 1918 1919 code := response.Header.Get("X-Amzn-ErrorType") 1920 if len(code) != 0 { 1921 errorCode = restjson.SanitizeErrorCode(code) 1922 } 1923 1924 var buff [1024]byte 1925 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1926 1927 body := io.TeeReader(errorBody, ringBuffer) 1928 decoder := json.NewDecoder(body) 1929 decoder.UseNumber() 1930 code, message, err := restjson.GetErrorInfo(decoder) 1931 if err != nil { 1932 var snapshot bytes.Buffer 1933 io.Copy(&snapshot, ringBuffer) 1934 err = &smithy.DeserializationError{ 1935 Err: fmt.Errorf("failed to decode response body, %w", err), 1936 Snapshot: snapshot.Bytes(), 1937 } 1938 return err 1939 } 1940 1941 errorBody.Seek(0, io.SeekStart) 1942 if len(code) != 0 { 1943 errorCode = restjson.SanitizeErrorCode(code) 1944 } 1945 if len(message) != 0 { 1946 errorMessage = message 1947 } 1948 1949 switch { 1950 case strings.EqualFold("AccessDeniedException", errorCode): 1951 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1952 1953 default: 1954 genericError := &smithy.GenericAPIError{ 1955 Code: errorCode, 1956 Message: errorMessage, 1957 } 1958 return genericError 1959 1960 } 1961} 1962 1963type awsAwsjson11_deserializeOpDescribeAccountModifications struct { 1964} 1965 1966func (*awsAwsjson11_deserializeOpDescribeAccountModifications) ID() string { 1967 return "OperationDeserializer" 1968} 1969 1970func (m *awsAwsjson11_deserializeOpDescribeAccountModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1971 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1972) { 1973 out, metadata, err = next.HandleDeserialize(ctx, in) 1974 if err != nil { 1975 return out, metadata, err 1976 } 1977 1978 response, ok := out.RawResponse.(*smithyhttp.Response) 1979 if !ok { 1980 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1981 } 1982 1983 if response.StatusCode < 200 || response.StatusCode >= 300 { 1984 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccountModifications(response, &metadata) 1985 } 1986 output := &DescribeAccountModificationsOutput{} 1987 out.Result = output 1988 1989 var buff [1024]byte 1990 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1991 1992 body := io.TeeReader(response.Body, ringBuffer) 1993 decoder := json.NewDecoder(body) 1994 decoder.UseNumber() 1995 var shape interface{} 1996 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1997 var snapshot bytes.Buffer 1998 io.Copy(&snapshot, ringBuffer) 1999 err = &smithy.DeserializationError{ 2000 Err: fmt.Errorf("failed to decode response body, %w", err), 2001 Snapshot: snapshot.Bytes(), 2002 } 2003 return out, metadata, err 2004 } 2005 2006 err = awsAwsjson11_deserializeOpDocumentDescribeAccountModificationsOutput(&output, shape) 2007 if err != nil { 2008 var snapshot bytes.Buffer 2009 io.Copy(&snapshot, ringBuffer) 2010 err = &smithy.DeserializationError{ 2011 Err: fmt.Errorf("failed to decode response body, %w", err), 2012 Snapshot: snapshot.Bytes(), 2013 } 2014 return out, metadata, err 2015 } 2016 2017 return out, metadata, err 2018} 2019 2020func awsAwsjson11_deserializeOpErrorDescribeAccountModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2021 var errorBuffer bytes.Buffer 2022 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2023 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2024 } 2025 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2026 2027 errorCode := "UnknownError" 2028 errorMessage := errorCode 2029 2030 code := response.Header.Get("X-Amzn-ErrorType") 2031 if len(code) != 0 { 2032 errorCode = restjson.SanitizeErrorCode(code) 2033 } 2034 2035 var buff [1024]byte 2036 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2037 2038 body := io.TeeReader(errorBody, ringBuffer) 2039 decoder := json.NewDecoder(body) 2040 decoder.UseNumber() 2041 code, message, err := restjson.GetErrorInfo(decoder) 2042 if err != nil { 2043 var snapshot bytes.Buffer 2044 io.Copy(&snapshot, ringBuffer) 2045 err = &smithy.DeserializationError{ 2046 Err: fmt.Errorf("failed to decode response body, %w", err), 2047 Snapshot: snapshot.Bytes(), 2048 } 2049 return err 2050 } 2051 2052 errorBody.Seek(0, io.SeekStart) 2053 if len(code) != 0 { 2054 errorCode = restjson.SanitizeErrorCode(code) 2055 } 2056 if len(message) != 0 { 2057 errorMessage = message 2058 } 2059 2060 switch { 2061 case strings.EqualFold("AccessDeniedException", errorCode): 2062 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2063 2064 default: 2065 genericError := &smithy.GenericAPIError{ 2066 Code: errorCode, 2067 Message: errorMessage, 2068 } 2069 return genericError 2070 2071 } 2072} 2073 2074type awsAwsjson11_deserializeOpDescribeClientProperties struct { 2075} 2076 2077func (*awsAwsjson11_deserializeOpDescribeClientProperties) ID() string { 2078 return "OperationDeserializer" 2079} 2080 2081func (m *awsAwsjson11_deserializeOpDescribeClientProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2082 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2083) { 2084 out, metadata, err = next.HandleDeserialize(ctx, in) 2085 if err != nil { 2086 return out, metadata, err 2087 } 2088 2089 response, ok := out.RawResponse.(*smithyhttp.Response) 2090 if !ok { 2091 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2092 } 2093 2094 if response.StatusCode < 200 || response.StatusCode >= 300 { 2095 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeClientProperties(response, &metadata) 2096 } 2097 output := &DescribeClientPropertiesOutput{} 2098 out.Result = output 2099 2100 var buff [1024]byte 2101 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2102 2103 body := io.TeeReader(response.Body, ringBuffer) 2104 decoder := json.NewDecoder(body) 2105 decoder.UseNumber() 2106 var shape interface{} 2107 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2108 var snapshot bytes.Buffer 2109 io.Copy(&snapshot, ringBuffer) 2110 err = &smithy.DeserializationError{ 2111 Err: fmt.Errorf("failed to decode response body, %w", err), 2112 Snapshot: snapshot.Bytes(), 2113 } 2114 return out, metadata, err 2115 } 2116 2117 err = awsAwsjson11_deserializeOpDocumentDescribeClientPropertiesOutput(&output, shape) 2118 if err != nil { 2119 var snapshot bytes.Buffer 2120 io.Copy(&snapshot, ringBuffer) 2121 err = &smithy.DeserializationError{ 2122 Err: fmt.Errorf("failed to decode response body, %w", err), 2123 Snapshot: snapshot.Bytes(), 2124 } 2125 return out, metadata, err 2126 } 2127 2128 return out, metadata, err 2129} 2130 2131func awsAwsjson11_deserializeOpErrorDescribeClientProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2132 var errorBuffer bytes.Buffer 2133 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2134 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2135 } 2136 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2137 2138 errorCode := "UnknownError" 2139 errorMessage := errorCode 2140 2141 code := response.Header.Get("X-Amzn-ErrorType") 2142 if len(code) != 0 { 2143 errorCode = restjson.SanitizeErrorCode(code) 2144 } 2145 2146 var buff [1024]byte 2147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2148 2149 body := io.TeeReader(errorBody, ringBuffer) 2150 decoder := json.NewDecoder(body) 2151 decoder.UseNumber() 2152 code, message, err := restjson.GetErrorInfo(decoder) 2153 if err != nil { 2154 var snapshot bytes.Buffer 2155 io.Copy(&snapshot, ringBuffer) 2156 err = &smithy.DeserializationError{ 2157 Err: fmt.Errorf("failed to decode response body, %w", err), 2158 Snapshot: snapshot.Bytes(), 2159 } 2160 return err 2161 } 2162 2163 errorBody.Seek(0, io.SeekStart) 2164 if len(code) != 0 { 2165 errorCode = restjson.SanitizeErrorCode(code) 2166 } 2167 if len(message) != 0 { 2168 errorMessage = message 2169 } 2170 2171 switch { 2172 case strings.EqualFold("AccessDeniedException", errorCode): 2173 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2174 2175 case strings.EqualFold("InvalidParameterValuesException", errorCode): 2176 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 2177 2178 case strings.EqualFold("ResourceNotFoundException", errorCode): 2179 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2180 2181 default: 2182 genericError := &smithy.GenericAPIError{ 2183 Code: errorCode, 2184 Message: errorMessage, 2185 } 2186 return genericError 2187 2188 } 2189} 2190 2191type awsAwsjson11_deserializeOpDescribeConnectionAliases struct { 2192} 2193 2194func (*awsAwsjson11_deserializeOpDescribeConnectionAliases) ID() string { 2195 return "OperationDeserializer" 2196} 2197 2198func (m *awsAwsjson11_deserializeOpDescribeConnectionAliases) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2199 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2200) { 2201 out, metadata, err = next.HandleDeserialize(ctx, in) 2202 if err != nil { 2203 return out, metadata, err 2204 } 2205 2206 response, ok := out.RawResponse.(*smithyhttp.Response) 2207 if !ok { 2208 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2209 } 2210 2211 if response.StatusCode < 200 || response.StatusCode >= 300 { 2212 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeConnectionAliases(response, &metadata) 2213 } 2214 output := &DescribeConnectionAliasesOutput{} 2215 out.Result = output 2216 2217 var buff [1024]byte 2218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2219 2220 body := io.TeeReader(response.Body, ringBuffer) 2221 decoder := json.NewDecoder(body) 2222 decoder.UseNumber() 2223 var shape interface{} 2224 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2225 var snapshot bytes.Buffer 2226 io.Copy(&snapshot, ringBuffer) 2227 err = &smithy.DeserializationError{ 2228 Err: fmt.Errorf("failed to decode response body, %w", err), 2229 Snapshot: snapshot.Bytes(), 2230 } 2231 return out, metadata, err 2232 } 2233 2234 err = awsAwsjson11_deserializeOpDocumentDescribeConnectionAliasesOutput(&output, shape) 2235 if err != nil { 2236 var snapshot bytes.Buffer 2237 io.Copy(&snapshot, ringBuffer) 2238 err = &smithy.DeserializationError{ 2239 Err: fmt.Errorf("failed to decode response body, %w", err), 2240 Snapshot: snapshot.Bytes(), 2241 } 2242 return out, metadata, err 2243 } 2244 2245 return out, metadata, err 2246} 2247 2248func awsAwsjson11_deserializeOpErrorDescribeConnectionAliases(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2249 var errorBuffer bytes.Buffer 2250 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2251 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2252 } 2253 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2254 2255 errorCode := "UnknownError" 2256 errorMessage := errorCode 2257 2258 code := response.Header.Get("X-Amzn-ErrorType") 2259 if len(code) != 0 { 2260 errorCode = restjson.SanitizeErrorCode(code) 2261 } 2262 2263 var buff [1024]byte 2264 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2265 2266 body := io.TeeReader(errorBody, ringBuffer) 2267 decoder := json.NewDecoder(body) 2268 decoder.UseNumber() 2269 code, message, err := restjson.GetErrorInfo(decoder) 2270 if err != nil { 2271 var snapshot bytes.Buffer 2272 io.Copy(&snapshot, ringBuffer) 2273 err = &smithy.DeserializationError{ 2274 Err: fmt.Errorf("failed to decode response body, %w", err), 2275 Snapshot: snapshot.Bytes(), 2276 } 2277 return err 2278 } 2279 2280 errorBody.Seek(0, io.SeekStart) 2281 if len(code) != 0 { 2282 errorCode = restjson.SanitizeErrorCode(code) 2283 } 2284 if len(message) != 0 { 2285 errorMessage = message 2286 } 2287 2288 switch { 2289 case strings.EqualFold("AccessDeniedException", errorCode): 2290 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2291 2292 case strings.EqualFold("InvalidParameterValuesException", errorCode): 2293 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 2294 2295 case strings.EqualFold("OperationNotSupportedException", errorCode): 2296 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 2297 2298 default: 2299 genericError := &smithy.GenericAPIError{ 2300 Code: errorCode, 2301 Message: errorMessage, 2302 } 2303 return genericError 2304 2305 } 2306} 2307 2308type awsAwsjson11_deserializeOpDescribeConnectionAliasPermissions struct { 2309} 2310 2311func (*awsAwsjson11_deserializeOpDescribeConnectionAliasPermissions) ID() string { 2312 return "OperationDeserializer" 2313} 2314 2315func (m *awsAwsjson11_deserializeOpDescribeConnectionAliasPermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2316 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2317) { 2318 out, metadata, err = next.HandleDeserialize(ctx, in) 2319 if err != nil { 2320 return out, metadata, err 2321 } 2322 2323 response, ok := out.RawResponse.(*smithyhttp.Response) 2324 if !ok { 2325 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2326 } 2327 2328 if response.StatusCode < 200 || response.StatusCode >= 300 { 2329 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeConnectionAliasPermissions(response, &metadata) 2330 } 2331 output := &DescribeConnectionAliasPermissionsOutput{} 2332 out.Result = output 2333 2334 var buff [1024]byte 2335 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2336 2337 body := io.TeeReader(response.Body, ringBuffer) 2338 decoder := json.NewDecoder(body) 2339 decoder.UseNumber() 2340 var shape interface{} 2341 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2342 var snapshot bytes.Buffer 2343 io.Copy(&snapshot, ringBuffer) 2344 err = &smithy.DeserializationError{ 2345 Err: fmt.Errorf("failed to decode response body, %w", err), 2346 Snapshot: snapshot.Bytes(), 2347 } 2348 return out, metadata, err 2349 } 2350 2351 err = awsAwsjson11_deserializeOpDocumentDescribeConnectionAliasPermissionsOutput(&output, shape) 2352 if err != nil { 2353 var snapshot bytes.Buffer 2354 io.Copy(&snapshot, ringBuffer) 2355 err = &smithy.DeserializationError{ 2356 Err: fmt.Errorf("failed to decode response body, %w", err), 2357 Snapshot: snapshot.Bytes(), 2358 } 2359 return out, metadata, err 2360 } 2361 2362 return out, metadata, err 2363} 2364 2365func awsAwsjson11_deserializeOpErrorDescribeConnectionAliasPermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2366 var errorBuffer bytes.Buffer 2367 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2368 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2369 } 2370 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2371 2372 errorCode := "UnknownError" 2373 errorMessage := errorCode 2374 2375 code := response.Header.Get("X-Amzn-ErrorType") 2376 if len(code) != 0 { 2377 errorCode = restjson.SanitizeErrorCode(code) 2378 } 2379 2380 var buff [1024]byte 2381 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2382 2383 body := io.TeeReader(errorBody, ringBuffer) 2384 decoder := json.NewDecoder(body) 2385 decoder.UseNumber() 2386 code, message, err := restjson.GetErrorInfo(decoder) 2387 if err != nil { 2388 var snapshot bytes.Buffer 2389 io.Copy(&snapshot, ringBuffer) 2390 err = &smithy.DeserializationError{ 2391 Err: fmt.Errorf("failed to decode response body, %w", err), 2392 Snapshot: snapshot.Bytes(), 2393 } 2394 return err 2395 } 2396 2397 errorBody.Seek(0, io.SeekStart) 2398 if len(code) != 0 { 2399 errorCode = restjson.SanitizeErrorCode(code) 2400 } 2401 if len(message) != 0 { 2402 errorMessage = message 2403 } 2404 2405 switch { 2406 case strings.EqualFold("AccessDeniedException", errorCode): 2407 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2408 2409 case strings.EqualFold("InvalidParameterValuesException", errorCode): 2410 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 2411 2412 case strings.EqualFold("OperationNotSupportedException", errorCode): 2413 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 2414 2415 case strings.EqualFold("ResourceNotFoundException", errorCode): 2416 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2417 2418 default: 2419 genericError := &smithy.GenericAPIError{ 2420 Code: errorCode, 2421 Message: errorMessage, 2422 } 2423 return genericError 2424 2425 } 2426} 2427 2428type awsAwsjson11_deserializeOpDescribeIpGroups struct { 2429} 2430 2431func (*awsAwsjson11_deserializeOpDescribeIpGroups) ID() string { 2432 return "OperationDeserializer" 2433} 2434 2435func (m *awsAwsjson11_deserializeOpDescribeIpGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2436 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2437) { 2438 out, metadata, err = next.HandleDeserialize(ctx, in) 2439 if err != nil { 2440 return out, metadata, err 2441 } 2442 2443 response, ok := out.RawResponse.(*smithyhttp.Response) 2444 if !ok { 2445 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2446 } 2447 2448 if response.StatusCode < 200 || response.StatusCode >= 300 { 2449 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeIpGroups(response, &metadata) 2450 } 2451 output := &DescribeIpGroupsOutput{} 2452 out.Result = output 2453 2454 var buff [1024]byte 2455 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2456 2457 body := io.TeeReader(response.Body, ringBuffer) 2458 decoder := json.NewDecoder(body) 2459 decoder.UseNumber() 2460 var shape interface{} 2461 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2462 var snapshot bytes.Buffer 2463 io.Copy(&snapshot, ringBuffer) 2464 err = &smithy.DeserializationError{ 2465 Err: fmt.Errorf("failed to decode response body, %w", err), 2466 Snapshot: snapshot.Bytes(), 2467 } 2468 return out, metadata, err 2469 } 2470 2471 err = awsAwsjson11_deserializeOpDocumentDescribeIpGroupsOutput(&output, shape) 2472 if err != nil { 2473 var snapshot bytes.Buffer 2474 io.Copy(&snapshot, ringBuffer) 2475 err = &smithy.DeserializationError{ 2476 Err: fmt.Errorf("failed to decode response body, %w", err), 2477 Snapshot: snapshot.Bytes(), 2478 } 2479 return out, metadata, err 2480 } 2481 2482 return out, metadata, err 2483} 2484 2485func awsAwsjson11_deserializeOpErrorDescribeIpGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2486 var errorBuffer bytes.Buffer 2487 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2488 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2489 } 2490 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2491 2492 errorCode := "UnknownError" 2493 errorMessage := errorCode 2494 2495 code := response.Header.Get("X-Amzn-ErrorType") 2496 if len(code) != 0 { 2497 errorCode = restjson.SanitizeErrorCode(code) 2498 } 2499 2500 var buff [1024]byte 2501 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2502 2503 body := io.TeeReader(errorBody, ringBuffer) 2504 decoder := json.NewDecoder(body) 2505 decoder.UseNumber() 2506 code, message, err := restjson.GetErrorInfo(decoder) 2507 if err != nil { 2508 var snapshot bytes.Buffer 2509 io.Copy(&snapshot, ringBuffer) 2510 err = &smithy.DeserializationError{ 2511 Err: fmt.Errorf("failed to decode response body, %w", err), 2512 Snapshot: snapshot.Bytes(), 2513 } 2514 return err 2515 } 2516 2517 errorBody.Seek(0, io.SeekStart) 2518 if len(code) != 0 { 2519 errorCode = restjson.SanitizeErrorCode(code) 2520 } 2521 if len(message) != 0 { 2522 errorMessage = message 2523 } 2524 2525 switch { 2526 case strings.EqualFold("AccessDeniedException", errorCode): 2527 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2528 2529 case strings.EqualFold("InvalidParameterValuesException", errorCode): 2530 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 2531 2532 default: 2533 genericError := &smithy.GenericAPIError{ 2534 Code: errorCode, 2535 Message: errorMessage, 2536 } 2537 return genericError 2538 2539 } 2540} 2541 2542type awsAwsjson11_deserializeOpDescribeTags struct { 2543} 2544 2545func (*awsAwsjson11_deserializeOpDescribeTags) ID() string { 2546 return "OperationDeserializer" 2547} 2548 2549func (m *awsAwsjson11_deserializeOpDescribeTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2550 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2551) { 2552 out, metadata, err = next.HandleDeserialize(ctx, in) 2553 if err != nil { 2554 return out, metadata, err 2555 } 2556 2557 response, ok := out.RawResponse.(*smithyhttp.Response) 2558 if !ok { 2559 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2560 } 2561 2562 if response.StatusCode < 200 || response.StatusCode >= 300 { 2563 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTags(response, &metadata) 2564 } 2565 output := &DescribeTagsOutput{} 2566 out.Result = output 2567 2568 var buff [1024]byte 2569 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2570 2571 body := io.TeeReader(response.Body, ringBuffer) 2572 decoder := json.NewDecoder(body) 2573 decoder.UseNumber() 2574 var shape interface{} 2575 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2576 var snapshot bytes.Buffer 2577 io.Copy(&snapshot, ringBuffer) 2578 err = &smithy.DeserializationError{ 2579 Err: fmt.Errorf("failed to decode response body, %w", err), 2580 Snapshot: snapshot.Bytes(), 2581 } 2582 return out, metadata, err 2583 } 2584 2585 err = awsAwsjson11_deserializeOpDocumentDescribeTagsOutput(&output, shape) 2586 if err != nil { 2587 var snapshot bytes.Buffer 2588 io.Copy(&snapshot, ringBuffer) 2589 err = &smithy.DeserializationError{ 2590 Err: fmt.Errorf("failed to decode response body, %w", err), 2591 Snapshot: snapshot.Bytes(), 2592 } 2593 return out, metadata, err 2594 } 2595 2596 return out, metadata, err 2597} 2598 2599func awsAwsjson11_deserializeOpErrorDescribeTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2600 var errorBuffer bytes.Buffer 2601 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2602 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2603 } 2604 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2605 2606 errorCode := "UnknownError" 2607 errorMessage := errorCode 2608 2609 code := response.Header.Get("X-Amzn-ErrorType") 2610 if len(code) != 0 { 2611 errorCode = restjson.SanitizeErrorCode(code) 2612 } 2613 2614 var buff [1024]byte 2615 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2616 2617 body := io.TeeReader(errorBody, ringBuffer) 2618 decoder := json.NewDecoder(body) 2619 decoder.UseNumber() 2620 code, message, err := restjson.GetErrorInfo(decoder) 2621 if err != nil { 2622 var snapshot bytes.Buffer 2623 io.Copy(&snapshot, ringBuffer) 2624 err = &smithy.DeserializationError{ 2625 Err: fmt.Errorf("failed to decode response body, %w", err), 2626 Snapshot: snapshot.Bytes(), 2627 } 2628 return err 2629 } 2630 2631 errorBody.Seek(0, io.SeekStart) 2632 if len(code) != 0 { 2633 errorCode = restjson.SanitizeErrorCode(code) 2634 } 2635 if len(message) != 0 { 2636 errorMessage = message 2637 } 2638 2639 switch { 2640 case strings.EqualFold("ResourceNotFoundException", errorCode): 2641 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2642 2643 default: 2644 genericError := &smithy.GenericAPIError{ 2645 Code: errorCode, 2646 Message: errorMessage, 2647 } 2648 return genericError 2649 2650 } 2651} 2652 2653type awsAwsjson11_deserializeOpDescribeWorkspaceBundles struct { 2654} 2655 2656func (*awsAwsjson11_deserializeOpDescribeWorkspaceBundles) ID() string { 2657 return "OperationDeserializer" 2658} 2659 2660func (m *awsAwsjson11_deserializeOpDescribeWorkspaceBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2661 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2662) { 2663 out, metadata, err = next.HandleDeserialize(ctx, in) 2664 if err != nil { 2665 return out, metadata, err 2666 } 2667 2668 response, ok := out.RawResponse.(*smithyhttp.Response) 2669 if !ok { 2670 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2671 } 2672 2673 if response.StatusCode < 200 || response.StatusCode >= 300 { 2674 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeWorkspaceBundles(response, &metadata) 2675 } 2676 output := &DescribeWorkspaceBundlesOutput{} 2677 out.Result = output 2678 2679 var buff [1024]byte 2680 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2681 2682 body := io.TeeReader(response.Body, ringBuffer) 2683 decoder := json.NewDecoder(body) 2684 decoder.UseNumber() 2685 var shape interface{} 2686 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2687 var snapshot bytes.Buffer 2688 io.Copy(&snapshot, ringBuffer) 2689 err = &smithy.DeserializationError{ 2690 Err: fmt.Errorf("failed to decode response body, %w", err), 2691 Snapshot: snapshot.Bytes(), 2692 } 2693 return out, metadata, err 2694 } 2695 2696 err = awsAwsjson11_deserializeOpDocumentDescribeWorkspaceBundlesOutput(&output, shape) 2697 if err != nil { 2698 var snapshot bytes.Buffer 2699 io.Copy(&snapshot, ringBuffer) 2700 err = &smithy.DeserializationError{ 2701 Err: fmt.Errorf("failed to decode response body, %w", err), 2702 Snapshot: snapshot.Bytes(), 2703 } 2704 return out, metadata, err 2705 } 2706 2707 return out, metadata, err 2708} 2709 2710func awsAwsjson11_deserializeOpErrorDescribeWorkspaceBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2711 var errorBuffer bytes.Buffer 2712 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2713 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2714 } 2715 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2716 2717 errorCode := "UnknownError" 2718 errorMessage := errorCode 2719 2720 code := response.Header.Get("X-Amzn-ErrorType") 2721 if len(code) != 0 { 2722 errorCode = restjson.SanitizeErrorCode(code) 2723 } 2724 2725 var buff [1024]byte 2726 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2727 2728 body := io.TeeReader(errorBody, ringBuffer) 2729 decoder := json.NewDecoder(body) 2730 decoder.UseNumber() 2731 code, message, err := restjson.GetErrorInfo(decoder) 2732 if err != nil { 2733 var snapshot bytes.Buffer 2734 io.Copy(&snapshot, ringBuffer) 2735 err = &smithy.DeserializationError{ 2736 Err: fmt.Errorf("failed to decode response body, %w", err), 2737 Snapshot: snapshot.Bytes(), 2738 } 2739 return err 2740 } 2741 2742 errorBody.Seek(0, io.SeekStart) 2743 if len(code) != 0 { 2744 errorCode = restjson.SanitizeErrorCode(code) 2745 } 2746 if len(message) != 0 { 2747 errorMessage = message 2748 } 2749 2750 switch { 2751 case strings.EqualFold("InvalidParameterValuesException", errorCode): 2752 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 2753 2754 default: 2755 genericError := &smithy.GenericAPIError{ 2756 Code: errorCode, 2757 Message: errorMessage, 2758 } 2759 return genericError 2760 2761 } 2762} 2763 2764type awsAwsjson11_deserializeOpDescribeWorkspaceDirectories struct { 2765} 2766 2767func (*awsAwsjson11_deserializeOpDescribeWorkspaceDirectories) ID() string { 2768 return "OperationDeserializer" 2769} 2770 2771func (m *awsAwsjson11_deserializeOpDescribeWorkspaceDirectories) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2772 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2773) { 2774 out, metadata, err = next.HandleDeserialize(ctx, in) 2775 if err != nil { 2776 return out, metadata, err 2777 } 2778 2779 response, ok := out.RawResponse.(*smithyhttp.Response) 2780 if !ok { 2781 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2782 } 2783 2784 if response.StatusCode < 200 || response.StatusCode >= 300 { 2785 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeWorkspaceDirectories(response, &metadata) 2786 } 2787 output := &DescribeWorkspaceDirectoriesOutput{} 2788 out.Result = output 2789 2790 var buff [1024]byte 2791 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2792 2793 body := io.TeeReader(response.Body, ringBuffer) 2794 decoder := json.NewDecoder(body) 2795 decoder.UseNumber() 2796 var shape interface{} 2797 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2798 var snapshot bytes.Buffer 2799 io.Copy(&snapshot, ringBuffer) 2800 err = &smithy.DeserializationError{ 2801 Err: fmt.Errorf("failed to decode response body, %w", err), 2802 Snapshot: snapshot.Bytes(), 2803 } 2804 return out, metadata, err 2805 } 2806 2807 err = awsAwsjson11_deserializeOpDocumentDescribeWorkspaceDirectoriesOutput(&output, shape) 2808 if err != nil { 2809 var snapshot bytes.Buffer 2810 io.Copy(&snapshot, ringBuffer) 2811 err = &smithy.DeserializationError{ 2812 Err: fmt.Errorf("failed to decode response body, %w", err), 2813 Snapshot: snapshot.Bytes(), 2814 } 2815 return out, metadata, err 2816 } 2817 2818 return out, metadata, err 2819} 2820 2821func awsAwsjson11_deserializeOpErrorDescribeWorkspaceDirectories(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2822 var errorBuffer bytes.Buffer 2823 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2824 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2825 } 2826 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2827 2828 errorCode := "UnknownError" 2829 errorMessage := errorCode 2830 2831 code := response.Header.Get("X-Amzn-ErrorType") 2832 if len(code) != 0 { 2833 errorCode = restjson.SanitizeErrorCode(code) 2834 } 2835 2836 var buff [1024]byte 2837 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2838 2839 body := io.TeeReader(errorBody, ringBuffer) 2840 decoder := json.NewDecoder(body) 2841 decoder.UseNumber() 2842 code, message, err := restjson.GetErrorInfo(decoder) 2843 if err != nil { 2844 var snapshot bytes.Buffer 2845 io.Copy(&snapshot, ringBuffer) 2846 err = &smithy.DeserializationError{ 2847 Err: fmt.Errorf("failed to decode response body, %w", err), 2848 Snapshot: snapshot.Bytes(), 2849 } 2850 return err 2851 } 2852 2853 errorBody.Seek(0, io.SeekStart) 2854 if len(code) != 0 { 2855 errorCode = restjson.SanitizeErrorCode(code) 2856 } 2857 if len(message) != 0 { 2858 errorMessage = message 2859 } 2860 2861 switch { 2862 case strings.EqualFold("InvalidParameterValuesException", errorCode): 2863 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 2864 2865 default: 2866 genericError := &smithy.GenericAPIError{ 2867 Code: errorCode, 2868 Message: errorMessage, 2869 } 2870 return genericError 2871 2872 } 2873} 2874 2875type awsAwsjson11_deserializeOpDescribeWorkspaceImagePermissions struct { 2876} 2877 2878func (*awsAwsjson11_deserializeOpDescribeWorkspaceImagePermissions) ID() string { 2879 return "OperationDeserializer" 2880} 2881 2882func (m *awsAwsjson11_deserializeOpDescribeWorkspaceImagePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2883 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2884) { 2885 out, metadata, err = next.HandleDeserialize(ctx, in) 2886 if err != nil { 2887 return out, metadata, err 2888 } 2889 2890 response, ok := out.RawResponse.(*smithyhttp.Response) 2891 if !ok { 2892 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2893 } 2894 2895 if response.StatusCode < 200 || response.StatusCode >= 300 { 2896 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeWorkspaceImagePermissions(response, &metadata) 2897 } 2898 output := &DescribeWorkspaceImagePermissionsOutput{} 2899 out.Result = output 2900 2901 var buff [1024]byte 2902 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2903 2904 body := io.TeeReader(response.Body, ringBuffer) 2905 decoder := json.NewDecoder(body) 2906 decoder.UseNumber() 2907 var shape interface{} 2908 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2909 var snapshot bytes.Buffer 2910 io.Copy(&snapshot, ringBuffer) 2911 err = &smithy.DeserializationError{ 2912 Err: fmt.Errorf("failed to decode response body, %w", err), 2913 Snapshot: snapshot.Bytes(), 2914 } 2915 return out, metadata, err 2916 } 2917 2918 err = awsAwsjson11_deserializeOpDocumentDescribeWorkspaceImagePermissionsOutput(&output, shape) 2919 if err != nil { 2920 var snapshot bytes.Buffer 2921 io.Copy(&snapshot, ringBuffer) 2922 err = &smithy.DeserializationError{ 2923 Err: fmt.Errorf("failed to decode response body, %w", err), 2924 Snapshot: snapshot.Bytes(), 2925 } 2926 return out, metadata, err 2927 } 2928 2929 return out, metadata, err 2930} 2931 2932func awsAwsjson11_deserializeOpErrorDescribeWorkspaceImagePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2933 var errorBuffer bytes.Buffer 2934 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2935 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2936 } 2937 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2938 2939 errorCode := "UnknownError" 2940 errorMessage := errorCode 2941 2942 code := response.Header.Get("X-Amzn-ErrorType") 2943 if len(code) != 0 { 2944 errorCode = restjson.SanitizeErrorCode(code) 2945 } 2946 2947 var buff [1024]byte 2948 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2949 2950 body := io.TeeReader(errorBody, ringBuffer) 2951 decoder := json.NewDecoder(body) 2952 decoder.UseNumber() 2953 code, message, err := restjson.GetErrorInfo(decoder) 2954 if err != nil { 2955 var snapshot bytes.Buffer 2956 io.Copy(&snapshot, ringBuffer) 2957 err = &smithy.DeserializationError{ 2958 Err: fmt.Errorf("failed to decode response body, %w", err), 2959 Snapshot: snapshot.Bytes(), 2960 } 2961 return err 2962 } 2963 2964 errorBody.Seek(0, io.SeekStart) 2965 if len(code) != 0 { 2966 errorCode = restjson.SanitizeErrorCode(code) 2967 } 2968 if len(message) != 0 { 2969 errorMessage = message 2970 } 2971 2972 switch { 2973 case strings.EqualFold("AccessDeniedException", errorCode): 2974 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2975 2976 case strings.EqualFold("InvalidParameterValuesException", errorCode): 2977 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 2978 2979 case strings.EqualFold("ResourceNotFoundException", errorCode): 2980 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2981 2982 default: 2983 genericError := &smithy.GenericAPIError{ 2984 Code: errorCode, 2985 Message: errorMessage, 2986 } 2987 return genericError 2988 2989 } 2990} 2991 2992type awsAwsjson11_deserializeOpDescribeWorkspaceImages struct { 2993} 2994 2995func (*awsAwsjson11_deserializeOpDescribeWorkspaceImages) ID() string { 2996 return "OperationDeserializer" 2997} 2998 2999func (m *awsAwsjson11_deserializeOpDescribeWorkspaceImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3000 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3001) { 3002 out, metadata, err = next.HandleDeserialize(ctx, in) 3003 if err != nil { 3004 return out, metadata, err 3005 } 3006 3007 response, ok := out.RawResponse.(*smithyhttp.Response) 3008 if !ok { 3009 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3010 } 3011 3012 if response.StatusCode < 200 || response.StatusCode >= 300 { 3013 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeWorkspaceImages(response, &metadata) 3014 } 3015 output := &DescribeWorkspaceImagesOutput{} 3016 out.Result = output 3017 3018 var buff [1024]byte 3019 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3020 3021 body := io.TeeReader(response.Body, ringBuffer) 3022 decoder := json.NewDecoder(body) 3023 decoder.UseNumber() 3024 var shape interface{} 3025 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3026 var snapshot bytes.Buffer 3027 io.Copy(&snapshot, ringBuffer) 3028 err = &smithy.DeserializationError{ 3029 Err: fmt.Errorf("failed to decode response body, %w", err), 3030 Snapshot: snapshot.Bytes(), 3031 } 3032 return out, metadata, err 3033 } 3034 3035 err = awsAwsjson11_deserializeOpDocumentDescribeWorkspaceImagesOutput(&output, shape) 3036 if err != nil { 3037 var snapshot bytes.Buffer 3038 io.Copy(&snapshot, ringBuffer) 3039 err = &smithy.DeserializationError{ 3040 Err: fmt.Errorf("failed to decode response body, %w", err), 3041 Snapshot: snapshot.Bytes(), 3042 } 3043 return out, metadata, err 3044 } 3045 3046 return out, metadata, err 3047} 3048 3049func awsAwsjson11_deserializeOpErrorDescribeWorkspaceImages(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3050 var errorBuffer bytes.Buffer 3051 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3052 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3053 } 3054 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3055 3056 errorCode := "UnknownError" 3057 errorMessage := errorCode 3058 3059 code := response.Header.Get("X-Amzn-ErrorType") 3060 if len(code) != 0 { 3061 errorCode = restjson.SanitizeErrorCode(code) 3062 } 3063 3064 var buff [1024]byte 3065 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3066 3067 body := io.TeeReader(errorBody, ringBuffer) 3068 decoder := json.NewDecoder(body) 3069 decoder.UseNumber() 3070 code, message, err := restjson.GetErrorInfo(decoder) 3071 if err != nil { 3072 var snapshot bytes.Buffer 3073 io.Copy(&snapshot, ringBuffer) 3074 err = &smithy.DeserializationError{ 3075 Err: fmt.Errorf("failed to decode response body, %w", err), 3076 Snapshot: snapshot.Bytes(), 3077 } 3078 return err 3079 } 3080 3081 errorBody.Seek(0, io.SeekStart) 3082 if len(code) != 0 { 3083 errorCode = restjson.SanitizeErrorCode(code) 3084 } 3085 if len(message) != 0 { 3086 errorMessage = message 3087 } 3088 3089 switch { 3090 case strings.EqualFold("AccessDeniedException", errorCode): 3091 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3092 3093 default: 3094 genericError := &smithy.GenericAPIError{ 3095 Code: errorCode, 3096 Message: errorMessage, 3097 } 3098 return genericError 3099 3100 } 3101} 3102 3103type awsAwsjson11_deserializeOpDescribeWorkspaces struct { 3104} 3105 3106func (*awsAwsjson11_deserializeOpDescribeWorkspaces) ID() string { 3107 return "OperationDeserializer" 3108} 3109 3110func (m *awsAwsjson11_deserializeOpDescribeWorkspaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3111 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3112) { 3113 out, metadata, err = next.HandleDeserialize(ctx, in) 3114 if err != nil { 3115 return out, metadata, err 3116 } 3117 3118 response, ok := out.RawResponse.(*smithyhttp.Response) 3119 if !ok { 3120 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3121 } 3122 3123 if response.StatusCode < 200 || response.StatusCode >= 300 { 3124 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeWorkspaces(response, &metadata) 3125 } 3126 output := &DescribeWorkspacesOutput{} 3127 out.Result = output 3128 3129 var buff [1024]byte 3130 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3131 3132 body := io.TeeReader(response.Body, ringBuffer) 3133 decoder := json.NewDecoder(body) 3134 decoder.UseNumber() 3135 var shape interface{} 3136 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3137 var snapshot bytes.Buffer 3138 io.Copy(&snapshot, ringBuffer) 3139 err = &smithy.DeserializationError{ 3140 Err: fmt.Errorf("failed to decode response body, %w", err), 3141 Snapshot: snapshot.Bytes(), 3142 } 3143 return out, metadata, err 3144 } 3145 3146 err = awsAwsjson11_deserializeOpDocumentDescribeWorkspacesOutput(&output, shape) 3147 if err != nil { 3148 var snapshot bytes.Buffer 3149 io.Copy(&snapshot, ringBuffer) 3150 err = &smithy.DeserializationError{ 3151 Err: fmt.Errorf("failed to decode response body, %w", err), 3152 Snapshot: snapshot.Bytes(), 3153 } 3154 return out, metadata, err 3155 } 3156 3157 return out, metadata, err 3158} 3159 3160func awsAwsjson11_deserializeOpErrorDescribeWorkspaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3161 var errorBuffer bytes.Buffer 3162 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3163 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3164 } 3165 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3166 3167 errorCode := "UnknownError" 3168 errorMessage := errorCode 3169 3170 code := response.Header.Get("X-Amzn-ErrorType") 3171 if len(code) != 0 { 3172 errorCode = restjson.SanitizeErrorCode(code) 3173 } 3174 3175 var buff [1024]byte 3176 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3177 3178 body := io.TeeReader(errorBody, ringBuffer) 3179 decoder := json.NewDecoder(body) 3180 decoder.UseNumber() 3181 code, message, err := restjson.GetErrorInfo(decoder) 3182 if err != nil { 3183 var snapshot bytes.Buffer 3184 io.Copy(&snapshot, ringBuffer) 3185 err = &smithy.DeserializationError{ 3186 Err: fmt.Errorf("failed to decode response body, %w", err), 3187 Snapshot: snapshot.Bytes(), 3188 } 3189 return err 3190 } 3191 3192 errorBody.Seek(0, io.SeekStart) 3193 if len(code) != 0 { 3194 errorCode = restjson.SanitizeErrorCode(code) 3195 } 3196 if len(message) != 0 { 3197 errorMessage = message 3198 } 3199 3200 switch { 3201 case strings.EqualFold("InvalidParameterValuesException", errorCode): 3202 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 3203 3204 case strings.EqualFold("ResourceUnavailableException", errorCode): 3205 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 3206 3207 default: 3208 genericError := &smithy.GenericAPIError{ 3209 Code: errorCode, 3210 Message: errorMessage, 3211 } 3212 return genericError 3213 3214 } 3215} 3216 3217type awsAwsjson11_deserializeOpDescribeWorkspacesConnectionStatus struct { 3218} 3219 3220func (*awsAwsjson11_deserializeOpDescribeWorkspacesConnectionStatus) ID() string { 3221 return "OperationDeserializer" 3222} 3223 3224func (m *awsAwsjson11_deserializeOpDescribeWorkspacesConnectionStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3225 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3226) { 3227 out, metadata, err = next.HandleDeserialize(ctx, in) 3228 if err != nil { 3229 return out, metadata, err 3230 } 3231 3232 response, ok := out.RawResponse.(*smithyhttp.Response) 3233 if !ok { 3234 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3235 } 3236 3237 if response.StatusCode < 200 || response.StatusCode >= 300 { 3238 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeWorkspacesConnectionStatus(response, &metadata) 3239 } 3240 output := &DescribeWorkspacesConnectionStatusOutput{} 3241 out.Result = output 3242 3243 var buff [1024]byte 3244 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3245 3246 body := io.TeeReader(response.Body, ringBuffer) 3247 decoder := json.NewDecoder(body) 3248 decoder.UseNumber() 3249 var shape interface{} 3250 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3251 var snapshot bytes.Buffer 3252 io.Copy(&snapshot, ringBuffer) 3253 err = &smithy.DeserializationError{ 3254 Err: fmt.Errorf("failed to decode response body, %w", err), 3255 Snapshot: snapshot.Bytes(), 3256 } 3257 return out, metadata, err 3258 } 3259 3260 err = awsAwsjson11_deserializeOpDocumentDescribeWorkspacesConnectionStatusOutput(&output, shape) 3261 if err != nil { 3262 var snapshot bytes.Buffer 3263 io.Copy(&snapshot, ringBuffer) 3264 err = &smithy.DeserializationError{ 3265 Err: fmt.Errorf("failed to decode response body, %w", err), 3266 Snapshot: snapshot.Bytes(), 3267 } 3268 return out, metadata, err 3269 } 3270 3271 return out, metadata, err 3272} 3273 3274func awsAwsjson11_deserializeOpErrorDescribeWorkspacesConnectionStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3275 var errorBuffer bytes.Buffer 3276 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3277 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3278 } 3279 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3280 3281 errorCode := "UnknownError" 3282 errorMessage := errorCode 3283 3284 code := response.Header.Get("X-Amzn-ErrorType") 3285 if len(code) != 0 { 3286 errorCode = restjson.SanitizeErrorCode(code) 3287 } 3288 3289 var buff [1024]byte 3290 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3291 3292 body := io.TeeReader(errorBody, ringBuffer) 3293 decoder := json.NewDecoder(body) 3294 decoder.UseNumber() 3295 code, message, err := restjson.GetErrorInfo(decoder) 3296 if err != nil { 3297 var snapshot bytes.Buffer 3298 io.Copy(&snapshot, ringBuffer) 3299 err = &smithy.DeserializationError{ 3300 Err: fmt.Errorf("failed to decode response body, %w", err), 3301 Snapshot: snapshot.Bytes(), 3302 } 3303 return err 3304 } 3305 3306 errorBody.Seek(0, io.SeekStart) 3307 if len(code) != 0 { 3308 errorCode = restjson.SanitizeErrorCode(code) 3309 } 3310 if len(message) != 0 { 3311 errorMessage = message 3312 } 3313 3314 switch { 3315 case strings.EqualFold("InvalidParameterValuesException", errorCode): 3316 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 3317 3318 default: 3319 genericError := &smithy.GenericAPIError{ 3320 Code: errorCode, 3321 Message: errorMessage, 3322 } 3323 return genericError 3324 3325 } 3326} 3327 3328type awsAwsjson11_deserializeOpDescribeWorkspaceSnapshots struct { 3329} 3330 3331func (*awsAwsjson11_deserializeOpDescribeWorkspaceSnapshots) ID() string { 3332 return "OperationDeserializer" 3333} 3334 3335func (m *awsAwsjson11_deserializeOpDescribeWorkspaceSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3336 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3337) { 3338 out, metadata, err = next.HandleDeserialize(ctx, in) 3339 if err != nil { 3340 return out, metadata, err 3341 } 3342 3343 response, ok := out.RawResponse.(*smithyhttp.Response) 3344 if !ok { 3345 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3346 } 3347 3348 if response.StatusCode < 200 || response.StatusCode >= 300 { 3349 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeWorkspaceSnapshots(response, &metadata) 3350 } 3351 output := &DescribeWorkspaceSnapshotsOutput{} 3352 out.Result = output 3353 3354 var buff [1024]byte 3355 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3356 3357 body := io.TeeReader(response.Body, ringBuffer) 3358 decoder := json.NewDecoder(body) 3359 decoder.UseNumber() 3360 var shape interface{} 3361 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3362 var snapshot bytes.Buffer 3363 io.Copy(&snapshot, ringBuffer) 3364 err = &smithy.DeserializationError{ 3365 Err: fmt.Errorf("failed to decode response body, %w", err), 3366 Snapshot: snapshot.Bytes(), 3367 } 3368 return out, metadata, err 3369 } 3370 3371 err = awsAwsjson11_deserializeOpDocumentDescribeWorkspaceSnapshotsOutput(&output, shape) 3372 if err != nil { 3373 var snapshot bytes.Buffer 3374 io.Copy(&snapshot, ringBuffer) 3375 err = &smithy.DeserializationError{ 3376 Err: fmt.Errorf("failed to decode response body, %w", err), 3377 Snapshot: snapshot.Bytes(), 3378 } 3379 return out, metadata, err 3380 } 3381 3382 return out, metadata, err 3383} 3384 3385func awsAwsjson11_deserializeOpErrorDescribeWorkspaceSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3386 var errorBuffer bytes.Buffer 3387 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3388 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3389 } 3390 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3391 3392 errorCode := "UnknownError" 3393 errorMessage := errorCode 3394 3395 code := response.Header.Get("X-Amzn-ErrorType") 3396 if len(code) != 0 { 3397 errorCode = restjson.SanitizeErrorCode(code) 3398 } 3399 3400 var buff [1024]byte 3401 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3402 3403 body := io.TeeReader(errorBody, ringBuffer) 3404 decoder := json.NewDecoder(body) 3405 decoder.UseNumber() 3406 code, message, err := restjson.GetErrorInfo(decoder) 3407 if err != nil { 3408 var snapshot bytes.Buffer 3409 io.Copy(&snapshot, ringBuffer) 3410 err = &smithy.DeserializationError{ 3411 Err: fmt.Errorf("failed to decode response body, %w", err), 3412 Snapshot: snapshot.Bytes(), 3413 } 3414 return err 3415 } 3416 3417 errorBody.Seek(0, io.SeekStart) 3418 if len(code) != 0 { 3419 errorCode = restjson.SanitizeErrorCode(code) 3420 } 3421 if len(message) != 0 { 3422 errorMessage = message 3423 } 3424 3425 switch { 3426 case strings.EqualFold("AccessDeniedException", errorCode): 3427 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3428 3429 case strings.EqualFold("InvalidParameterValuesException", errorCode): 3430 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 3431 3432 case strings.EqualFold("ResourceNotFoundException", errorCode): 3433 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3434 3435 default: 3436 genericError := &smithy.GenericAPIError{ 3437 Code: errorCode, 3438 Message: errorMessage, 3439 } 3440 return genericError 3441 3442 } 3443} 3444 3445type awsAwsjson11_deserializeOpDisassociateConnectionAlias struct { 3446} 3447 3448func (*awsAwsjson11_deserializeOpDisassociateConnectionAlias) ID() string { 3449 return "OperationDeserializer" 3450} 3451 3452func (m *awsAwsjson11_deserializeOpDisassociateConnectionAlias) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3453 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3454) { 3455 out, metadata, err = next.HandleDeserialize(ctx, in) 3456 if err != nil { 3457 return out, metadata, err 3458 } 3459 3460 response, ok := out.RawResponse.(*smithyhttp.Response) 3461 if !ok { 3462 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3463 } 3464 3465 if response.StatusCode < 200 || response.StatusCode >= 300 { 3466 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateConnectionAlias(response, &metadata) 3467 } 3468 output := &DisassociateConnectionAliasOutput{} 3469 out.Result = output 3470 3471 var buff [1024]byte 3472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3473 3474 body := io.TeeReader(response.Body, ringBuffer) 3475 decoder := json.NewDecoder(body) 3476 decoder.UseNumber() 3477 var shape interface{} 3478 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3479 var snapshot bytes.Buffer 3480 io.Copy(&snapshot, ringBuffer) 3481 err = &smithy.DeserializationError{ 3482 Err: fmt.Errorf("failed to decode response body, %w", err), 3483 Snapshot: snapshot.Bytes(), 3484 } 3485 return out, metadata, err 3486 } 3487 3488 err = awsAwsjson11_deserializeOpDocumentDisassociateConnectionAliasOutput(&output, shape) 3489 if err != nil { 3490 var snapshot bytes.Buffer 3491 io.Copy(&snapshot, ringBuffer) 3492 err = &smithy.DeserializationError{ 3493 Err: fmt.Errorf("failed to decode response body, %w", err), 3494 Snapshot: snapshot.Bytes(), 3495 } 3496 return out, metadata, err 3497 } 3498 3499 return out, metadata, err 3500} 3501 3502func awsAwsjson11_deserializeOpErrorDisassociateConnectionAlias(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3503 var errorBuffer bytes.Buffer 3504 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3505 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3506 } 3507 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3508 3509 errorCode := "UnknownError" 3510 errorMessage := errorCode 3511 3512 code := response.Header.Get("X-Amzn-ErrorType") 3513 if len(code) != 0 { 3514 errorCode = restjson.SanitizeErrorCode(code) 3515 } 3516 3517 var buff [1024]byte 3518 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3519 3520 body := io.TeeReader(errorBody, ringBuffer) 3521 decoder := json.NewDecoder(body) 3522 decoder.UseNumber() 3523 code, message, err := restjson.GetErrorInfo(decoder) 3524 if err != nil { 3525 var snapshot bytes.Buffer 3526 io.Copy(&snapshot, ringBuffer) 3527 err = &smithy.DeserializationError{ 3528 Err: fmt.Errorf("failed to decode response body, %w", err), 3529 Snapshot: snapshot.Bytes(), 3530 } 3531 return err 3532 } 3533 3534 errorBody.Seek(0, io.SeekStart) 3535 if len(code) != 0 { 3536 errorCode = restjson.SanitizeErrorCode(code) 3537 } 3538 if len(message) != 0 { 3539 errorMessage = message 3540 } 3541 3542 switch { 3543 case strings.EqualFold("AccessDeniedException", errorCode): 3544 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3545 3546 case strings.EqualFold("InvalidParameterValuesException", errorCode): 3547 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 3548 3549 case strings.EqualFold("InvalidResourceStateException", errorCode): 3550 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 3551 3552 case strings.EqualFold("OperationNotSupportedException", errorCode): 3553 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 3554 3555 case strings.EqualFold("ResourceNotFoundException", errorCode): 3556 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3557 3558 default: 3559 genericError := &smithy.GenericAPIError{ 3560 Code: errorCode, 3561 Message: errorMessage, 3562 } 3563 return genericError 3564 3565 } 3566} 3567 3568type awsAwsjson11_deserializeOpDisassociateIpGroups struct { 3569} 3570 3571func (*awsAwsjson11_deserializeOpDisassociateIpGroups) ID() string { 3572 return "OperationDeserializer" 3573} 3574 3575func (m *awsAwsjson11_deserializeOpDisassociateIpGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3576 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3577) { 3578 out, metadata, err = next.HandleDeserialize(ctx, in) 3579 if err != nil { 3580 return out, metadata, err 3581 } 3582 3583 response, ok := out.RawResponse.(*smithyhttp.Response) 3584 if !ok { 3585 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3586 } 3587 3588 if response.StatusCode < 200 || response.StatusCode >= 300 { 3589 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateIpGroups(response, &metadata) 3590 } 3591 output := &DisassociateIpGroupsOutput{} 3592 out.Result = output 3593 3594 var buff [1024]byte 3595 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3596 3597 body := io.TeeReader(response.Body, ringBuffer) 3598 decoder := json.NewDecoder(body) 3599 decoder.UseNumber() 3600 var shape interface{} 3601 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3602 var snapshot bytes.Buffer 3603 io.Copy(&snapshot, ringBuffer) 3604 err = &smithy.DeserializationError{ 3605 Err: fmt.Errorf("failed to decode response body, %w", err), 3606 Snapshot: snapshot.Bytes(), 3607 } 3608 return out, metadata, err 3609 } 3610 3611 err = awsAwsjson11_deserializeOpDocumentDisassociateIpGroupsOutput(&output, shape) 3612 if err != nil { 3613 var snapshot bytes.Buffer 3614 io.Copy(&snapshot, ringBuffer) 3615 err = &smithy.DeserializationError{ 3616 Err: fmt.Errorf("failed to decode response body, %w", err), 3617 Snapshot: snapshot.Bytes(), 3618 } 3619 return out, metadata, err 3620 } 3621 3622 return out, metadata, err 3623} 3624 3625func awsAwsjson11_deserializeOpErrorDisassociateIpGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3626 var errorBuffer bytes.Buffer 3627 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3628 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3629 } 3630 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3631 3632 errorCode := "UnknownError" 3633 errorMessage := errorCode 3634 3635 code := response.Header.Get("X-Amzn-ErrorType") 3636 if len(code) != 0 { 3637 errorCode = restjson.SanitizeErrorCode(code) 3638 } 3639 3640 var buff [1024]byte 3641 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3642 3643 body := io.TeeReader(errorBody, ringBuffer) 3644 decoder := json.NewDecoder(body) 3645 decoder.UseNumber() 3646 code, message, err := restjson.GetErrorInfo(decoder) 3647 if err != nil { 3648 var snapshot bytes.Buffer 3649 io.Copy(&snapshot, ringBuffer) 3650 err = &smithy.DeserializationError{ 3651 Err: fmt.Errorf("failed to decode response body, %w", err), 3652 Snapshot: snapshot.Bytes(), 3653 } 3654 return err 3655 } 3656 3657 errorBody.Seek(0, io.SeekStart) 3658 if len(code) != 0 { 3659 errorCode = restjson.SanitizeErrorCode(code) 3660 } 3661 if len(message) != 0 { 3662 errorMessage = message 3663 } 3664 3665 switch { 3666 case strings.EqualFold("AccessDeniedException", errorCode): 3667 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3668 3669 case strings.EqualFold("InvalidParameterValuesException", errorCode): 3670 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 3671 3672 case strings.EqualFold("InvalidResourceStateException", errorCode): 3673 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 3674 3675 case strings.EqualFold("ResourceNotFoundException", errorCode): 3676 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3677 3678 default: 3679 genericError := &smithy.GenericAPIError{ 3680 Code: errorCode, 3681 Message: errorMessage, 3682 } 3683 return genericError 3684 3685 } 3686} 3687 3688type awsAwsjson11_deserializeOpImportWorkspaceImage struct { 3689} 3690 3691func (*awsAwsjson11_deserializeOpImportWorkspaceImage) ID() string { 3692 return "OperationDeserializer" 3693} 3694 3695func (m *awsAwsjson11_deserializeOpImportWorkspaceImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3696 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3697) { 3698 out, metadata, err = next.HandleDeserialize(ctx, in) 3699 if err != nil { 3700 return out, metadata, err 3701 } 3702 3703 response, ok := out.RawResponse.(*smithyhttp.Response) 3704 if !ok { 3705 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3706 } 3707 3708 if response.StatusCode < 200 || response.StatusCode >= 300 { 3709 return out, metadata, awsAwsjson11_deserializeOpErrorImportWorkspaceImage(response, &metadata) 3710 } 3711 output := &ImportWorkspaceImageOutput{} 3712 out.Result = output 3713 3714 var buff [1024]byte 3715 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3716 3717 body := io.TeeReader(response.Body, ringBuffer) 3718 decoder := json.NewDecoder(body) 3719 decoder.UseNumber() 3720 var shape interface{} 3721 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3722 var snapshot bytes.Buffer 3723 io.Copy(&snapshot, ringBuffer) 3724 err = &smithy.DeserializationError{ 3725 Err: fmt.Errorf("failed to decode response body, %w", err), 3726 Snapshot: snapshot.Bytes(), 3727 } 3728 return out, metadata, err 3729 } 3730 3731 err = awsAwsjson11_deserializeOpDocumentImportWorkspaceImageOutput(&output, shape) 3732 if err != nil { 3733 var snapshot bytes.Buffer 3734 io.Copy(&snapshot, ringBuffer) 3735 err = &smithy.DeserializationError{ 3736 Err: fmt.Errorf("failed to decode response body, %w", err), 3737 Snapshot: snapshot.Bytes(), 3738 } 3739 return out, metadata, err 3740 } 3741 3742 return out, metadata, err 3743} 3744 3745func awsAwsjson11_deserializeOpErrorImportWorkspaceImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3746 var errorBuffer bytes.Buffer 3747 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3748 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3749 } 3750 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3751 3752 errorCode := "UnknownError" 3753 errorMessage := errorCode 3754 3755 code := response.Header.Get("X-Amzn-ErrorType") 3756 if len(code) != 0 { 3757 errorCode = restjson.SanitizeErrorCode(code) 3758 } 3759 3760 var buff [1024]byte 3761 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3762 3763 body := io.TeeReader(errorBody, ringBuffer) 3764 decoder := json.NewDecoder(body) 3765 decoder.UseNumber() 3766 code, message, err := restjson.GetErrorInfo(decoder) 3767 if err != nil { 3768 var snapshot bytes.Buffer 3769 io.Copy(&snapshot, ringBuffer) 3770 err = &smithy.DeserializationError{ 3771 Err: fmt.Errorf("failed to decode response body, %w", err), 3772 Snapshot: snapshot.Bytes(), 3773 } 3774 return err 3775 } 3776 3777 errorBody.Seek(0, io.SeekStart) 3778 if len(code) != 0 { 3779 errorCode = restjson.SanitizeErrorCode(code) 3780 } 3781 if len(message) != 0 { 3782 errorMessage = message 3783 } 3784 3785 switch { 3786 case strings.EqualFold("AccessDeniedException", errorCode): 3787 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3788 3789 case strings.EqualFold("InvalidParameterValuesException", errorCode): 3790 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 3791 3792 case strings.EqualFold("OperationNotSupportedException", errorCode): 3793 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 3794 3795 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 3796 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 3797 3798 case strings.EqualFold("ResourceLimitExceededException", errorCode): 3799 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 3800 3801 case strings.EqualFold("ResourceNotFoundException", errorCode): 3802 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3803 3804 default: 3805 genericError := &smithy.GenericAPIError{ 3806 Code: errorCode, 3807 Message: errorMessage, 3808 } 3809 return genericError 3810 3811 } 3812} 3813 3814type awsAwsjson11_deserializeOpListAvailableManagementCidrRanges struct { 3815} 3816 3817func (*awsAwsjson11_deserializeOpListAvailableManagementCidrRanges) ID() string { 3818 return "OperationDeserializer" 3819} 3820 3821func (m *awsAwsjson11_deserializeOpListAvailableManagementCidrRanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3822 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3823) { 3824 out, metadata, err = next.HandleDeserialize(ctx, in) 3825 if err != nil { 3826 return out, metadata, err 3827 } 3828 3829 response, ok := out.RawResponse.(*smithyhttp.Response) 3830 if !ok { 3831 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3832 } 3833 3834 if response.StatusCode < 200 || response.StatusCode >= 300 { 3835 return out, metadata, awsAwsjson11_deserializeOpErrorListAvailableManagementCidrRanges(response, &metadata) 3836 } 3837 output := &ListAvailableManagementCidrRangesOutput{} 3838 out.Result = output 3839 3840 var buff [1024]byte 3841 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3842 3843 body := io.TeeReader(response.Body, ringBuffer) 3844 decoder := json.NewDecoder(body) 3845 decoder.UseNumber() 3846 var shape interface{} 3847 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3848 var snapshot bytes.Buffer 3849 io.Copy(&snapshot, ringBuffer) 3850 err = &smithy.DeserializationError{ 3851 Err: fmt.Errorf("failed to decode response body, %w", err), 3852 Snapshot: snapshot.Bytes(), 3853 } 3854 return out, metadata, err 3855 } 3856 3857 err = awsAwsjson11_deserializeOpDocumentListAvailableManagementCidrRangesOutput(&output, shape) 3858 if err != nil { 3859 var snapshot bytes.Buffer 3860 io.Copy(&snapshot, ringBuffer) 3861 err = &smithy.DeserializationError{ 3862 Err: fmt.Errorf("failed to decode response body, %w", err), 3863 Snapshot: snapshot.Bytes(), 3864 } 3865 return out, metadata, err 3866 } 3867 3868 return out, metadata, err 3869} 3870 3871func awsAwsjson11_deserializeOpErrorListAvailableManagementCidrRanges(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3872 var errorBuffer bytes.Buffer 3873 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3874 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3875 } 3876 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3877 3878 errorCode := "UnknownError" 3879 errorMessage := errorCode 3880 3881 code := response.Header.Get("X-Amzn-ErrorType") 3882 if len(code) != 0 { 3883 errorCode = restjson.SanitizeErrorCode(code) 3884 } 3885 3886 var buff [1024]byte 3887 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3888 3889 body := io.TeeReader(errorBody, ringBuffer) 3890 decoder := json.NewDecoder(body) 3891 decoder.UseNumber() 3892 code, message, err := restjson.GetErrorInfo(decoder) 3893 if err != nil { 3894 var snapshot bytes.Buffer 3895 io.Copy(&snapshot, ringBuffer) 3896 err = &smithy.DeserializationError{ 3897 Err: fmt.Errorf("failed to decode response body, %w", err), 3898 Snapshot: snapshot.Bytes(), 3899 } 3900 return err 3901 } 3902 3903 errorBody.Seek(0, io.SeekStart) 3904 if len(code) != 0 { 3905 errorCode = restjson.SanitizeErrorCode(code) 3906 } 3907 if len(message) != 0 { 3908 errorMessage = message 3909 } 3910 3911 switch { 3912 case strings.EqualFold("AccessDeniedException", errorCode): 3913 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3914 3915 case strings.EqualFold("InvalidParameterValuesException", errorCode): 3916 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 3917 3918 default: 3919 genericError := &smithy.GenericAPIError{ 3920 Code: errorCode, 3921 Message: errorMessage, 3922 } 3923 return genericError 3924 3925 } 3926} 3927 3928type awsAwsjson11_deserializeOpMigrateWorkspace struct { 3929} 3930 3931func (*awsAwsjson11_deserializeOpMigrateWorkspace) ID() string { 3932 return "OperationDeserializer" 3933} 3934 3935func (m *awsAwsjson11_deserializeOpMigrateWorkspace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3936 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3937) { 3938 out, metadata, err = next.HandleDeserialize(ctx, in) 3939 if err != nil { 3940 return out, metadata, err 3941 } 3942 3943 response, ok := out.RawResponse.(*smithyhttp.Response) 3944 if !ok { 3945 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3946 } 3947 3948 if response.StatusCode < 200 || response.StatusCode >= 300 { 3949 return out, metadata, awsAwsjson11_deserializeOpErrorMigrateWorkspace(response, &metadata) 3950 } 3951 output := &MigrateWorkspaceOutput{} 3952 out.Result = output 3953 3954 var buff [1024]byte 3955 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3956 3957 body := io.TeeReader(response.Body, ringBuffer) 3958 decoder := json.NewDecoder(body) 3959 decoder.UseNumber() 3960 var shape interface{} 3961 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3962 var snapshot bytes.Buffer 3963 io.Copy(&snapshot, ringBuffer) 3964 err = &smithy.DeserializationError{ 3965 Err: fmt.Errorf("failed to decode response body, %w", err), 3966 Snapshot: snapshot.Bytes(), 3967 } 3968 return out, metadata, err 3969 } 3970 3971 err = awsAwsjson11_deserializeOpDocumentMigrateWorkspaceOutput(&output, shape) 3972 if err != nil { 3973 var snapshot bytes.Buffer 3974 io.Copy(&snapshot, ringBuffer) 3975 err = &smithy.DeserializationError{ 3976 Err: fmt.Errorf("failed to decode response body, %w", err), 3977 Snapshot: snapshot.Bytes(), 3978 } 3979 return out, metadata, err 3980 } 3981 3982 return out, metadata, err 3983} 3984 3985func awsAwsjson11_deserializeOpErrorMigrateWorkspace(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3986 var errorBuffer bytes.Buffer 3987 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3988 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3989 } 3990 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3991 3992 errorCode := "UnknownError" 3993 errorMessage := errorCode 3994 3995 code := response.Header.Get("X-Amzn-ErrorType") 3996 if len(code) != 0 { 3997 errorCode = restjson.SanitizeErrorCode(code) 3998 } 3999 4000 var buff [1024]byte 4001 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4002 4003 body := io.TeeReader(errorBody, ringBuffer) 4004 decoder := json.NewDecoder(body) 4005 decoder.UseNumber() 4006 code, message, err := restjson.GetErrorInfo(decoder) 4007 if err != nil { 4008 var snapshot bytes.Buffer 4009 io.Copy(&snapshot, ringBuffer) 4010 err = &smithy.DeserializationError{ 4011 Err: fmt.Errorf("failed to decode response body, %w", err), 4012 Snapshot: snapshot.Bytes(), 4013 } 4014 return err 4015 } 4016 4017 errorBody.Seek(0, io.SeekStart) 4018 if len(code) != 0 { 4019 errorCode = restjson.SanitizeErrorCode(code) 4020 } 4021 if len(message) != 0 { 4022 errorMessage = message 4023 } 4024 4025 switch { 4026 case strings.EqualFold("AccessDeniedException", errorCode): 4027 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4028 4029 case strings.EqualFold("InvalidParameterValuesException", errorCode): 4030 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 4031 4032 case strings.EqualFold("OperationInProgressException", errorCode): 4033 return awsAwsjson11_deserializeErrorOperationInProgressException(response, errorBody) 4034 4035 case strings.EqualFold("OperationNotSupportedException", errorCode): 4036 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 4037 4038 case strings.EqualFold("ResourceNotFoundException", errorCode): 4039 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4040 4041 case strings.EqualFold("ResourceUnavailableException", errorCode): 4042 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 4043 4044 default: 4045 genericError := &smithy.GenericAPIError{ 4046 Code: errorCode, 4047 Message: errorMessage, 4048 } 4049 return genericError 4050 4051 } 4052} 4053 4054type awsAwsjson11_deserializeOpModifyAccount struct { 4055} 4056 4057func (*awsAwsjson11_deserializeOpModifyAccount) ID() string { 4058 return "OperationDeserializer" 4059} 4060 4061func (m *awsAwsjson11_deserializeOpModifyAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4062 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4063) { 4064 out, metadata, err = next.HandleDeserialize(ctx, in) 4065 if err != nil { 4066 return out, metadata, err 4067 } 4068 4069 response, ok := out.RawResponse.(*smithyhttp.Response) 4070 if !ok { 4071 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4072 } 4073 4074 if response.StatusCode < 200 || response.StatusCode >= 300 { 4075 return out, metadata, awsAwsjson11_deserializeOpErrorModifyAccount(response, &metadata) 4076 } 4077 output := &ModifyAccountOutput{} 4078 out.Result = output 4079 4080 var buff [1024]byte 4081 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4082 4083 body := io.TeeReader(response.Body, ringBuffer) 4084 decoder := json.NewDecoder(body) 4085 decoder.UseNumber() 4086 var shape interface{} 4087 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4088 var snapshot bytes.Buffer 4089 io.Copy(&snapshot, ringBuffer) 4090 err = &smithy.DeserializationError{ 4091 Err: fmt.Errorf("failed to decode response body, %w", err), 4092 Snapshot: snapshot.Bytes(), 4093 } 4094 return out, metadata, err 4095 } 4096 4097 err = awsAwsjson11_deserializeOpDocumentModifyAccountOutput(&output, shape) 4098 if err != nil { 4099 var snapshot bytes.Buffer 4100 io.Copy(&snapshot, ringBuffer) 4101 err = &smithy.DeserializationError{ 4102 Err: fmt.Errorf("failed to decode response body, %w", err), 4103 Snapshot: snapshot.Bytes(), 4104 } 4105 return out, metadata, err 4106 } 4107 4108 return out, metadata, err 4109} 4110 4111func awsAwsjson11_deserializeOpErrorModifyAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4112 var errorBuffer bytes.Buffer 4113 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4114 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4115 } 4116 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4117 4118 errorCode := "UnknownError" 4119 errorMessage := errorCode 4120 4121 code := response.Header.Get("X-Amzn-ErrorType") 4122 if len(code) != 0 { 4123 errorCode = restjson.SanitizeErrorCode(code) 4124 } 4125 4126 var buff [1024]byte 4127 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4128 4129 body := io.TeeReader(errorBody, ringBuffer) 4130 decoder := json.NewDecoder(body) 4131 decoder.UseNumber() 4132 code, message, err := restjson.GetErrorInfo(decoder) 4133 if err != nil { 4134 var snapshot bytes.Buffer 4135 io.Copy(&snapshot, ringBuffer) 4136 err = &smithy.DeserializationError{ 4137 Err: fmt.Errorf("failed to decode response body, %w", err), 4138 Snapshot: snapshot.Bytes(), 4139 } 4140 return err 4141 } 4142 4143 errorBody.Seek(0, io.SeekStart) 4144 if len(code) != 0 { 4145 errorCode = restjson.SanitizeErrorCode(code) 4146 } 4147 if len(message) != 0 { 4148 errorMessage = message 4149 } 4150 4151 switch { 4152 case strings.EqualFold("AccessDeniedException", errorCode): 4153 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4154 4155 case strings.EqualFold("InvalidParameterValuesException", errorCode): 4156 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 4157 4158 case strings.EqualFold("InvalidResourceStateException", errorCode): 4159 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 4160 4161 case strings.EqualFold("ResourceNotFoundException", errorCode): 4162 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4163 4164 case strings.EqualFold("ResourceUnavailableException", errorCode): 4165 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 4166 4167 default: 4168 genericError := &smithy.GenericAPIError{ 4169 Code: errorCode, 4170 Message: errorMessage, 4171 } 4172 return genericError 4173 4174 } 4175} 4176 4177type awsAwsjson11_deserializeOpModifyClientProperties struct { 4178} 4179 4180func (*awsAwsjson11_deserializeOpModifyClientProperties) ID() string { 4181 return "OperationDeserializer" 4182} 4183 4184func (m *awsAwsjson11_deserializeOpModifyClientProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4185 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4186) { 4187 out, metadata, err = next.HandleDeserialize(ctx, in) 4188 if err != nil { 4189 return out, metadata, err 4190 } 4191 4192 response, ok := out.RawResponse.(*smithyhttp.Response) 4193 if !ok { 4194 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4195 } 4196 4197 if response.StatusCode < 200 || response.StatusCode >= 300 { 4198 return out, metadata, awsAwsjson11_deserializeOpErrorModifyClientProperties(response, &metadata) 4199 } 4200 output := &ModifyClientPropertiesOutput{} 4201 out.Result = output 4202 4203 var buff [1024]byte 4204 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4205 4206 body := io.TeeReader(response.Body, ringBuffer) 4207 decoder := json.NewDecoder(body) 4208 decoder.UseNumber() 4209 var shape interface{} 4210 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4211 var snapshot bytes.Buffer 4212 io.Copy(&snapshot, ringBuffer) 4213 err = &smithy.DeserializationError{ 4214 Err: fmt.Errorf("failed to decode response body, %w", err), 4215 Snapshot: snapshot.Bytes(), 4216 } 4217 return out, metadata, err 4218 } 4219 4220 err = awsAwsjson11_deserializeOpDocumentModifyClientPropertiesOutput(&output, shape) 4221 if err != nil { 4222 var snapshot bytes.Buffer 4223 io.Copy(&snapshot, ringBuffer) 4224 err = &smithy.DeserializationError{ 4225 Err: fmt.Errorf("failed to decode response body, %w", err), 4226 Snapshot: snapshot.Bytes(), 4227 } 4228 return out, metadata, err 4229 } 4230 4231 return out, metadata, err 4232} 4233 4234func awsAwsjson11_deserializeOpErrorModifyClientProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4235 var errorBuffer bytes.Buffer 4236 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4237 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4238 } 4239 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4240 4241 errorCode := "UnknownError" 4242 errorMessage := errorCode 4243 4244 code := response.Header.Get("X-Amzn-ErrorType") 4245 if len(code) != 0 { 4246 errorCode = restjson.SanitizeErrorCode(code) 4247 } 4248 4249 var buff [1024]byte 4250 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4251 4252 body := io.TeeReader(errorBody, ringBuffer) 4253 decoder := json.NewDecoder(body) 4254 decoder.UseNumber() 4255 code, message, err := restjson.GetErrorInfo(decoder) 4256 if err != nil { 4257 var snapshot bytes.Buffer 4258 io.Copy(&snapshot, ringBuffer) 4259 err = &smithy.DeserializationError{ 4260 Err: fmt.Errorf("failed to decode response body, %w", err), 4261 Snapshot: snapshot.Bytes(), 4262 } 4263 return err 4264 } 4265 4266 errorBody.Seek(0, io.SeekStart) 4267 if len(code) != 0 { 4268 errorCode = restjson.SanitizeErrorCode(code) 4269 } 4270 if len(message) != 0 { 4271 errorMessage = message 4272 } 4273 4274 switch { 4275 case strings.EqualFold("AccessDeniedException", errorCode): 4276 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4277 4278 case strings.EqualFold("InvalidParameterValuesException", errorCode): 4279 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 4280 4281 case strings.EqualFold("ResourceNotFoundException", errorCode): 4282 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4283 4284 default: 4285 genericError := &smithy.GenericAPIError{ 4286 Code: errorCode, 4287 Message: errorMessage, 4288 } 4289 return genericError 4290 4291 } 4292} 4293 4294type awsAwsjson11_deserializeOpModifySelfservicePermissions struct { 4295} 4296 4297func (*awsAwsjson11_deserializeOpModifySelfservicePermissions) ID() string { 4298 return "OperationDeserializer" 4299} 4300 4301func (m *awsAwsjson11_deserializeOpModifySelfservicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4302 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4303) { 4304 out, metadata, err = next.HandleDeserialize(ctx, in) 4305 if err != nil { 4306 return out, metadata, err 4307 } 4308 4309 response, ok := out.RawResponse.(*smithyhttp.Response) 4310 if !ok { 4311 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4312 } 4313 4314 if response.StatusCode < 200 || response.StatusCode >= 300 { 4315 return out, metadata, awsAwsjson11_deserializeOpErrorModifySelfservicePermissions(response, &metadata) 4316 } 4317 output := &ModifySelfservicePermissionsOutput{} 4318 out.Result = output 4319 4320 var buff [1024]byte 4321 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4322 4323 body := io.TeeReader(response.Body, ringBuffer) 4324 decoder := json.NewDecoder(body) 4325 decoder.UseNumber() 4326 var shape interface{} 4327 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4328 var snapshot bytes.Buffer 4329 io.Copy(&snapshot, ringBuffer) 4330 err = &smithy.DeserializationError{ 4331 Err: fmt.Errorf("failed to decode response body, %w", err), 4332 Snapshot: snapshot.Bytes(), 4333 } 4334 return out, metadata, err 4335 } 4336 4337 err = awsAwsjson11_deserializeOpDocumentModifySelfservicePermissionsOutput(&output, shape) 4338 if err != nil { 4339 var snapshot bytes.Buffer 4340 io.Copy(&snapshot, ringBuffer) 4341 err = &smithy.DeserializationError{ 4342 Err: fmt.Errorf("failed to decode response body, %w", err), 4343 Snapshot: snapshot.Bytes(), 4344 } 4345 return out, metadata, err 4346 } 4347 4348 return out, metadata, err 4349} 4350 4351func awsAwsjson11_deserializeOpErrorModifySelfservicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4352 var errorBuffer bytes.Buffer 4353 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4354 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4355 } 4356 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4357 4358 errorCode := "UnknownError" 4359 errorMessage := errorCode 4360 4361 code := response.Header.Get("X-Amzn-ErrorType") 4362 if len(code) != 0 { 4363 errorCode = restjson.SanitizeErrorCode(code) 4364 } 4365 4366 var buff [1024]byte 4367 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4368 4369 body := io.TeeReader(errorBody, ringBuffer) 4370 decoder := json.NewDecoder(body) 4371 decoder.UseNumber() 4372 code, message, err := restjson.GetErrorInfo(decoder) 4373 if err != nil { 4374 var snapshot bytes.Buffer 4375 io.Copy(&snapshot, ringBuffer) 4376 err = &smithy.DeserializationError{ 4377 Err: fmt.Errorf("failed to decode response body, %w", err), 4378 Snapshot: snapshot.Bytes(), 4379 } 4380 return err 4381 } 4382 4383 errorBody.Seek(0, io.SeekStart) 4384 if len(code) != 0 { 4385 errorCode = restjson.SanitizeErrorCode(code) 4386 } 4387 if len(message) != 0 { 4388 errorMessage = message 4389 } 4390 4391 switch { 4392 case strings.EqualFold("AccessDeniedException", errorCode): 4393 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4394 4395 case strings.EqualFold("InvalidParameterValuesException", errorCode): 4396 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 4397 4398 case strings.EqualFold("ResourceNotFoundException", errorCode): 4399 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4400 4401 default: 4402 genericError := &smithy.GenericAPIError{ 4403 Code: errorCode, 4404 Message: errorMessage, 4405 } 4406 return genericError 4407 4408 } 4409} 4410 4411type awsAwsjson11_deserializeOpModifyWorkspaceAccessProperties struct { 4412} 4413 4414func (*awsAwsjson11_deserializeOpModifyWorkspaceAccessProperties) ID() string { 4415 return "OperationDeserializer" 4416} 4417 4418func (m *awsAwsjson11_deserializeOpModifyWorkspaceAccessProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4419 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4420) { 4421 out, metadata, err = next.HandleDeserialize(ctx, in) 4422 if err != nil { 4423 return out, metadata, err 4424 } 4425 4426 response, ok := out.RawResponse.(*smithyhttp.Response) 4427 if !ok { 4428 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4429 } 4430 4431 if response.StatusCode < 200 || response.StatusCode >= 300 { 4432 return out, metadata, awsAwsjson11_deserializeOpErrorModifyWorkspaceAccessProperties(response, &metadata) 4433 } 4434 output := &ModifyWorkspaceAccessPropertiesOutput{} 4435 out.Result = output 4436 4437 var buff [1024]byte 4438 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4439 4440 body := io.TeeReader(response.Body, ringBuffer) 4441 decoder := json.NewDecoder(body) 4442 decoder.UseNumber() 4443 var shape interface{} 4444 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4445 var snapshot bytes.Buffer 4446 io.Copy(&snapshot, ringBuffer) 4447 err = &smithy.DeserializationError{ 4448 Err: fmt.Errorf("failed to decode response body, %w", err), 4449 Snapshot: snapshot.Bytes(), 4450 } 4451 return out, metadata, err 4452 } 4453 4454 err = awsAwsjson11_deserializeOpDocumentModifyWorkspaceAccessPropertiesOutput(&output, shape) 4455 if err != nil { 4456 var snapshot bytes.Buffer 4457 io.Copy(&snapshot, ringBuffer) 4458 err = &smithy.DeserializationError{ 4459 Err: fmt.Errorf("failed to decode response body, %w", err), 4460 Snapshot: snapshot.Bytes(), 4461 } 4462 return out, metadata, err 4463 } 4464 4465 return out, metadata, err 4466} 4467 4468func awsAwsjson11_deserializeOpErrorModifyWorkspaceAccessProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4469 var errorBuffer bytes.Buffer 4470 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4471 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4472 } 4473 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4474 4475 errorCode := "UnknownError" 4476 errorMessage := errorCode 4477 4478 code := response.Header.Get("X-Amzn-ErrorType") 4479 if len(code) != 0 { 4480 errorCode = restjson.SanitizeErrorCode(code) 4481 } 4482 4483 var buff [1024]byte 4484 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4485 4486 body := io.TeeReader(errorBody, ringBuffer) 4487 decoder := json.NewDecoder(body) 4488 decoder.UseNumber() 4489 code, message, err := restjson.GetErrorInfo(decoder) 4490 if err != nil { 4491 var snapshot bytes.Buffer 4492 io.Copy(&snapshot, ringBuffer) 4493 err = &smithy.DeserializationError{ 4494 Err: fmt.Errorf("failed to decode response body, %w", err), 4495 Snapshot: snapshot.Bytes(), 4496 } 4497 return err 4498 } 4499 4500 errorBody.Seek(0, io.SeekStart) 4501 if len(code) != 0 { 4502 errorCode = restjson.SanitizeErrorCode(code) 4503 } 4504 if len(message) != 0 { 4505 errorMessage = message 4506 } 4507 4508 switch { 4509 case strings.EqualFold("AccessDeniedException", errorCode): 4510 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4511 4512 case strings.EqualFold("ResourceNotFoundException", errorCode): 4513 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4514 4515 default: 4516 genericError := &smithy.GenericAPIError{ 4517 Code: errorCode, 4518 Message: errorMessage, 4519 } 4520 return genericError 4521 4522 } 4523} 4524 4525type awsAwsjson11_deserializeOpModifyWorkspaceCreationProperties struct { 4526} 4527 4528func (*awsAwsjson11_deserializeOpModifyWorkspaceCreationProperties) ID() string { 4529 return "OperationDeserializer" 4530} 4531 4532func (m *awsAwsjson11_deserializeOpModifyWorkspaceCreationProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4533 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4534) { 4535 out, metadata, err = next.HandleDeserialize(ctx, in) 4536 if err != nil { 4537 return out, metadata, err 4538 } 4539 4540 response, ok := out.RawResponse.(*smithyhttp.Response) 4541 if !ok { 4542 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4543 } 4544 4545 if response.StatusCode < 200 || response.StatusCode >= 300 { 4546 return out, metadata, awsAwsjson11_deserializeOpErrorModifyWorkspaceCreationProperties(response, &metadata) 4547 } 4548 output := &ModifyWorkspaceCreationPropertiesOutput{} 4549 out.Result = output 4550 4551 var buff [1024]byte 4552 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4553 4554 body := io.TeeReader(response.Body, ringBuffer) 4555 decoder := json.NewDecoder(body) 4556 decoder.UseNumber() 4557 var shape interface{} 4558 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4559 var snapshot bytes.Buffer 4560 io.Copy(&snapshot, ringBuffer) 4561 err = &smithy.DeserializationError{ 4562 Err: fmt.Errorf("failed to decode response body, %w", err), 4563 Snapshot: snapshot.Bytes(), 4564 } 4565 return out, metadata, err 4566 } 4567 4568 err = awsAwsjson11_deserializeOpDocumentModifyWorkspaceCreationPropertiesOutput(&output, shape) 4569 if err != nil { 4570 var snapshot bytes.Buffer 4571 io.Copy(&snapshot, ringBuffer) 4572 err = &smithy.DeserializationError{ 4573 Err: fmt.Errorf("failed to decode response body, %w", err), 4574 Snapshot: snapshot.Bytes(), 4575 } 4576 return out, metadata, err 4577 } 4578 4579 return out, metadata, err 4580} 4581 4582func awsAwsjson11_deserializeOpErrorModifyWorkspaceCreationProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4583 var errorBuffer bytes.Buffer 4584 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4585 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4586 } 4587 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4588 4589 errorCode := "UnknownError" 4590 errorMessage := errorCode 4591 4592 code := response.Header.Get("X-Amzn-ErrorType") 4593 if len(code) != 0 { 4594 errorCode = restjson.SanitizeErrorCode(code) 4595 } 4596 4597 var buff [1024]byte 4598 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4599 4600 body := io.TeeReader(errorBody, ringBuffer) 4601 decoder := json.NewDecoder(body) 4602 decoder.UseNumber() 4603 code, message, err := restjson.GetErrorInfo(decoder) 4604 if err != nil { 4605 var snapshot bytes.Buffer 4606 io.Copy(&snapshot, ringBuffer) 4607 err = &smithy.DeserializationError{ 4608 Err: fmt.Errorf("failed to decode response body, %w", err), 4609 Snapshot: snapshot.Bytes(), 4610 } 4611 return err 4612 } 4613 4614 errorBody.Seek(0, io.SeekStart) 4615 if len(code) != 0 { 4616 errorCode = restjson.SanitizeErrorCode(code) 4617 } 4618 if len(message) != 0 { 4619 errorMessage = message 4620 } 4621 4622 switch { 4623 case strings.EqualFold("AccessDeniedException", errorCode): 4624 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4625 4626 case strings.EqualFold("InvalidParameterValuesException", errorCode): 4627 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 4628 4629 case strings.EqualFold("OperationNotSupportedException", errorCode): 4630 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 4631 4632 case strings.EqualFold("ResourceNotFoundException", errorCode): 4633 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4634 4635 default: 4636 genericError := &smithy.GenericAPIError{ 4637 Code: errorCode, 4638 Message: errorMessage, 4639 } 4640 return genericError 4641 4642 } 4643} 4644 4645type awsAwsjson11_deserializeOpModifyWorkspaceProperties struct { 4646} 4647 4648func (*awsAwsjson11_deserializeOpModifyWorkspaceProperties) ID() string { 4649 return "OperationDeserializer" 4650} 4651 4652func (m *awsAwsjson11_deserializeOpModifyWorkspaceProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4653 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4654) { 4655 out, metadata, err = next.HandleDeserialize(ctx, in) 4656 if err != nil { 4657 return out, metadata, err 4658 } 4659 4660 response, ok := out.RawResponse.(*smithyhttp.Response) 4661 if !ok { 4662 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4663 } 4664 4665 if response.StatusCode < 200 || response.StatusCode >= 300 { 4666 return out, metadata, awsAwsjson11_deserializeOpErrorModifyWorkspaceProperties(response, &metadata) 4667 } 4668 output := &ModifyWorkspacePropertiesOutput{} 4669 out.Result = output 4670 4671 var buff [1024]byte 4672 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4673 4674 body := io.TeeReader(response.Body, ringBuffer) 4675 decoder := json.NewDecoder(body) 4676 decoder.UseNumber() 4677 var shape interface{} 4678 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4679 var snapshot bytes.Buffer 4680 io.Copy(&snapshot, ringBuffer) 4681 err = &smithy.DeserializationError{ 4682 Err: fmt.Errorf("failed to decode response body, %w", err), 4683 Snapshot: snapshot.Bytes(), 4684 } 4685 return out, metadata, err 4686 } 4687 4688 err = awsAwsjson11_deserializeOpDocumentModifyWorkspacePropertiesOutput(&output, shape) 4689 if err != nil { 4690 var snapshot bytes.Buffer 4691 io.Copy(&snapshot, ringBuffer) 4692 err = &smithy.DeserializationError{ 4693 Err: fmt.Errorf("failed to decode response body, %w", err), 4694 Snapshot: snapshot.Bytes(), 4695 } 4696 return out, metadata, err 4697 } 4698 4699 return out, metadata, err 4700} 4701 4702func awsAwsjson11_deserializeOpErrorModifyWorkspaceProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4703 var errorBuffer bytes.Buffer 4704 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4705 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4706 } 4707 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4708 4709 errorCode := "UnknownError" 4710 errorMessage := errorCode 4711 4712 code := response.Header.Get("X-Amzn-ErrorType") 4713 if len(code) != 0 { 4714 errorCode = restjson.SanitizeErrorCode(code) 4715 } 4716 4717 var buff [1024]byte 4718 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4719 4720 body := io.TeeReader(errorBody, ringBuffer) 4721 decoder := json.NewDecoder(body) 4722 decoder.UseNumber() 4723 code, message, err := restjson.GetErrorInfo(decoder) 4724 if err != nil { 4725 var snapshot bytes.Buffer 4726 io.Copy(&snapshot, ringBuffer) 4727 err = &smithy.DeserializationError{ 4728 Err: fmt.Errorf("failed to decode response body, %w", err), 4729 Snapshot: snapshot.Bytes(), 4730 } 4731 return err 4732 } 4733 4734 errorBody.Seek(0, io.SeekStart) 4735 if len(code) != 0 { 4736 errorCode = restjson.SanitizeErrorCode(code) 4737 } 4738 if len(message) != 0 { 4739 errorMessage = message 4740 } 4741 4742 switch { 4743 case strings.EqualFold("AccessDeniedException", errorCode): 4744 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4745 4746 case strings.EqualFold("InvalidParameterValuesException", errorCode): 4747 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 4748 4749 case strings.EqualFold("InvalidResourceStateException", errorCode): 4750 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 4751 4752 case strings.EqualFold("OperationInProgressException", errorCode): 4753 return awsAwsjson11_deserializeErrorOperationInProgressException(response, errorBody) 4754 4755 case strings.EqualFold("ResourceNotFoundException", errorCode): 4756 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4757 4758 case strings.EqualFold("ResourceUnavailableException", errorCode): 4759 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 4760 4761 case strings.EqualFold("UnsupportedWorkspaceConfigurationException", errorCode): 4762 return awsAwsjson11_deserializeErrorUnsupportedWorkspaceConfigurationException(response, errorBody) 4763 4764 default: 4765 genericError := &smithy.GenericAPIError{ 4766 Code: errorCode, 4767 Message: errorMessage, 4768 } 4769 return genericError 4770 4771 } 4772} 4773 4774type awsAwsjson11_deserializeOpModifyWorkspaceState struct { 4775} 4776 4777func (*awsAwsjson11_deserializeOpModifyWorkspaceState) ID() string { 4778 return "OperationDeserializer" 4779} 4780 4781func (m *awsAwsjson11_deserializeOpModifyWorkspaceState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4782 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4783) { 4784 out, metadata, err = next.HandleDeserialize(ctx, in) 4785 if err != nil { 4786 return out, metadata, err 4787 } 4788 4789 response, ok := out.RawResponse.(*smithyhttp.Response) 4790 if !ok { 4791 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4792 } 4793 4794 if response.StatusCode < 200 || response.StatusCode >= 300 { 4795 return out, metadata, awsAwsjson11_deserializeOpErrorModifyWorkspaceState(response, &metadata) 4796 } 4797 output := &ModifyWorkspaceStateOutput{} 4798 out.Result = output 4799 4800 var buff [1024]byte 4801 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4802 4803 body := io.TeeReader(response.Body, ringBuffer) 4804 decoder := json.NewDecoder(body) 4805 decoder.UseNumber() 4806 var shape interface{} 4807 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4808 var snapshot bytes.Buffer 4809 io.Copy(&snapshot, ringBuffer) 4810 err = &smithy.DeserializationError{ 4811 Err: fmt.Errorf("failed to decode response body, %w", err), 4812 Snapshot: snapshot.Bytes(), 4813 } 4814 return out, metadata, err 4815 } 4816 4817 err = awsAwsjson11_deserializeOpDocumentModifyWorkspaceStateOutput(&output, shape) 4818 if err != nil { 4819 var snapshot bytes.Buffer 4820 io.Copy(&snapshot, ringBuffer) 4821 err = &smithy.DeserializationError{ 4822 Err: fmt.Errorf("failed to decode response body, %w", err), 4823 Snapshot: snapshot.Bytes(), 4824 } 4825 return out, metadata, err 4826 } 4827 4828 return out, metadata, err 4829} 4830 4831func awsAwsjson11_deserializeOpErrorModifyWorkspaceState(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4832 var errorBuffer bytes.Buffer 4833 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4834 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4835 } 4836 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4837 4838 errorCode := "UnknownError" 4839 errorMessage := errorCode 4840 4841 code := response.Header.Get("X-Amzn-ErrorType") 4842 if len(code) != 0 { 4843 errorCode = restjson.SanitizeErrorCode(code) 4844 } 4845 4846 var buff [1024]byte 4847 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4848 4849 body := io.TeeReader(errorBody, ringBuffer) 4850 decoder := json.NewDecoder(body) 4851 decoder.UseNumber() 4852 code, message, err := restjson.GetErrorInfo(decoder) 4853 if err != nil { 4854 var snapshot bytes.Buffer 4855 io.Copy(&snapshot, ringBuffer) 4856 err = &smithy.DeserializationError{ 4857 Err: fmt.Errorf("failed to decode response body, %w", err), 4858 Snapshot: snapshot.Bytes(), 4859 } 4860 return err 4861 } 4862 4863 errorBody.Seek(0, io.SeekStart) 4864 if len(code) != 0 { 4865 errorCode = restjson.SanitizeErrorCode(code) 4866 } 4867 if len(message) != 0 { 4868 errorMessage = message 4869 } 4870 4871 switch { 4872 case strings.EqualFold("InvalidParameterValuesException", errorCode): 4873 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 4874 4875 case strings.EqualFold("InvalidResourceStateException", errorCode): 4876 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 4877 4878 case strings.EqualFold("ResourceNotFoundException", errorCode): 4879 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4880 4881 default: 4882 genericError := &smithy.GenericAPIError{ 4883 Code: errorCode, 4884 Message: errorMessage, 4885 } 4886 return genericError 4887 4888 } 4889} 4890 4891type awsAwsjson11_deserializeOpRebootWorkspaces struct { 4892} 4893 4894func (*awsAwsjson11_deserializeOpRebootWorkspaces) ID() string { 4895 return "OperationDeserializer" 4896} 4897 4898func (m *awsAwsjson11_deserializeOpRebootWorkspaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4899 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4900) { 4901 out, metadata, err = next.HandleDeserialize(ctx, in) 4902 if err != nil { 4903 return out, metadata, err 4904 } 4905 4906 response, ok := out.RawResponse.(*smithyhttp.Response) 4907 if !ok { 4908 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4909 } 4910 4911 if response.StatusCode < 200 || response.StatusCode >= 300 { 4912 return out, metadata, awsAwsjson11_deserializeOpErrorRebootWorkspaces(response, &metadata) 4913 } 4914 output := &RebootWorkspacesOutput{} 4915 out.Result = output 4916 4917 var buff [1024]byte 4918 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4919 4920 body := io.TeeReader(response.Body, ringBuffer) 4921 decoder := json.NewDecoder(body) 4922 decoder.UseNumber() 4923 var shape interface{} 4924 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4925 var snapshot bytes.Buffer 4926 io.Copy(&snapshot, ringBuffer) 4927 err = &smithy.DeserializationError{ 4928 Err: fmt.Errorf("failed to decode response body, %w", err), 4929 Snapshot: snapshot.Bytes(), 4930 } 4931 return out, metadata, err 4932 } 4933 4934 err = awsAwsjson11_deserializeOpDocumentRebootWorkspacesOutput(&output, shape) 4935 if err != nil { 4936 var snapshot bytes.Buffer 4937 io.Copy(&snapshot, ringBuffer) 4938 err = &smithy.DeserializationError{ 4939 Err: fmt.Errorf("failed to decode response body, %w", err), 4940 Snapshot: snapshot.Bytes(), 4941 } 4942 return out, metadata, err 4943 } 4944 4945 return out, metadata, err 4946} 4947 4948func awsAwsjson11_deserializeOpErrorRebootWorkspaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4949 var errorBuffer bytes.Buffer 4950 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4951 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4952 } 4953 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4954 4955 errorCode := "UnknownError" 4956 errorMessage := errorCode 4957 4958 code := response.Header.Get("X-Amzn-ErrorType") 4959 if len(code) != 0 { 4960 errorCode = restjson.SanitizeErrorCode(code) 4961 } 4962 4963 var buff [1024]byte 4964 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4965 4966 body := io.TeeReader(errorBody, ringBuffer) 4967 decoder := json.NewDecoder(body) 4968 decoder.UseNumber() 4969 code, message, err := restjson.GetErrorInfo(decoder) 4970 if err != nil { 4971 var snapshot bytes.Buffer 4972 io.Copy(&snapshot, ringBuffer) 4973 err = &smithy.DeserializationError{ 4974 Err: fmt.Errorf("failed to decode response body, %w", err), 4975 Snapshot: snapshot.Bytes(), 4976 } 4977 return err 4978 } 4979 4980 errorBody.Seek(0, io.SeekStart) 4981 if len(code) != 0 { 4982 errorCode = restjson.SanitizeErrorCode(code) 4983 } 4984 if len(message) != 0 { 4985 errorMessage = message 4986 } 4987 4988 switch { 4989 default: 4990 genericError := &smithy.GenericAPIError{ 4991 Code: errorCode, 4992 Message: errorMessage, 4993 } 4994 return genericError 4995 4996 } 4997} 4998 4999type awsAwsjson11_deserializeOpRebuildWorkspaces struct { 5000} 5001 5002func (*awsAwsjson11_deserializeOpRebuildWorkspaces) ID() string { 5003 return "OperationDeserializer" 5004} 5005 5006func (m *awsAwsjson11_deserializeOpRebuildWorkspaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5007 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5008) { 5009 out, metadata, err = next.HandleDeserialize(ctx, in) 5010 if err != nil { 5011 return out, metadata, err 5012 } 5013 5014 response, ok := out.RawResponse.(*smithyhttp.Response) 5015 if !ok { 5016 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5017 } 5018 5019 if response.StatusCode < 200 || response.StatusCode >= 300 { 5020 return out, metadata, awsAwsjson11_deserializeOpErrorRebuildWorkspaces(response, &metadata) 5021 } 5022 output := &RebuildWorkspacesOutput{} 5023 out.Result = output 5024 5025 var buff [1024]byte 5026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5027 5028 body := io.TeeReader(response.Body, ringBuffer) 5029 decoder := json.NewDecoder(body) 5030 decoder.UseNumber() 5031 var shape interface{} 5032 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5033 var snapshot bytes.Buffer 5034 io.Copy(&snapshot, ringBuffer) 5035 err = &smithy.DeserializationError{ 5036 Err: fmt.Errorf("failed to decode response body, %w", err), 5037 Snapshot: snapshot.Bytes(), 5038 } 5039 return out, metadata, err 5040 } 5041 5042 err = awsAwsjson11_deserializeOpDocumentRebuildWorkspacesOutput(&output, shape) 5043 if err != nil { 5044 var snapshot bytes.Buffer 5045 io.Copy(&snapshot, ringBuffer) 5046 err = &smithy.DeserializationError{ 5047 Err: fmt.Errorf("failed to decode response body, %w", err), 5048 Snapshot: snapshot.Bytes(), 5049 } 5050 return out, metadata, err 5051 } 5052 5053 return out, metadata, err 5054} 5055 5056func awsAwsjson11_deserializeOpErrorRebuildWorkspaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5057 var errorBuffer bytes.Buffer 5058 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5059 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5060 } 5061 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5062 5063 errorCode := "UnknownError" 5064 errorMessage := errorCode 5065 5066 code := response.Header.Get("X-Amzn-ErrorType") 5067 if len(code) != 0 { 5068 errorCode = restjson.SanitizeErrorCode(code) 5069 } 5070 5071 var buff [1024]byte 5072 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5073 5074 body := io.TeeReader(errorBody, ringBuffer) 5075 decoder := json.NewDecoder(body) 5076 decoder.UseNumber() 5077 code, message, err := restjson.GetErrorInfo(decoder) 5078 if err != nil { 5079 var snapshot bytes.Buffer 5080 io.Copy(&snapshot, ringBuffer) 5081 err = &smithy.DeserializationError{ 5082 Err: fmt.Errorf("failed to decode response body, %w", err), 5083 Snapshot: snapshot.Bytes(), 5084 } 5085 return err 5086 } 5087 5088 errorBody.Seek(0, io.SeekStart) 5089 if len(code) != 0 { 5090 errorCode = restjson.SanitizeErrorCode(code) 5091 } 5092 if len(message) != 0 { 5093 errorMessage = message 5094 } 5095 5096 switch { 5097 default: 5098 genericError := &smithy.GenericAPIError{ 5099 Code: errorCode, 5100 Message: errorMessage, 5101 } 5102 return genericError 5103 5104 } 5105} 5106 5107type awsAwsjson11_deserializeOpRegisterWorkspaceDirectory struct { 5108} 5109 5110func (*awsAwsjson11_deserializeOpRegisterWorkspaceDirectory) ID() string { 5111 return "OperationDeserializer" 5112} 5113 5114func (m *awsAwsjson11_deserializeOpRegisterWorkspaceDirectory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5115 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5116) { 5117 out, metadata, err = next.HandleDeserialize(ctx, in) 5118 if err != nil { 5119 return out, metadata, err 5120 } 5121 5122 response, ok := out.RawResponse.(*smithyhttp.Response) 5123 if !ok { 5124 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5125 } 5126 5127 if response.StatusCode < 200 || response.StatusCode >= 300 { 5128 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterWorkspaceDirectory(response, &metadata) 5129 } 5130 output := &RegisterWorkspaceDirectoryOutput{} 5131 out.Result = output 5132 5133 var buff [1024]byte 5134 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5135 5136 body := io.TeeReader(response.Body, ringBuffer) 5137 decoder := json.NewDecoder(body) 5138 decoder.UseNumber() 5139 var shape interface{} 5140 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5141 var snapshot bytes.Buffer 5142 io.Copy(&snapshot, ringBuffer) 5143 err = &smithy.DeserializationError{ 5144 Err: fmt.Errorf("failed to decode response body, %w", err), 5145 Snapshot: snapshot.Bytes(), 5146 } 5147 return out, metadata, err 5148 } 5149 5150 err = awsAwsjson11_deserializeOpDocumentRegisterWorkspaceDirectoryOutput(&output, shape) 5151 if err != nil { 5152 var snapshot bytes.Buffer 5153 io.Copy(&snapshot, ringBuffer) 5154 err = &smithy.DeserializationError{ 5155 Err: fmt.Errorf("failed to decode response body, %w", err), 5156 Snapshot: snapshot.Bytes(), 5157 } 5158 return out, metadata, err 5159 } 5160 5161 return out, metadata, err 5162} 5163 5164func awsAwsjson11_deserializeOpErrorRegisterWorkspaceDirectory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5165 var errorBuffer bytes.Buffer 5166 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5167 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5168 } 5169 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5170 5171 errorCode := "UnknownError" 5172 errorMessage := errorCode 5173 5174 code := response.Header.Get("X-Amzn-ErrorType") 5175 if len(code) != 0 { 5176 errorCode = restjson.SanitizeErrorCode(code) 5177 } 5178 5179 var buff [1024]byte 5180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5181 5182 body := io.TeeReader(errorBody, ringBuffer) 5183 decoder := json.NewDecoder(body) 5184 decoder.UseNumber() 5185 code, message, err := restjson.GetErrorInfo(decoder) 5186 if err != nil { 5187 var snapshot bytes.Buffer 5188 io.Copy(&snapshot, ringBuffer) 5189 err = &smithy.DeserializationError{ 5190 Err: fmt.Errorf("failed to decode response body, %w", err), 5191 Snapshot: snapshot.Bytes(), 5192 } 5193 return err 5194 } 5195 5196 errorBody.Seek(0, io.SeekStart) 5197 if len(code) != 0 { 5198 errorCode = restjson.SanitizeErrorCode(code) 5199 } 5200 if len(message) != 0 { 5201 errorMessage = message 5202 } 5203 5204 switch { 5205 case strings.EqualFold("AccessDeniedException", errorCode): 5206 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5207 5208 case strings.EqualFold("InvalidParameterValuesException", errorCode): 5209 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 5210 5211 case strings.EqualFold("InvalidResourceStateException", errorCode): 5212 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 5213 5214 case strings.EqualFold("OperationNotSupportedException", errorCode): 5215 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 5216 5217 case strings.EqualFold("ResourceLimitExceededException", errorCode): 5218 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 5219 5220 case strings.EqualFold("ResourceNotFoundException", errorCode): 5221 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5222 5223 case strings.EqualFold("UnsupportedNetworkConfigurationException", errorCode): 5224 return awsAwsjson11_deserializeErrorUnsupportedNetworkConfigurationException(response, errorBody) 5225 5226 case strings.EqualFold("WorkspacesDefaultRoleNotFoundException", errorCode): 5227 return awsAwsjson11_deserializeErrorWorkspacesDefaultRoleNotFoundException(response, errorBody) 5228 5229 default: 5230 genericError := &smithy.GenericAPIError{ 5231 Code: errorCode, 5232 Message: errorMessage, 5233 } 5234 return genericError 5235 5236 } 5237} 5238 5239type awsAwsjson11_deserializeOpRestoreWorkspace struct { 5240} 5241 5242func (*awsAwsjson11_deserializeOpRestoreWorkspace) ID() string { 5243 return "OperationDeserializer" 5244} 5245 5246func (m *awsAwsjson11_deserializeOpRestoreWorkspace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5247 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5248) { 5249 out, metadata, err = next.HandleDeserialize(ctx, in) 5250 if err != nil { 5251 return out, metadata, err 5252 } 5253 5254 response, ok := out.RawResponse.(*smithyhttp.Response) 5255 if !ok { 5256 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5257 } 5258 5259 if response.StatusCode < 200 || response.StatusCode >= 300 { 5260 return out, metadata, awsAwsjson11_deserializeOpErrorRestoreWorkspace(response, &metadata) 5261 } 5262 output := &RestoreWorkspaceOutput{} 5263 out.Result = output 5264 5265 var buff [1024]byte 5266 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5267 5268 body := io.TeeReader(response.Body, ringBuffer) 5269 decoder := json.NewDecoder(body) 5270 decoder.UseNumber() 5271 var shape interface{} 5272 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5273 var snapshot bytes.Buffer 5274 io.Copy(&snapshot, ringBuffer) 5275 err = &smithy.DeserializationError{ 5276 Err: fmt.Errorf("failed to decode response body, %w", err), 5277 Snapshot: snapshot.Bytes(), 5278 } 5279 return out, metadata, err 5280 } 5281 5282 err = awsAwsjson11_deserializeOpDocumentRestoreWorkspaceOutput(&output, shape) 5283 if err != nil { 5284 var snapshot bytes.Buffer 5285 io.Copy(&snapshot, ringBuffer) 5286 err = &smithy.DeserializationError{ 5287 Err: fmt.Errorf("failed to decode response body, %w", err), 5288 Snapshot: snapshot.Bytes(), 5289 } 5290 return out, metadata, err 5291 } 5292 5293 return out, metadata, err 5294} 5295 5296func awsAwsjson11_deserializeOpErrorRestoreWorkspace(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5297 var errorBuffer bytes.Buffer 5298 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5299 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5300 } 5301 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5302 5303 errorCode := "UnknownError" 5304 errorMessage := errorCode 5305 5306 code := response.Header.Get("X-Amzn-ErrorType") 5307 if len(code) != 0 { 5308 errorCode = restjson.SanitizeErrorCode(code) 5309 } 5310 5311 var buff [1024]byte 5312 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5313 5314 body := io.TeeReader(errorBody, ringBuffer) 5315 decoder := json.NewDecoder(body) 5316 decoder.UseNumber() 5317 code, message, err := restjson.GetErrorInfo(decoder) 5318 if err != nil { 5319 var snapshot bytes.Buffer 5320 io.Copy(&snapshot, ringBuffer) 5321 err = &smithy.DeserializationError{ 5322 Err: fmt.Errorf("failed to decode response body, %w", err), 5323 Snapshot: snapshot.Bytes(), 5324 } 5325 return err 5326 } 5327 5328 errorBody.Seek(0, io.SeekStart) 5329 if len(code) != 0 { 5330 errorCode = restjson.SanitizeErrorCode(code) 5331 } 5332 if len(message) != 0 { 5333 errorMessage = message 5334 } 5335 5336 switch { 5337 case strings.EqualFold("AccessDeniedException", errorCode): 5338 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5339 5340 case strings.EqualFold("InvalidParameterValuesException", errorCode): 5341 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 5342 5343 case strings.EqualFold("ResourceNotFoundException", errorCode): 5344 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5345 5346 default: 5347 genericError := &smithy.GenericAPIError{ 5348 Code: errorCode, 5349 Message: errorMessage, 5350 } 5351 return genericError 5352 5353 } 5354} 5355 5356type awsAwsjson11_deserializeOpRevokeIpRules struct { 5357} 5358 5359func (*awsAwsjson11_deserializeOpRevokeIpRules) ID() string { 5360 return "OperationDeserializer" 5361} 5362 5363func (m *awsAwsjson11_deserializeOpRevokeIpRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5364 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5365) { 5366 out, metadata, err = next.HandleDeserialize(ctx, in) 5367 if err != nil { 5368 return out, metadata, err 5369 } 5370 5371 response, ok := out.RawResponse.(*smithyhttp.Response) 5372 if !ok { 5373 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5374 } 5375 5376 if response.StatusCode < 200 || response.StatusCode >= 300 { 5377 return out, metadata, awsAwsjson11_deserializeOpErrorRevokeIpRules(response, &metadata) 5378 } 5379 output := &RevokeIpRulesOutput{} 5380 out.Result = output 5381 5382 var buff [1024]byte 5383 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5384 5385 body := io.TeeReader(response.Body, ringBuffer) 5386 decoder := json.NewDecoder(body) 5387 decoder.UseNumber() 5388 var shape interface{} 5389 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5390 var snapshot bytes.Buffer 5391 io.Copy(&snapshot, ringBuffer) 5392 err = &smithy.DeserializationError{ 5393 Err: fmt.Errorf("failed to decode response body, %w", err), 5394 Snapshot: snapshot.Bytes(), 5395 } 5396 return out, metadata, err 5397 } 5398 5399 err = awsAwsjson11_deserializeOpDocumentRevokeIpRulesOutput(&output, shape) 5400 if err != nil { 5401 var snapshot bytes.Buffer 5402 io.Copy(&snapshot, ringBuffer) 5403 err = &smithy.DeserializationError{ 5404 Err: fmt.Errorf("failed to decode response body, %w", err), 5405 Snapshot: snapshot.Bytes(), 5406 } 5407 return out, metadata, err 5408 } 5409 5410 return out, metadata, err 5411} 5412 5413func awsAwsjson11_deserializeOpErrorRevokeIpRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5414 var errorBuffer bytes.Buffer 5415 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5416 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5417 } 5418 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5419 5420 errorCode := "UnknownError" 5421 errorMessage := errorCode 5422 5423 code := response.Header.Get("X-Amzn-ErrorType") 5424 if len(code) != 0 { 5425 errorCode = restjson.SanitizeErrorCode(code) 5426 } 5427 5428 var buff [1024]byte 5429 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5430 5431 body := io.TeeReader(errorBody, ringBuffer) 5432 decoder := json.NewDecoder(body) 5433 decoder.UseNumber() 5434 code, message, err := restjson.GetErrorInfo(decoder) 5435 if err != nil { 5436 var snapshot bytes.Buffer 5437 io.Copy(&snapshot, ringBuffer) 5438 err = &smithy.DeserializationError{ 5439 Err: fmt.Errorf("failed to decode response body, %w", err), 5440 Snapshot: snapshot.Bytes(), 5441 } 5442 return err 5443 } 5444 5445 errorBody.Seek(0, io.SeekStart) 5446 if len(code) != 0 { 5447 errorCode = restjson.SanitizeErrorCode(code) 5448 } 5449 if len(message) != 0 { 5450 errorMessage = message 5451 } 5452 5453 switch { 5454 case strings.EqualFold("AccessDeniedException", errorCode): 5455 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5456 5457 case strings.EqualFold("InvalidParameterValuesException", errorCode): 5458 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 5459 5460 case strings.EqualFold("InvalidResourceStateException", errorCode): 5461 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 5462 5463 case strings.EqualFold("ResourceNotFoundException", errorCode): 5464 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5465 5466 default: 5467 genericError := &smithy.GenericAPIError{ 5468 Code: errorCode, 5469 Message: errorMessage, 5470 } 5471 return genericError 5472 5473 } 5474} 5475 5476type awsAwsjson11_deserializeOpStartWorkspaces struct { 5477} 5478 5479func (*awsAwsjson11_deserializeOpStartWorkspaces) ID() string { 5480 return "OperationDeserializer" 5481} 5482 5483func (m *awsAwsjson11_deserializeOpStartWorkspaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5484 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5485) { 5486 out, metadata, err = next.HandleDeserialize(ctx, in) 5487 if err != nil { 5488 return out, metadata, err 5489 } 5490 5491 response, ok := out.RawResponse.(*smithyhttp.Response) 5492 if !ok { 5493 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5494 } 5495 5496 if response.StatusCode < 200 || response.StatusCode >= 300 { 5497 return out, metadata, awsAwsjson11_deserializeOpErrorStartWorkspaces(response, &metadata) 5498 } 5499 output := &StartWorkspacesOutput{} 5500 out.Result = output 5501 5502 var buff [1024]byte 5503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5504 5505 body := io.TeeReader(response.Body, ringBuffer) 5506 decoder := json.NewDecoder(body) 5507 decoder.UseNumber() 5508 var shape interface{} 5509 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5510 var snapshot bytes.Buffer 5511 io.Copy(&snapshot, ringBuffer) 5512 err = &smithy.DeserializationError{ 5513 Err: fmt.Errorf("failed to decode response body, %w", err), 5514 Snapshot: snapshot.Bytes(), 5515 } 5516 return out, metadata, err 5517 } 5518 5519 err = awsAwsjson11_deserializeOpDocumentStartWorkspacesOutput(&output, shape) 5520 if err != nil { 5521 var snapshot bytes.Buffer 5522 io.Copy(&snapshot, ringBuffer) 5523 err = &smithy.DeserializationError{ 5524 Err: fmt.Errorf("failed to decode response body, %w", err), 5525 Snapshot: snapshot.Bytes(), 5526 } 5527 return out, metadata, err 5528 } 5529 5530 return out, metadata, err 5531} 5532 5533func awsAwsjson11_deserializeOpErrorStartWorkspaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5534 var errorBuffer bytes.Buffer 5535 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5536 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5537 } 5538 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5539 5540 errorCode := "UnknownError" 5541 errorMessage := errorCode 5542 5543 code := response.Header.Get("X-Amzn-ErrorType") 5544 if len(code) != 0 { 5545 errorCode = restjson.SanitizeErrorCode(code) 5546 } 5547 5548 var buff [1024]byte 5549 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5550 5551 body := io.TeeReader(errorBody, ringBuffer) 5552 decoder := json.NewDecoder(body) 5553 decoder.UseNumber() 5554 code, message, err := restjson.GetErrorInfo(decoder) 5555 if err != nil { 5556 var snapshot bytes.Buffer 5557 io.Copy(&snapshot, ringBuffer) 5558 err = &smithy.DeserializationError{ 5559 Err: fmt.Errorf("failed to decode response body, %w", err), 5560 Snapshot: snapshot.Bytes(), 5561 } 5562 return err 5563 } 5564 5565 errorBody.Seek(0, io.SeekStart) 5566 if len(code) != 0 { 5567 errorCode = restjson.SanitizeErrorCode(code) 5568 } 5569 if len(message) != 0 { 5570 errorMessage = message 5571 } 5572 5573 switch { 5574 default: 5575 genericError := &smithy.GenericAPIError{ 5576 Code: errorCode, 5577 Message: errorMessage, 5578 } 5579 return genericError 5580 5581 } 5582} 5583 5584type awsAwsjson11_deserializeOpStopWorkspaces struct { 5585} 5586 5587func (*awsAwsjson11_deserializeOpStopWorkspaces) ID() string { 5588 return "OperationDeserializer" 5589} 5590 5591func (m *awsAwsjson11_deserializeOpStopWorkspaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5592 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5593) { 5594 out, metadata, err = next.HandleDeserialize(ctx, in) 5595 if err != nil { 5596 return out, metadata, err 5597 } 5598 5599 response, ok := out.RawResponse.(*smithyhttp.Response) 5600 if !ok { 5601 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5602 } 5603 5604 if response.StatusCode < 200 || response.StatusCode >= 300 { 5605 return out, metadata, awsAwsjson11_deserializeOpErrorStopWorkspaces(response, &metadata) 5606 } 5607 output := &StopWorkspacesOutput{} 5608 out.Result = output 5609 5610 var buff [1024]byte 5611 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5612 5613 body := io.TeeReader(response.Body, ringBuffer) 5614 decoder := json.NewDecoder(body) 5615 decoder.UseNumber() 5616 var shape interface{} 5617 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5618 var snapshot bytes.Buffer 5619 io.Copy(&snapshot, ringBuffer) 5620 err = &smithy.DeserializationError{ 5621 Err: fmt.Errorf("failed to decode response body, %w", err), 5622 Snapshot: snapshot.Bytes(), 5623 } 5624 return out, metadata, err 5625 } 5626 5627 err = awsAwsjson11_deserializeOpDocumentStopWorkspacesOutput(&output, shape) 5628 if err != nil { 5629 var snapshot bytes.Buffer 5630 io.Copy(&snapshot, ringBuffer) 5631 err = &smithy.DeserializationError{ 5632 Err: fmt.Errorf("failed to decode response body, %w", err), 5633 Snapshot: snapshot.Bytes(), 5634 } 5635 return out, metadata, err 5636 } 5637 5638 return out, metadata, err 5639} 5640 5641func awsAwsjson11_deserializeOpErrorStopWorkspaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5642 var errorBuffer bytes.Buffer 5643 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5644 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5645 } 5646 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5647 5648 errorCode := "UnknownError" 5649 errorMessage := errorCode 5650 5651 code := response.Header.Get("X-Amzn-ErrorType") 5652 if len(code) != 0 { 5653 errorCode = restjson.SanitizeErrorCode(code) 5654 } 5655 5656 var buff [1024]byte 5657 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5658 5659 body := io.TeeReader(errorBody, ringBuffer) 5660 decoder := json.NewDecoder(body) 5661 decoder.UseNumber() 5662 code, message, err := restjson.GetErrorInfo(decoder) 5663 if err != nil { 5664 var snapshot bytes.Buffer 5665 io.Copy(&snapshot, ringBuffer) 5666 err = &smithy.DeserializationError{ 5667 Err: fmt.Errorf("failed to decode response body, %w", err), 5668 Snapshot: snapshot.Bytes(), 5669 } 5670 return err 5671 } 5672 5673 errorBody.Seek(0, io.SeekStart) 5674 if len(code) != 0 { 5675 errorCode = restjson.SanitizeErrorCode(code) 5676 } 5677 if len(message) != 0 { 5678 errorMessage = message 5679 } 5680 5681 switch { 5682 default: 5683 genericError := &smithy.GenericAPIError{ 5684 Code: errorCode, 5685 Message: errorMessage, 5686 } 5687 return genericError 5688 5689 } 5690} 5691 5692type awsAwsjson11_deserializeOpTerminateWorkspaces struct { 5693} 5694 5695func (*awsAwsjson11_deserializeOpTerminateWorkspaces) ID() string { 5696 return "OperationDeserializer" 5697} 5698 5699func (m *awsAwsjson11_deserializeOpTerminateWorkspaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5700 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5701) { 5702 out, metadata, err = next.HandleDeserialize(ctx, in) 5703 if err != nil { 5704 return out, metadata, err 5705 } 5706 5707 response, ok := out.RawResponse.(*smithyhttp.Response) 5708 if !ok { 5709 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5710 } 5711 5712 if response.StatusCode < 200 || response.StatusCode >= 300 { 5713 return out, metadata, awsAwsjson11_deserializeOpErrorTerminateWorkspaces(response, &metadata) 5714 } 5715 output := &TerminateWorkspacesOutput{} 5716 out.Result = output 5717 5718 var buff [1024]byte 5719 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5720 5721 body := io.TeeReader(response.Body, ringBuffer) 5722 decoder := json.NewDecoder(body) 5723 decoder.UseNumber() 5724 var shape interface{} 5725 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5726 var snapshot bytes.Buffer 5727 io.Copy(&snapshot, ringBuffer) 5728 err = &smithy.DeserializationError{ 5729 Err: fmt.Errorf("failed to decode response body, %w", err), 5730 Snapshot: snapshot.Bytes(), 5731 } 5732 return out, metadata, err 5733 } 5734 5735 err = awsAwsjson11_deserializeOpDocumentTerminateWorkspacesOutput(&output, shape) 5736 if err != nil { 5737 var snapshot bytes.Buffer 5738 io.Copy(&snapshot, ringBuffer) 5739 err = &smithy.DeserializationError{ 5740 Err: fmt.Errorf("failed to decode response body, %w", err), 5741 Snapshot: snapshot.Bytes(), 5742 } 5743 return out, metadata, err 5744 } 5745 5746 return out, metadata, err 5747} 5748 5749func awsAwsjson11_deserializeOpErrorTerminateWorkspaces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5750 var errorBuffer bytes.Buffer 5751 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5752 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5753 } 5754 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5755 5756 errorCode := "UnknownError" 5757 errorMessage := errorCode 5758 5759 code := response.Header.Get("X-Amzn-ErrorType") 5760 if len(code) != 0 { 5761 errorCode = restjson.SanitizeErrorCode(code) 5762 } 5763 5764 var buff [1024]byte 5765 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5766 5767 body := io.TeeReader(errorBody, ringBuffer) 5768 decoder := json.NewDecoder(body) 5769 decoder.UseNumber() 5770 code, message, err := restjson.GetErrorInfo(decoder) 5771 if err != nil { 5772 var snapshot bytes.Buffer 5773 io.Copy(&snapshot, ringBuffer) 5774 err = &smithy.DeserializationError{ 5775 Err: fmt.Errorf("failed to decode response body, %w", err), 5776 Snapshot: snapshot.Bytes(), 5777 } 5778 return err 5779 } 5780 5781 errorBody.Seek(0, io.SeekStart) 5782 if len(code) != 0 { 5783 errorCode = restjson.SanitizeErrorCode(code) 5784 } 5785 if len(message) != 0 { 5786 errorMessage = message 5787 } 5788 5789 switch { 5790 default: 5791 genericError := &smithy.GenericAPIError{ 5792 Code: errorCode, 5793 Message: errorMessage, 5794 } 5795 return genericError 5796 5797 } 5798} 5799 5800type awsAwsjson11_deserializeOpUpdateConnectionAliasPermission struct { 5801} 5802 5803func (*awsAwsjson11_deserializeOpUpdateConnectionAliasPermission) ID() string { 5804 return "OperationDeserializer" 5805} 5806 5807func (m *awsAwsjson11_deserializeOpUpdateConnectionAliasPermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5808 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5809) { 5810 out, metadata, err = next.HandleDeserialize(ctx, in) 5811 if err != nil { 5812 return out, metadata, err 5813 } 5814 5815 response, ok := out.RawResponse.(*smithyhttp.Response) 5816 if !ok { 5817 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5818 } 5819 5820 if response.StatusCode < 200 || response.StatusCode >= 300 { 5821 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateConnectionAliasPermission(response, &metadata) 5822 } 5823 output := &UpdateConnectionAliasPermissionOutput{} 5824 out.Result = output 5825 5826 var buff [1024]byte 5827 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5828 5829 body := io.TeeReader(response.Body, ringBuffer) 5830 decoder := json.NewDecoder(body) 5831 decoder.UseNumber() 5832 var shape interface{} 5833 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5834 var snapshot bytes.Buffer 5835 io.Copy(&snapshot, ringBuffer) 5836 err = &smithy.DeserializationError{ 5837 Err: fmt.Errorf("failed to decode response body, %w", err), 5838 Snapshot: snapshot.Bytes(), 5839 } 5840 return out, metadata, err 5841 } 5842 5843 err = awsAwsjson11_deserializeOpDocumentUpdateConnectionAliasPermissionOutput(&output, shape) 5844 if err != nil { 5845 var snapshot bytes.Buffer 5846 io.Copy(&snapshot, ringBuffer) 5847 err = &smithy.DeserializationError{ 5848 Err: fmt.Errorf("failed to decode response body, %w", err), 5849 Snapshot: snapshot.Bytes(), 5850 } 5851 return out, metadata, err 5852 } 5853 5854 return out, metadata, err 5855} 5856 5857func awsAwsjson11_deserializeOpErrorUpdateConnectionAliasPermission(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5858 var errorBuffer bytes.Buffer 5859 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5860 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5861 } 5862 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5863 5864 errorCode := "UnknownError" 5865 errorMessage := errorCode 5866 5867 code := response.Header.Get("X-Amzn-ErrorType") 5868 if len(code) != 0 { 5869 errorCode = restjson.SanitizeErrorCode(code) 5870 } 5871 5872 var buff [1024]byte 5873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5874 5875 body := io.TeeReader(errorBody, ringBuffer) 5876 decoder := json.NewDecoder(body) 5877 decoder.UseNumber() 5878 code, message, err := restjson.GetErrorInfo(decoder) 5879 if err != nil { 5880 var snapshot bytes.Buffer 5881 io.Copy(&snapshot, ringBuffer) 5882 err = &smithy.DeserializationError{ 5883 Err: fmt.Errorf("failed to decode response body, %w", err), 5884 Snapshot: snapshot.Bytes(), 5885 } 5886 return err 5887 } 5888 5889 errorBody.Seek(0, io.SeekStart) 5890 if len(code) != 0 { 5891 errorCode = restjson.SanitizeErrorCode(code) 5892 } 5893 if len(message) != 0 { 5894 errorMessage = message 5895 } 5896 5897 switch { 5898 case strings.EqualFold("AccessDeniedException", errorCode): 5899 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5900 5901 case strings.EqualFold("InvalidParameterValuesException", errorCode): 5902 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 5903 5904 case strings.EqualFold("InvalidResourceStateException", errorCode): 5905 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 5906 5907 case strings.EqualFold("OperationNotSupportedException", errorCode): 5908 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 5909 5910 case strings.EqualFold("ResourceAssociatedException", errorCode): 5911 return awsAwsjson11_deserializeErrorResourceAssociatedException(response, errorBody) 5912 5913 case strings.EqualFold("ResourceLimitExceededException", errorCode): 5914 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 5915 5916 case strings.EqualFold("ResourceNotFoundException", errorCode): 5917 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5918 5919 default: 5920 genericError := &smithy.GenericAPIError{ 5921 Code: errorCode, 5922 Message: errorMessage, 5923 } 5924 return genericError 5925 5926 } 5927} 5928 5929type awsAwsjson11_deserializeOpUpdateRulesOfIpGroup struct { 5930} 5931 5932func (*awsAwsjson11_deserializeOpUpdateRulesOfIpGroup) ID() string { 5933 return "OperationDeserializer" 5934} 5935 5936func (m *awsAwsjson11_deserializeOpUpdateRulesOfIpGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5937 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5938) { 5939 out, metadata, err = next.HandleDeserialize(ctx, in) 5940 if err != nil { 5941 return out, metadata, err 5942 } 5943 5944 response, ok := out.RawResponse.(*smithyhttp.Response) 5945 if !ok { 5946 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5947 } 5948 5949 if response.StatusCode < 200 || response.StatusCode >= 300 { 5950 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRulesOfIpGroup(response, &metadata) 5951 } 5952 output := &UpdateRulesOfIpGroupOutput{} 5953 out.Result = output 5954 5955 var buff [1024]byte 5956 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5957 5958 body := io.TeeReader(response.Body, ringBuffer) 5959 decoder := json.NewDecoder(body) 5960 decoder.UseNumber() 5961 var shape interface{} 5962 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5963 var snapshot bytes.Buffer 5964 io.Copy(&snapshot, ringBuffer) 5965 err = &smithy.DeserializationError{ 5966 Err: fmt.Errorf("failed to decode response body, %w", err), 5967 Snapshot: snapshot.Bytes(), 5968 } 5969 return out, metadata, err 5970 } 5971 5972 err = awsAwsjson11_deserializeOpDocumentUpdateRulesOfIpGroupOutput(&output, shape) 5973 if err != nil { 5974 var snapshot bytes.Buffer 5975 io.Copy(&snapshot, ringBuffer) 5976 err = &smithy.DeserializationError{ 5977 Err: fmt.Errorf("failed to decode response body, %w", err), 5978 Snapshot: snapshot.Bytes(), 5979 } 5980 return out, metadata, err 5981 } 5982 5983 return out, metadata, err 5984} 5985 5986func awsAwsjson11_deserializeOpErrorUpdateRulesOfIpGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5987 var errorBuffer bytes.Buffer 5988 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5989 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5990 } 5991 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5992 5993 errorCode := "UnknownError" 5994 errorMessage := errorCode 5995 5996 code := response.Header.Get("X-Amzn-ErrorType") 5997 if len(code) != 0 { 5998 errorCode = restjson.SanitizeErrorCode(code) 5999 } 6000 6001 var buff [1024]byte 6002 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6003 6004 body := io.TeeReader(errorBody, ringBuffer) 6005 decoder := json.NewDecoder(body) 6006 decoder.UseNumber() 6007 code, message, err := restjson.GetErrorInfo(decoder) 6008 if err != nil { 6009 var snapshot bytes.Buffer 6010 io.Copy(&snapshot, ringBuffer) 6011 err = &smithy.DeserializationError{ 6012 Err: fmt.Errorf("failed to decode response body, %w", err), 6013 Snapshot: snapshot.Bytes(), 6014 } 6015 return err 6016 } 6017 6018 errorBody.Seek(0, io.SeekStart) 6019 if len(code) != 0 { 6020 errorCode = restjson.SanitizeErrorCode(code) 6021 } 6022 if len(message) != 0 { 6023 errorMessage = message 6024 } 6025 6026 switch { 6027 case strings.EqualFold("AccessDeniedException", errorCode): 6028 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6029 6030 case strings.EqualFold("InvalidParameterValuesException", errorCode): 6031 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 6032 6033 case strings.EqualFold("InvalidResourceStateException", errorCode): 6034 return awsAwsjson11_deserializeErrorInvalidResourceStateException(response, errorBody) 6035 6036 case strings.EqualFold("ResourceLimitExceededException", errorCode): 6037 return awsAwsjson11_deserializeErrorResourceLimitExceededException(response, errorBody) 6038 6039 case strings.EqualFold("ResourceNotFoundException", errorCode): 6040 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6041 6042 default: 6043 genericError := &smithy.GenericAPIError{ 6044 Code: errorCode, 6045 Message: errorMessage, 6046 } 6047 return genericError 6048 6049 } 6050} 6051 6052type awsAwsjson11_deserializeOpUpdateWorkspaceBundle struct { 6053} 6054 6055func (*awsAwsjson11_deserializeOpUpdateWorkspaceBundle) ID() string { 6056 return "OperationDeserializer" 6057} 6058 6059func (m *awsAwsjson11_deserializeOpUpdateWorkspaceBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6060 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6061) { 6062 out, metadata, err = next.HandleDeserialize(ctx, in) 6063 if err != nil { 6064 return out, metadata, err 6065 } 6066 6067 response, ok := out.RawResponse.(*smithyhttp.Response) 6068 if !ok { 6069 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6070 } 6071 6072 if response.StatusCode < 200 || response.StatusCode >= 300 { 6073 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateWorkspaceBundle(response, &metadata) 6074 } 6075 output := &UpdateWorkspaceBundleOutput{} 6076 out.Result = output 6077 6078 var buff [1024]byte 6079 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6080 6081 body := io.TeeReader(response.Body, ringBuffer) 6082 decoder := json.NewDecoder(body) 6083 decoder.UseNumber() 6084 var shape interface{} 6085 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6086 var snapshot bytes.Buffer 6087 io.Copy(&snapshot, ringBuffer) 6088 err = &smithy.DeserializationError{ 6089 Err: fmt.Errorf("failed to decode response body, %w", err), 6090 Snapshot: snapshot.Bytes(), 6091 } 6092 return out, metadata, err 6093 } 6094 6095 err = awsAwsjson11_deserializeOpDocumentUpdateWorkspaceBundleOutput(&output, shape) 6096 if err != nil { 6097 var snapshot bytes.Buffer 6098 io.Copy(&snapshot, ringBuffer) 6099 err = &smithy.DeserializationError{ 6100 Err: fmt.Errorf("failed to decode response body, %w", err), 6101 Snapshot: snapshot.Bytes(), 6102 } 6103 return out, metadata, err 6104 } 6105 6106 return out, metadata, err 6107} 6108 6109func awsAwsjson11_deserializeOpErrorUpdateWorkspaceBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6110 var errorBuffer bytes.Buffer 6111 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6112 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6113 } 6114 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6115 6116 errorCode := "UnknownError" 6117 errorMessage := errorCode 6118 6119 code := response.Header.Get("X-Amzn-ErrorType") 6120 if len(code) != 0 { 6121 errorCode = restjson.SanitizeErrorCode(code) 6122 } 6123 6124 var buff [1024]byte 6125 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6126 6127 body := io.TeeReader(errorBody, ringBuffer) 6128 decoder := json.NewDecoder(body) 6129 decoder.UseNumber() 6130 code, message, err := restjson.GetErrorInfo(decoder) 6131 if err != nil { 6132 var snapshot bytes.Buffer 6133 io.Copy(&snapshot, ringBuffer) 6134 err = &smithy.DeserializationError{ 6135 Err: fmt.Errorf("failed to decode response body, %w", err), 6136 Snapshot: snapshot.Bytes(), 6137 } 6138 return err 6139 } 6140 6141 errorBody.Seek(0, io.SeekStart) 6142 if len(code) != 0 { 6143 errorCode = restjson.SanitizeErrorCode(code) 6144 } 6145 if len(message) != 0 { 6146 errorMessage = message 6147 } 6148 6149 switch { 6150 case strings.EqualFold("AccessDeniedException", errorCode): 6151 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6152 6153 case strings.EqualFold("InvalidParameterValuesException", errorCode): 6154 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 6155 6156 case strings.EqualFold("ResourceNotFoundException", errorCode): 6157 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6158 6159 case strings.EqualFold("ResourceUnavailableException", errorCode): 6160 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 6161 6162 default: 6163 genericError := &smithy.GenericAPIError{ 6164 Code: errorCode, 6165 Message: errorMessage, 6166 } 6167 return genericError 6168 6169 } 6170} 6171 6172type awsAwsjson11_deserializeOpUpdateWorkspaceImagePermission struct { 6173} 6174 6175func (*awsAwsjson11_deserializeOpUpdateWorkspaceImagePermission) ID() string { 6176 return "OperationDeserializer" 6177} 6178 6179func (m *awsAwsjson11_deserializeOpUpdateWorkspaceImagePermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6180 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6181) { 6182 out, metadata, err = next.HandleDeserialize(ctx, in) 6183 if err != nil { 6184 return out, metadata, err 6185 } 6186 6187 response, ok := out.RawResponse.(*smithyhttp.Response) 6188 if !ok { 6189 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6190 } 6191 6192 if response.StatusCode < 200 || response.StatusCode >= 300 { 6193 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateWorkspaceImagePermission(response, &metadata) 6194 } 6195 output := &UpdateWorkspaceImagePermissionOutput{} 6196 out.Result = output 6197 6198 var buff [1024]byte 6199 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6200 6201 body := io.TeeReader(response.Body, ringBuffer) 6202 decoder := json.NewDecoder(body) 6203 decoder.UseNumber() 6204 var shape interface{} 6205 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6206 var snapshot bytes.Buffer 6207 io.Copy(&snapshot, ringBuffer) 6208 err = &smithy.DeserializationError{ 6209 Err: fmt.Errorf("failed to decode response body, %w", err), 6210 Snapshot: snapshot.Bytes(), 6211 } 6212 return out, metadata, err 6213 } 6214 6215 err = awsAwsjson11_deserializeOpDocumentUpdateWorkspaceImagePermissionOutput(&output, shape) 6216 if err != nil { 6217 var snapshot bytes.Buffer 6218 io.Copy(&snapshot, ringBuffer) 6219 err = &smithy.DeserializationError{ 6220 Err: fmt.Errorf("failed to decode response body, %w", err), 6221 Snapshot: snapshot.Bytes(), 6222 } 6223 return out, metadata, err 6224 } 6225 6226 return out, metadata, err 6227} 6228 6229func awsAwsjson11_deserializeOpErrorUpdateWorkspaceImagePermission(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6230 var errorBuffer bytes.Buffer 6231 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6232 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6233 } 6234 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6235 6236 errorCode := "UnknownError" 6237 errorMessage := errorCode 6238 6239 code := response.Header.Get("X-Amzn-ErrorType") 6240 if len(code) != 0 { 6241 errorCode = restjson.SanitizeErrorCode(code) 6242 } 6243 6244 var buff [1024]byte 6245 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6246 6247 body := io.TeeReader(errorBody, ringBuffer) 6248 decoder := json.NewDecoder(body) 6249 decoder.UseNumber() 6250 code, message, err := restjson.GetErrorInfo(decoder) 6251 if err != nil { 6252 var snapshot bytes.Buffer 6253 io.Copy(&snapshot, ringBuffer) 6254 err = &smithy.DeserializationError{ 6255 Err: fmt.Errorf("failed to decode response body, %w", err), 6256 Snapshot: snapshot.Bytes(), 6257 } 6258 return err 6259 } 6260 6261 errorBody.Seek(0, io.SeekStart) 6262 if len(code) != 0 { 6263 errorCode = restjson.SanitizeErrorCode(code) 6264 } 6265 if len(message) != 0 { 6266 errorMessage = message 6267 } 6268 6269 switch { 6270 case strings.EqualFold("AccessDeniedException", errorCode): 6271 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6272 6273 case strings.EqualFold("InvalidParameterValuesException", errorCode): 6274 return awsAwsjson11_deserializeErrorInvalidParameterValuesException(response, errorBody) 6275 6276 case strings.EqualFold("OperationNotSupportedException", errorCode): 6277 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 6278 6279 case strings.EqualFold("ResourceNotFoundException", errorCode): 6280 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6281 6282 case strings.EqualFold("ResourceUnavailableException", errorCode): 6283 return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody) 6284 6285 default: 6286 genericError := &smithy.GenericAPIError{ 6287 Code: errorCode, 6288 Message: errorMessage, 6289 } 6290 return genericError 6291 6292 } 6293} 6294 6295func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6296 var buff [1024]byte 6297 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6298 6299 body := io.TeeReader(errorBody, ringBuffer) 6300 decoder := json.NewDecoder(body) 6301 decoder.UseNumber() 6302 var shape interface{} 6303 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6304 var snapshot bytes.Buffer 6305 io.Copy(&snapshot, ringBuffer) 6306 err = &smithy.DeserializationError{ 6307 Err: fmt.Errorf("failed to decode response body, %w", err), 6308 Snapshot: snapshot.Bytes(), 6309 } 6310 return err 6311 } 6312 6313 output := &types.AccessDeniedException{} 6314 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) 6315 6316 if err != nil { 6317 var snapshot bytes.Buffer 6318 io.Copy(&snapshot, ringBuffer) 6319 err = &smithy.DeserializationError{ 6320 Err: fmt.Errorf("failed to decode response body, %w", err), 6321 Snapshot: snapshot.Bytes(), 6322 } 6323 return err 6324 } 6325 6326 errorBody.Seek(0, io.SeekStart) 6327 return output 6328} 6329 6330func awsAwsjson11_deserializeErrorInvalidParameterValuesException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6331 var buff [1024]byte 6332 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6333 6334 body := io.TeeReader(errorBody, ringBuffer) 6335 decoder := json.NewDecoder(body) 6336 decoder.UseNumber() 6337 var shape interface{} 6338 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6339 var snapshot bytes.Buffer 6340 io.Copy(&snapshot, ringBuffer) 6341 err = &smithy.DeserializationError{ 6342 Err: fmt.Errorf("failed to decode response body, %w", err), 6343 Snapshot: snapshot.Bytes(), 6344 } 6345 return err 6346 } 6347 6348 output := &types.InvalidParameterValuesException{} 6349 err := awsAwsjson11_deserializeDocumentInvalidParameterValuesException(&output, shape) 6350 6351 if err != nil { 6352 var snapshot bytes.Buffer 6353 io.Copy(&snapshot, ringBuffer) 6354 err = &smithy.DeserializationError{ 6355 Err: fmt.Errorf("failed to decode response body, %w", err), 6356 Snapshot: snapshot.Bytes(), 6357 } 6358 return err 6359 } 6360 6361 errorBody.Seek(0, io.SeekStart) 6362 return output 6363} 6364 6365func awsAwsjson11_deserializeErrorInvalidResourceStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6366 var buff [1024]byte 6367 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6368 6369 body := io.TeeReader(errorBody, ringBuffer) 6370 decoder := json.NewDecoder(body) 6371 decoder.UseNumber() 6372 var shape interface{} 6373 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6374 var snapshot bytes.Buffer 6375 io.Copy(&snapshot, ringBuffer) 6376 err = &smithy.DeserializationError{ 6377 Err: fmt.Errorf("failed to decode response body, %w", err), 6378 Snapshot: snapshot.Bytes(), 6379 } 6380 return err 6381 } 6382 6383 output := &types.InvalidResourceStateException{} 6384 err := awsAwsjson11_deserializeDocumentInvalidResourceStateException(&output, shape) 6385 6386 if err != nil { 6387 var snapshot bytes.Buffer 6388 io.Copy(&snapshot, ringBuffer) 6389 err = &smithy.DeserializationError{ 6390 Err: fmt.Errorf("failed to decode response body, %w", err), 6391 Snapshot: snapshot.Bytes(), 6392 } 6393 return err 6394 } 6395 6396 errorBody.Seek(0, io.SeekStart) 6397 return output 6398} 6399 6400func awsAwsjson11_deserializeErrorOperationInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6401 var buff [1024]byte 6402 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6403 6404 body := io.TeeReader(errorBody, ringBuffer) 6405 decoder := json.NewDecoder(body) 6406 decoder.UseNumber() 6407 var shape interface{} 6408 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6409 var snapshot bytes.Buffer 6410 io.Copy(&snapshot, ringBuffer) 6411 err = &smithy.DeserializationError{ 6412 Err: fmt.Errorf("failed to decode response body, %w", err), 6413 Snapshot: snapshot.Bytes(), 6414 } 6415 return err 6416 } 6417 6418 output := &types.OperationInProgressException{} 6419 err := awsAwsjson11_deserializeDocumentOperationInProgressException(&output, shape) 6420 6421 if err != nil { 6422 var snapshot bytes.Buffer 6423 io.Copy(&snapshot, ringBuffer) 6424 err = &smithy.DeserializationError{ 6425 Err: fmt.Errorf("failed to decode response body, %w", err), 6426 Snapshot: snapshot.Bytes(), 6427 } 6428 return err 6429 } 6430 6431 errorBody.Seek(0, io.SeekStart) 6432 return output 6433} 6434 6435func awsAwsjson11_deserializeErrorOperationNotSupportedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6436 var buff [1024]byte 6437 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6438 6439 body := io.TeeReader(errorBody, ringBuffer) 6440 decoder := json.NewDecoder(body) 6441 decoder.UseNumber() 6442 var shape interface{} 6443 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6444 var snapshot bytes.Buffer 6445 io.Copy(&snapshot, ringBuffer) 6446 err = &smithy.DeserializationError{ 6447 Err: fmt.Errorf("failed to decode response body, %w", err), 6448 Snapshot: snapshot.Bytes(), 6449 } 6450 return err 6451 } 6452 6453 output := &types.OperationNotSupportedException{} 6454 err := awsAwsjson11_deserializeDocumentOperationNotSupportedException(&output, shape) 6455 6456 if err != nil { 6457 var snapshot bytes.Buffer 6458 io.Copy(&snapshot, ringBuffer) 6459 err = &smithy.DeserializationError{ 6460 Err: fmt.Errorf("failed to decode response body, %w", err), 6461 Snapshot: snapshot.Bytes(), 6462 } 6463 return err 6464 } 6465 6466 errorBody.Seek(0, io.SeekStart) 6467 return output 6468} 6469 6470func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6471 var buff [1024]byte 6472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6473 6474 body := io.TeeReader(errorBody, ringBuffer) 6475 decoder := json.NewDecoder(body) 6476 decoder.UseNumber() 6477 var shape interface{} 6478 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6479 var snapshot bytes.Buffer 6480 io.Copy(&snapshot, ringBuffer) 6481 err = &smithy.DeserializationError{ 6482 Err: fmt.Errorf("failed to decode response body, %w", err), 6483 Snapshot: snapshot.Bytes(), 6484 } 6485 return err 6486 } 6487 6488 output := &types.ResourceAlreadyExistsException{} 6489 err := awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(&output, shape) 6490 6491 if err != nil { 6492 var snapshot bytes.Buffer 6493 io.Copy(&snapshot, ringBuffer) 6494 err = &smithy.DeserializationError{ 6495 Err: fmt.Errorf("failed to decode response body, %w", err), 6496 Snapshot: snapshot.Bytes(), 6497 } 6498 return err 6499 } 6500 6501 errorBody.Seek(0, io.SeekStart) 6502 return output 6503} 6504 6505func awsAwsjson11_deserializeErrorResourceAssociatedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6506 var buff [1024]byte 6507 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6508 6509 body := io.TeeReader(errorBody, ringBuffer) 6510 decoder := json.NewDecoder(body) 6511 decoder.UseNumber() 6512 var shape interface{} 6513 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6514 var snapshot bytes.Buffer 6515 io.Copy(&snapshot, ringBuffer) 6516 err = &smithy.DeserializationError{ 6517 Err: fmt.Errorf("failed to decode response body, %w", err), 6518 Snapshot: snapshot.Bytes(), 6519 } 6520 return err 6521 } 6522 6523 output := &types.ResourceAssociatedException{} 6524 err := awsAwsjson11_deserializeDocumentResourceAssociatedException(&output, shape) 6525 6526 if err != nil { 6527 var snapshot bytes.Buffer 6528 io.Copy(&snapshot, ringBuffer) 6529 err = &smithy.DeserializationError{ 6530 Err: fmt.Errorf("failed to decode response body, %w", err), 6531 Snapshot: snapshot.Bytes(), 6532 } 6533 return err 6534 } 6535 6536 errorBody.Seek(0, io.SeekStart) 6537 return output 6538} 6539 6540func awsAwsjson11_deserializeErrorResourceCreationFailedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6541 var buff [1024]byte 6542 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6543 6544 body := io.TeeReader(errorBody, ringBuffer) 6545 decoder := json.NewDecoder(body) 6546 decoder.UseNumber() 6547 var shape interface{} 6548 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6549 var snapshot bytes.Buffer 6550 io.Copy(&snapshot, ringBuffer) 6551 err = &smithy.DeserializationError{ 6552 Err: fmt.Errorf("failed to decode response body, %w", err), 6553 Snapshot: snapshot.Bytes(), 6554 } 6555 return err 6556 } 6557 6558 output := &types.ResourceCreationFailedException{} 6559 err := awsAwsjson11_deserializeDocumentResourceCreationFailedException(&output, shape) 6560 6561 if err != nil { 6562 var snapshot bytes.Buffer 6563 io.Copy(&snapshot, ringBuffer) 6564 err = &smithy.DeserializationError{ 6565 Err: fmt.Errorf("failed to decode response body, %w", err), 6566 Snapshot: snapshot.Bytes(), 6567 } 6568 return err 6569 } 6570 6571 errorBody.Seek(0, io.SeekStart) 6572 return output 6573} 6574 6575func awsAwsjson11_deserializeErrorResourceLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6576 var buff [1024]byte 6577 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6578 6579 body := io.TeeReader(errorBody, ringBuffer) 6580 decoder := json.NewDecoder(body) 6581 decoder.UseNumber() 6582 var shape interface{} 6583 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6584 var snapshot bytes.Buffer 6585 io.Copy(&snapshot, ringBuffer) 6586 err = &smithy.DeserializationError{ 6587 Err: fmt.Errorf("failed to decode response body, %w", err), 6588 Snapshot: snapshot.Bytes(), 6589 } 6590 return err 6591 } 6592 6593 output := &types.ResourceLimitExceededException{} 6594 err := awsAwsjson11_deserializeDocumentResourceLimitExceededException(&output, shape) 6595 6596 if err != nil { 6597 var snapshot bytes.Buffer 6598 io.Copy(&snapshot, ringBuffer) 6599 err = &smithy.DeserializationError{ 6600 Err: fmt.Errorf("failed to decode response body, %w", err), 6601 Snapshot: snapshot.Bytes(), 6602 } 6603 return err 6604 } 6605 6606 errorBody.Seek(0, io.SeekStart) 6607 return output 6608} 6609 6610func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6611 var buff [1024]byte 6612 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6613 6614 body := io.TeeReader(errorBody, ringBuffer) 6615 decoder := json.NewDecoder(body) 6616 decoder.UseNumber() 6617 var shape interface{} 6618 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6619 var snapshot bytes.Buffer 6620 io.Copy(&snapshot, ringBuffer) 6621 err = &smithy.DeserializationError{ 6622 Err: fmt.Errorf("failed to decode response body, %w", err), 6623 Snapshot: snapshot.Bytes(), 6624 } 6625 return err 6626 } 6627 6628 output := &types.ResourceNotFoundException{} 6629 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 6630 6631 if err != nil { 6632 var snapshot bytes.Buffer 6633 io.Copy(&snapshot, ringBuffer) 6634 err = &smithy.DeserializationError{ 6635 Err: fmt.Errorf("failed to decode response body, %w", err), 6636 Snapshot: snapshot.Bytes(), 6637 } 6638 return err 6639 } 6640 6641 errorBody.Seek(0, io.SeekStart) 6642 return output 6643} 6644 6645func awsAwsjson11_deserializeErrorResourceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6646 var buff [1024]byte 6647 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6648 6649 body := io.TeeReader(errorBody, ringBuffer) 6650 decoder := json.NewDecoder(body) 6651 decoder.UseNumber() 6652 var shape interface{} 6653 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6654 var snapshot bytes.Buffer 6655 io.Copy(&snapshot, ringBuffer) 6656 err = &smithy.DeserializationError{ 6657 Err: fmt.Errorf("failed to decode response body, %w", err), 6658 Snapshot: snapshot.Bytes(), 6659 } 6660 return err 6661 } 6662 6663 output := &types.ResourceUnavailableException{} 6664 err := awsAwsjson11_deserializeDocumentResourceUnavailableException(&output, shape) 6665 6666 if err != nil { 6667 var snapshot bytes.Buffer 6668 io.Copy(&snapshot, ringBuffer) 6669 err = &smithy.DeserializationError{ 6670 Err: fmt.Errorf("failed to decode response body, %w", err), 6671 Snapshot: snapshot.Bytes(), 6672 } 6673 return err 6674 } 6675 6676 errorBody.Seek(0, io.SeekStart) 6677 return output 6678} 6679 6680func awsAwsjson11_deserializeErrorUnsupportedNetworkConfigurationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6681 var buff [1024]byte 6682 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6683 6684 body := io.TeeReader(errorBody, ringBuffer) 6685 decoder := json.NewDecoder(body) 6686 decoder.UseNumber() 6687 var shape interface{} 6688 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6689 var snapshot bytes.Buffer 6690 io.Copy(&snapshot, ringBuffer) 6691 err = &smithy.DeserializationError{ 6692 Err: fmt.Errorf("failed to decode response body, %w", err), 6693 Snapshot: snapshot.Bytes(), 6694 } 6695 return err 6696 } 6697 6698 output := &types.UnsupportedNetworkConfigurationException{} 6699 err := awsAwsjson11_deserializeDocumentUnsupportedNetworkConfigurationException(&output, shape) 6700 6701 if err != nil { 6702 var snapshot bytes.Buffer 6703 io.Copy(&snapshot, ringBuffer) 6704 err = &smithy.DeserializationError{ 6705 Err: fmt.Errorf("failed to decode response body, %w", err), 6706 Snapshot: snapshot.Bytes(), 6707 } 6708 return err 6709 } 6710 6711 errorBody.Seek(0, io.SeekStart) 6712 return output 6713} 6714 6715func awsAwsjson11_deserializeErrorUnsupportedWorkspaceConfigurationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6716 var buff [1024]byte 6717 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6718 6719 body := io.TeeReader(errorBody, ringBuffer) 6720 decoder := json.NewDecoder(body) 6721 decoder.UseNumber() 6722 var shape interface{} 6723 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6724 var snapshot bytes.Buffer 6725 io.Copy(&snapshot, ringBuffer) 6726 err = &smithy.DeserializationError{ 6727 Err: fmt.Errorf("failed to decode response body, %w", err), 6728 Snapshot: snapshot.Bytes(), 6729 } 6730 return err 6731 } 6732 6733 output := &types.UnsupportedWorkspaceConfigurationException{} 6734 err := awsAwsjson11_deserializeDocumentUnsupportedWorkspaceConfigurationException(&output, shape) 6735 6736 if err != nil { 6737 var snapshot bytes.Buffer 6738 io.Copy(&snapshot, ringBuffer) 6739 err = &smithy.DeserializationError{ 6740 Err: fmt.Errorf("failed to decode response body, %w", err), 6741 Snapshot: snapshot.Bytes(), 6742 } 6743 return err 6744 } 6745 6746 errorBody.Seek(0, io.SeekStart) 6747 return output 6748} 6749 6750func awsAwsjson11_deserializeErrorWorkspacesDefaultRoleNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6751 var buff [1024]byte 6752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6753 6754 body := io.TeeReader(errorBody, ringBuffer) 6755 decoder := json.NewDecoder(body) 6756 decoder.UseNumber() 6757 var shape interface{} 6758 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6759 var snapshot bytes.Buffer 6760 io.Copy(&snapshot, ringBuffer) 6761 err = &smithy.DeserializationError{ 6762 Err: fmt.Errorf("failed to decode response body, %w", err), 6763 Snapshot: snapshot.Bytes(), 6764 } 6765 return err 6766 } 6767 6768 output := &types.WorkspacesDefaultRoleNotFoundException{} 6769 err := awsAwsjson11_deserializeDocumentWorkspacesDefaultRoleNotFoundException(&output, shape) 6770 6771 if err != nil { 6772 var snapshot bytes.Buffer 6773 io.Copy(&snapshot, ringBuffer) 6774 err = &smithy.DeserializationError{ 6775 Err: fmt.Errorf("failed to decode response body, %w", err), 6776 Snapshot: snapshot.Bytes(), 6777 } 6778 return err 6779 } 6780 6781 errorBody.Seek(0, io.SeekStart) 6782 return output 6783} 6784 6785func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 6786 if v == nil { 6787 return fmt.Errorf("unexpected nil of type %T", v) 6788 } 6789 if value == nil { 6790 return nil 6791 } 6792 6793 shape, ok := value.(map[string]interface{}) 6794 if !ok { 6795 return fmt.Errorf("unexpected JSON type %v", value) 6796 } 6797 6798 var sv *types.AccessDeniedException 6799 if *v == nil { 6800 sv = &types.AccessDeniedException{} 6801 } else { 6802 sv = *v 6803 } 6804 6805 for key, value := range shape { 6806 switch key { 6807 case "message": 6808 if value != nil { 6809 jtv, ok := value.(string) 6810 if !ok { 6811 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 6812 } 6813 sv.Message = ptr.String(jtv) 6814 } 6815 6816 default: 6817 _, _ = key, value 6818 6819 } 6820 } 6821 *v = sv 6822 return nil 6823} 6824 6825func awsAwsjson11_deserializeDocumentAccountModification(v **types.AccountModification, value interface{}) error { 6826 if v == nil { 6827 return fmt.Errorf("unexpected nil of type %T", v) 6828 } 6829 if value == nil { 6830 return nil 6831 } 6832 6833 shape, ok := value.(map[string]interface{}) 6834 if !ok { 6835 return fmt.Errorf("unexpected JSON type %v", value) 6836 } 6837 6838 var sv *types.AccountModification 6839 if *v == nil { 6840 sv = &types.AccountModification{} 6841 } else { 6842 sv = *v 6843 } 6844 6845 for key, value := range shape { 6846 switch key { 6847 case "DedicatedTenancyManagementCidrRange": 6848 if value != nil { 6849 jtv, ok := value.(string) 6850 if !ok { 6851 return fmt.Errorf("expected DedicatedTenancyManagementCidrRange to be of type string, got %T instead", value) 6852 } 6853 sv.DedicatedTenancyManagementCidrRange = ptr.String(jtv) 6854 } 6855 6856 case "DedicatedTenancySupport": 6857 if value != nil { 6858 jtv, ok := value.(string) 6859 if !ok { 6860 return fmt.Errorf("expected DedicatedTenancySupportResultEnum to be of type string, got %T instead", value) 6861 } 6862 sv.DedicatedTenancySupport = types.DedicatedTenancySupportResultEnum(jtv) 6863 } 6864 6865 case "ErrorCode": 6866 if value != nil { 6867 jtv, ok := value.(string) 6868 if !ok { 6869 return fmt.Errorf("expected WorkspaceErrorCode to be of type string, got %T instead", value) 6870 } 6871 sv.ErrorCode = ptr.String(jtv) 6872 } 6873 6874 case "ErrorMessage": 6875 if value != nil { 6876 jtv, ok := value.(string) 6877 if !ok { 6878 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 6879 } 6880 sv.ErrorMessage = ptr.String(jtv) 6881 } 6882 6883 case "ModificationState": 6884 if value != nil { 6885 jtv, ok := value.(string) 6886 if !ok { 6887 return fmt.Errorf("expected DedicatedTenancyModificationStateEnum to be of type string, got %T instead", value) 6888 } 6889 sv.ModificationState = types.DedicatedTenancyModificationStateEnum(jtv) 6890 } 6891 6892 case "StartTime": 6893 if value != nil { 6894 jtv, ok := value.(json.Number) 6895 if !ok { 6896 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6897 } 6898 f64, err := jtv.Float64() 6899 if err != nil { 6900 return err 6901 } 6902 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6903 } 6904 6905 default: 6906 _, _ = key, value 6907 6908 } 6909 } 6910 *v = sv 6911 return nil 6912} 6913 6914func awsAwsjson11_deserializeDocumentAccountModificationList(v *[]types.AccountModification, value interface{}) error { 6915 if v == nil { 6916 return fmt.Errorf("unexpected nil of type %T", v) 6917 } 6918 if value == nil { 6919 return nil 6920 } 6921 6922 shape, ok := value.([]interface{}) 6923 if !ok { 6924 return fmt.Errorf("unexpected JSON type %v", value) 6925 } 6926 6927 var cv []types.AccountModification 6928 if *v == nil { 6929 cv = []types.AccountModification{} 6930 } else { 6931 cv = *v 6932 } 6933 6934 for _, value := range shape { 6935 var col types.AccountModification 6936 destAddr := &col 6937 if err := awsAwsjson11_deserializeDocumentAccountModification(&destAddr, value); err != nil { 6938 return err 6939 } 6940 col = *destAddr 6941 cv = append(cv, col) 6942 6943 } 6944 *v = cv 6945 return nil 6946} 6947 6948func awsAwsjson11_deserializeDocumentBundleList(v *[]types.WorkspaceBundle, value interface{}) error { 6949 if v == nil { 6950 return fmt.Errorf("unexpected nil of type %T", v) 6951 } 6952 if value == nil { 6953 return nil 6954 } 6955 6956 shape, ok := value.([]interface{}) 6957 if !ok { 6958 return fmt.Errorf("unexpected JSON type %v", value) 6959 } 6960 6961 var cv []types.WorkspaceBundle 6962 if *v == nil { 6963 cv = []types.WorkspaceBundle{} 6964 } else { 6965 cv = *v 6966 } 6967 6968 for _, value := range shape { 6969 var col types.WorkspaceBundle 6970 destAddr := &col 6971 if err := awsAwsjson11_deserializeDocumentWorkspaceBundle(&destAddr, value); err != nil { 6972 return err 6973 } 6974 col = *destAddr 6975 cv = append(cv, col) 6976 6977 } 6978 *v = cv 6979 return nil 6980} 6981 6982func awsAwsjson11_deserializeDocumentClientProperties(v **types.ClientProperties, value interface{}) error { 6983 if v == nil { 6984 return fmt.Errorf("unexpected nil of type %T", v) 6985 } 6986 if value == nil { 6987 return nil 6988 } 6989 6990 shape, ok := value.(map[string]interface{}) 6991 if !ok { 6992 return fmt.Errorf("unexpected JSON type %v", value) 6993 } 6994 6995 var sv *types.ClientProperties 6996 if *v == nil { 6997 sv = &types.ClientProperties{} 6998 } else { 6999 sv = *v 7000 } 7001 7002 for key, value := range shape { 7003 switch key { 7004 case "ReconnectEnabled": 7005 if value != nil { 7006 jtv, ok := value.(string) 7007 if !ok { 7008 return fmt.Errorf("expected ReconnectEnum to be of type string, got %T instead", value) 7009 } 7010 sv.ReconnectEnabled = types.ReconnectEnum(jtv) 7011 } 7012 7013 default: 7014 _, _ = key, value 7015 7016 } 7017 } 7018 *v = sv 7019 return nil 7020} 7021 7022func awsAwsjson11_deserializeDocumentClientPropertiesList(v *[]types.ClientPropertiesResult, value interface{}) error { 7023 if v == nil { 7024 return fmt.Errorf("unexpected nil of type %T", v) 7025 } 7026 if value == nil { 7027 return nil 7028 } 7029 7030 shape, ok := value.([]interface{}) 7031 if !ok { 7032 return fmt.Errorf("unexpected JSON type %v", value) 7033 } 7034 7035 var cv []types.ClientPropertiesResult 7036 if *v == nil { 7037 cv = []types.ClientPropertiesResult{} 7038 } else { 7039 cv = *v 7040 } 7041 7042 for _, value := range shape { 7043 var col types.ClientPropertiesResult 7044 destAddr := &col 7045 if err := awsAwsjson11_deserializeDocumentClientPropertiesResult(&destAddr, value); err != nil { 7046 return err 7047 } 7048 col = *destAddr 7049 cv = append(cv, col) 7050 7051 } 7052 *v = cv 7053 return nil 7054} 7055 7056func awsAwsjson11_deserializeDocumentClientPropertiesResult(v **types.ClientPropertiesResult, value interface{}) error { 7057 if v == nil { 7058 return fmt.Errorf("unexpected nil of type %T", v) 7059 } 7060 if value == nil { 7061 return nil 7062 } 7063 7064 shape, ok := value.(map[string]interface{}) 7065 if !ok { 7066 return fmt.Errorf("unexpected JSON type %v", value) 7067 } 7068 7069 var sv *types.ClientPropertiesResult 7070 if *v == nil { 7071 sv = &types.ClientPropertiesResult{} 7072 } else { 7073 sv = *v 7074 } 7075 7076 for key, value := range shape { 7077 switch key { 7078 case "ClientProperties": 7079 if err := awsAwsjson11_deserializeDocumentClientProperties(&sv.ClientProperties, value); err != nil { 7080 return err 7081 } 7082 7083 case "ResourceId": 7084 if value != nil { 7085 jtv, ok := value.(string) 7086 if !ok { 7087 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value) 7088 } 7089 sv.ResourceId = ptr.String(jtv) 7090 } 7091 7092 default: 7093 _, _ = key, value 7094 7095 } 7096 } 7097 *v = sv 7098 return nil 7099} 7100 7101func awsAwsjson11_deserializeDocumentComputeType(v **types.ComputeType, value interface{}) error { 7102 if v == nil { 7103 return fmt.Errorf("unexpected nil of type %T", v) 7104 } 7105 if value == nil { 7106 return nil 7107 } 7108 7109 shape, ok := value.(map[string]interface{}) 7110 if !ok { 7111 return fmt.Errorf("unexpected JSON type %v", value) 7112 } 7113 7114 var sv *types.ComputeType 7115 if *v == nil { 7116 sv = &types.ComputeType{} 7117 } else { 7118 sv = *v 7119 } 7120 7121 for key, value := range shape { 7122 switch key { 7123 case "Name": 7124 if value != nil { 7125 jtv, ok := value.(string) 7126 if !ok { 7127 return fmt.Errorf("expected Compute to be of type string, got %T instead", value) 7128 } 7129 sv.Name = types.Compute(jtv) 7130 } 7131 7132 default: 7133 _, _ = key, value 7134 7135 } 7136 } 7137 *v = sv 7138 return nil 7139} 7140 7141func awsAwsjson11_deserializeDocumentConnectionAlias(v **types.ConnectionAlias, value interface{}) error { 7142 if v == nil { 7143 return fmt.Errorf("unexpected nil of type %T", v) 7144 } 7145 if value == nil { 7146 return nil 7147 } 7148 7149 shape, ok := value.(map[string]interface{}) 7150 if !ok { 7151 return fmt.Errorf("unexpected JSON type %v", value) 7152 } 7153 7154 var sv *types.ConnectionAlias 7155 if *v == nil { 7156 sv = &types.ConnectionAlias{} 7157 } else { 7158 sv = *v 7159 } 7160 7161 for key, value := range shape { 7162 switch key { 7163 case "AliasId": 7164 if value != nil { 7165 jtv, ok := value.(string) 7166 if !ok { 7167 return fmt.Errorf("expected ConnectionAliasId to be of type string, got %T instead", value) 7168 } 7169 sv.AliasId = ptr.String(jtv) 7170 } 7171 7172 case "Associations": 7173 if err := awsAwsjson11_deserializeDocumentConnectionAliasAssociationList(&sv.Associations, value); err != nil { 7174 return err 7175 } 7176 7177 case "ConnectionString": 7178 if value != nil { 7179 jtv, ok := value.(string) 7180 if !ok { 7181 return fmt.Errorf("expected ConnectionString to be of type string, got %T instead", value) 7182 } 7183 sv.ConnectionString = ptr.String(jtv) 7184 } 7185 7186 case "OwnerAccountId": 7187 if value != nil { 7188 jtv, ok := value.(string) 7189 if !ok { 7190 return fmt.Errorf("expected AwsAccount to be of type string, got %T instead", value) 7191 } 7192 sv.OwnerAccountId = ptr.String(jtv) 7193 } 7194 7195 case "State": 7196 if value != nil { 7197 jtv, ok := value.(string) 7198 if !ok { 7199 return fmt.Errorf("expected ConnectionAliasState to be of type string, got %T instead", value) 7200 } 7201 sv.State = types.ConnectionAliasState(jtv) 7202 } 7203 7204 default: 7205 _, _ = key, value 7206 7207 } 7208 } 7209 *v = sv 7210 return nil 7211} 7212 7213func awsAwsjson11_deserializeDocumentConnectionAliasAssociation(v **types.ConnectionAliasAssociation, value interface{}) error { 7214 if v == nil { 7215 return fmt.Errorf("unexpected nil of type %T", v) 7216 } 7217 if value == nil { 7218 return nil 7219 } 7220 7221 shape, ok := value.(map[string]interface{}) 7222 if !ok { 7223 return fmt.Errorf("unexpected JSON type %v", value) 7224 } 7225 7226 var sv *types.ConnectionAliasAssociation 7227 if *v == nil { 7228 sv = &types.ConnectionAliasAssociation{} 7229 } else { 7230 sv = *v 7231 } 7232 7233 for key, value := range shape { 7234 switch key { 7235 case "AssociatedAccountId": 7236 if value != nil { 7237 jtv, ok := value.(string) 7238 if !ok { 7239 return fmt.Errorf("expected AwsAccount to be of type string, got %T instead", value) 7240 } 7241 sv.AssociatedAccountId = ptr.String(jtv) 7242 } 7243 7244 case "AssociationStatus": 7245 if value != nil { 7246 jtv, ok := value.(string) 7247 if !ok { 7248 return fmt.Errorf("expected AssociationStatus to be of type string, got %T instead", value) 7249 } 7250 sv.AssociationStatus = types.AssociationStatus(jtv) 7251 } 7252 7253 case "ConnectionIdentifier": 7254 if value != nil { 7255 jtv, ok := value.(string) 7256 if !ok { 7257 return fmt.Errorf("expected ConnectionIdentifier to be of type string, got %T instead", value) 7258 } 7259 sv.ConnectionIdentifier = ptr.String(jtv) 7260 } 7261 7262 case "ResourceId": 7263 if value != nil { 7264 jtv, ok := value.(string) 7265 if !ok { 7266 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value) 7267 } 7268 sv.ResourceId = ptr.String(jtv) 7269 } 7270 7271 default: 7272 _, _ = key, value 7273 7274 } 7275 } 7276 *v = sv 7277 return nil 7278} 7279 7280func awsAwsjson11_deserializeDocumentConnectionAliasAssociationList(v *[]types.ConnectionAliasAssociation, value interface{}) error { 7281 if v == nil { 7282 return fmt.Errorf("unexpected nil of type %T", v) 7283 } 7284 if value == nil { 7285 return nil 7286 } 7287 7288 shape, ok := value.([]interface{}) 7289 if !ok { 7290 return fmt.Errorf("unexpected JSON type %v", value) 7291 } 7292 7293 var cv []types.ConnectionAliasAssociation 7294 if *v == nil { 7295 cv = []types.ConnectionAliasAssociation{} 7296 } else { 7297 cv = *v 7298 } 7299 7300 for _, value := range shape { 7301 var col types.ConnectionAliasAssociation 7302 destAddr := &col 7303 if err := awsAwsjson11_deserializeDocumentConnectionAliasAssociation(&destAddr, value); err != nil { 7304 return err 7305 } 7306 col = *destAddr 7307 cv = append(cv, col) 7308 7309 } 7310 *v = cv 7311 return nil 7312} 7313 7314func awsAwsjson11_deserializeDocumentConnectionAliasList(v *[]types.ConnectionAlias, value interface{}) error { 7315 if v == nil { 7316 return fmt.Errorf("unexpected nil of type %T", v) 7317 } 7318 if value == nil { 7319 return nil 7320 } 7321 7322 shape, ok := value.([]interface{}) 7323 if !ok { 7324 return fmt.Errorf("unexpected JSON type %v", value) 7325 } 7326 7327 var cv []types.ConnectionAlias 7328 if *v == nil { 7329 cv = []types.ConnectionAlias{} 7330 } else { 7331 cv = *v 7332 } 7333 7334 for _, value := range shape { 7335 var col types.ConnectionAlias 7336 destAddr := &col 7337 if err := awsAwsjson11_deserializeDocumentConnectionAlias(&destAddr, value); err != nil { 7338 return err 7339 } 7340 col = *destAddr 7341 cv = append(cv, col) 7342 7343 } 7344 *v = cv 7345 return nil 7346} 7347 7348func awsAwsjson11_deserializeDocumentConnectionAliasPermission(v **types.ConnectionAliasPermission, value interface{}) error { 7349 if v == nil { 7350 return fmt.Errorf("unexpected nil of type %T", v) 7351 } 7352 if value == nil { 7353 return nil 7354 } 7355 7356 shape, ok := value.(map[string]interface{}) 7357 if !ok { 7358 return fmt.Errorf("unexpected JSON type %v", value) 7359 } 7360 7361 var sv *types.ConnectionAliasPermission 7362 if *v == nil { 7363 sv = &types.ConnectionAliasPermission{} 7364 } else { 7365 sv = *v 7366 } 7367 7368 for key, value := range shape { 7369 switch key { 7370 case "AllowAssociation": 7371 if value != nil { 7372 jtv, ok := value.(bool) 7373 if !ok { 7374 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7375 } 7376 sv.AllowAssociation = ptr.Bool(jtv) 7377 } 7378 7379 case "SharedAccountId": 7380 if value != nil { 7381 jtv, ok := value.(string) 7382 if !ok { 7383 return fmt.Errorf("expected AwsAccount to be of type string, got %T instead", value) 7384 } 7385 sv.SharedAccountId = ptr.String(jtv) 7386 } 7387 7388 default: 7389 _, _ = key, value 7390 7391 } 7392 } 7393 *v = sv 7394 return nil 7395} 7396 7397func awsAwsjson11_deserializeDocumentConnectionAliasPermissions(v *[]types.ConnectionAliasPermission, value interface{}) error { 7398 if v == nil { 7399 return fmt.Errorf("unexpected nil of type %T", v) 7400 } 7401 if value == nil { 7402 return nil 7403 } 7404 7405 shape, ok := value.([]interface{}) 7406 if !ok { 7407 return fmt.Errorf("unexpected JSON type %v", value) 7408 } 7409 7410 var cv []types.ConnectionAliasPermission 7411 if *v == nil { 7412 cv = []types.ConnectionAliasPermission{} 7413 } else { 7414 cv = *v 7415 } 7416 7417 for _, value := range shape { 7418 var col types.ConnectionAliasPermission 7419 destAddr := &col 7420 if err := awsAwsjson11_deserializeDocumentConnectionAliasPermission(&destAddr, value); err != nil { 7421 return err 7422 } 7423 col = *destAddr 7424 cv = append(cv, col) 7425 7426 } 7427 *v = cv 7428 return nil 7429} 7430 7431func awsAwsjson11_deserializeDocumentDedicatedTenancyCidrRangeList(v *[]string, value interface{}) error { 7432 if v == nil { 7433 return fmt.Errorf("unexpected nil of type %T", v) 7434 } 7435 if value == nil { 7436 return nil 7437 } 7438 7439 shape, ok := value.([]interface{}) 7440 if !ok { 7441 return fmt.Errorf("unexpected JSON type %v", value) 7442 } 7443 7444 var cv []string 7445 if *v == nil { 7446 cv = []string{} 7447 } else { 7448 cv = *v 7449 } 7450 7451 for _, value := range shape { 7452 var col string 7453 if value != nil { 7454 jtv, ok := value.(string) 7455 if !ok { 7456 return fmt.Errorf("expected DedicatedTenancyManagementCidrRange to be of type string, got %T instead", value) 7457 } 7458 col = jtv 7459 } 7460 cv = append(cv, col) 7461 7462 } 7463 *v = cv 7464 return nil 7465} 7466 7467func awsAwsjson11_deserializeDocumentDefaultWorkspaceCreationProperties(v **types.DefaultWorkspaceCreationProperties, value interface{}) error { 7468 if v == nil { 7469 return fmt.Errorf("unexpected nil of type %T", v) 7470 } 7471 if value == nil { 7472 return nil 7473 } 7474 7475 shape, ok := value.(map[string]interface{}) 7476 if !ok { 7477 return fmt.Errorf("unexpected JSON type %v", value) 7478 } 7479 7480 var sv *types.DefaultWorkspaceCreationProperties 7481 if *v == nil { 7482 sv = &types.DefaultWorkspaceCreationProperties{} 7483 } else { 7484 sv = *v 7485 } 7486 7487 for key, value := range shape { 7488 switch key { 7489 case "CustomSecurityGroupId": 7490 if value != nil { 7491 jtv, ok := value.(string) 7492 if !ok { 7493 return fmt.Errorf("expected SecurityGroupId to be of type string, got %T instead", value) 7494 } 7495 sv.CustomSecurityGroupId = ptr.String(jtv) 7496 } 7497 7498 case "DefaultOu": 7499 if value != nil { 7500 jtv, ok := value.(string) 7501 if !ok { 7502 return fmt.Errorf("expected DefaultOu to be of type string, got %T instead", value) 7503 } 7504 sv.DefaultOu = ptr.String(jtv) 7505 } 7506 7507 case "EnableInternetAccess": 7508 if value != nil { 7509 jtv, ok := value.(bool) 7510 if !ok { 7511 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7512 } 7513 sv.EnableInternetAccess = ptr.Bool(jtv) 7514 } 7515 7516 case "EnableMaintenanceMode": 7517 if value != nil { 7518 jtv, ok := value.(bool) 7519 if !ok { 7520 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7521 } 7522 sv.EnableMaintenanceMode = ptr.Bool(jtv) 7523 } 7524 7525 case "EnableWorkDocs": 7526 if value != nil { 7527 jtv, ok := value.(bool) 7528 if !ok { 7529 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7530 } 7531 sv.EnableWorkDocs = ptr.Bool(jtv) 7532 } 7533 7534 case "UserEnabledAsLocalAdministrator": 7535 if value != nil { 7536 jtv, ok := value.(bool) 7537 if !ok { 7538 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7539 } 7540 sv.UserEnabledAsLocalAdministrator = ptr.Bool(jtv) 7541 } 7542 7543 default: 7544 _, _ = key, value 7545 7546 } 7547 } 7548 *v = sv 7549 return nil 7550} 7551 7552func awsAwsjson11_deserializeDocumentDirectoryList(v *[]types.WorkspaceDirectory, value interface{}) error { 7553 if v == nil { 7554 return fmt.Errorf("unexpected nil of type %T", v) 7555 } 7556 if value == nil { 7557 return nil 7558 } 7559 7560 shape, ok := value.([]interface{}) 7561 if !ok { 7562 return fmt.Errorf("unexpected JSON type %v", value) 7563 } 7564 7565 var cv []types.WorkspaceDirectory 7566 if *v == nil { 7567 cv = []types.WorkspaceDirectory{} 7568 } else { 7569 cv = *v 7570 } 7571 7572 for _, value := range shape { 7573 var col types.WorkspaceDirectory 7574 destAddr := &col 7575 if err := awsAwsjson11_deserializeDocumentWorkspaceDirectory(&destAddr, value); err != nil { 7576 return err 7577 } 7578 col = *destAddr 7579 cv = append(cv, col) 7580 7581 } 7582 *v = cv 7583 return nil 7584} 7585 7586func awsAwsjson11_deserializeDocumentDnsIpAddresses(v *[]string, value interface{}) error { 7587 if v == nil { 7588 return fmt.Errorf("unexpected nil of type %T", v) 7589 } 7590 if value == nil { 7591 return nil 7592 } 7593 7594 shape, ok := value.([]interface{}) 7595 if !ok { 7596 return fmt.Errorf("unexpected JSON type %v", value) 7597 } 7598 7599 var cv []string 7600 if *v == nil { 7601 cv = []string{} 7602 } else { 7603 cv = *v 7604 } 7605 7606 for _, value := range shape { 7607 var col string 7608 if value != nil { 7609 jtv, ok := value.(string) 7610 if !ok { 7611 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value) 7612 } 7613 col = jtv 7614 } 7615 cv = append(cv, col) 7616 7617 } 7618 *v = cv 7619 return nil 7620} 7621 7622func awsAwsjson11_deserializeDocumentFailedCreateWorkspaceRequest(v **types.FailedCreateWorkspaceRequest, value interface{}) error { 7623 if v == nil { 7624 return fmt.Errorf("unexpected nil of type %T", v) 7625 } 7626 if value == nil { 7627 return nil 7628 } 7629 7630 shape, ok := value.(map[string]interface{}) 7631 if !ok { 7632 return fmt.Errorf("unexpected JSON type %v", value) 7633 } 7634 7635 var sv *types.FailedCreateWorkspaceRequest 7636 if *v == nil { 7637 sv = &types.FailedCreateWorkspaceRequest{} 7638 } else { 7639 sv = *v 7640 } 7641 7642 for key, value := range shape { 7643 switch key { 7644 case "ErrorCode": 7645 if value != nil { 7646 jtv, ok := value.(string) 7647 if !ok { 7648 return fmt.Errorf("expected ErrorType to be of type string, got %T instead", value) 7649 } 7650 sv.ErrorCode = ptr.String(jtv) 7651 } 7652 7653 case "ErrorMessage": 7654 if value != nil { 7655 jtv, ok := value.(string) 7656 if !ok { 7657 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 7658 } 7659 sv.ErrorMessage = ptr.String(jtv) 7660 } 7661 7662 case "WorkspaceRequest": 7663 if err := awsAwsjson11_deserializeDocumentWorkspaceRequest(&sv.WorkspaceRequest, value); err != nil { 7664 return err 7665 } 7666 7667 default: 7668 _, _ = key, value 7669 7670 } 7671 } 7672 *v = sv 7673 return nil 7674} 7675 7676func awsAwsjson11_deserializeDocumentFailedCreateWorkspaceRequests(v *[]types.FailedCreateWorkspaceRequest, value interface{}) error { 7677 if v == nil { 7678 return fmt.Errorf("unexpected nil of type %T", v) 7679 } 7680 if value == nil { 7681 return nil 7682 } 7683 7684 shape, ok := value.([]interface{}) 7685 if !ok { 7686 return fmt.Errorf("unexpected JSON type %v", value) 7687 } 7688 7689 var cv []types.FailedCreateWorkspaceRequest 7690 if *v == nil { 7691 cv = []types.FailedCreateWorkspaceRequest{} 7692 } else { 7693 cv = *v 7694 } 7695 7696 for _, value := range shape { 7697 var col types.FailedCreateWorkspaceRequest 7698 destAddr := &col 7699 if err := awsAwsjson11_deserializeDocumentFailedCreateWorkspaceRequest(&destAddr, value); err != nil { 7700 return err 7701 } 7702 col = *destAddr 7703 cv = append(cv, col) 7704 7705 } 7706 *v = cv 7707 return nil 7708} 7709 7710func awsAwsjson11_deserializeDocumentFailedRebootWorkspaceRequests(v *[]types.FailedWorkspaceChangeRequest, value interface{}) error { 7711 if v == nil { 7712 return fmt.Errorf("unexpected nil of type %T", v) 7713 } 7714 if value == nil { 7715 return nil 7716 } 7717 7718 shape, ok := value.([]interface{}) 7719 if !ok { 7720 return fmt.Errorf("unexpected JSON type %v", value) 7721 } 7722 7723 var cv []types.FailedWorkspaceChangeRequest 7724 if *v == nil { 7725 cv = []types.FailedWorkspaceChangeRequest{} 7726 } else { 7727 cv = *v 7728 } 7729 7730 for _, value := range shape { 7731 var col types.FailedWorkspaceChangeRequest 7732 destAddr := &col 7733 if err := awsAwsjson11_deserializeDocumentFailedWorkspaceChangeRequest(&destAddr, value); err != nil { 7734 return err 7735 } 7736 col = *destAddr 7737 cv = append(cv, col) 7738 7739 } 7740 *v = cv 7741 return nil 7742} 7743 7744func awsAwsjson11_deserializeDocumentFailedRebuildWorkspaceRequests(v *[]types.FailedWorkspaceChangeRequest, value interface{}) error { 7745 if v == nil { 7746 return fmt.Errorf("unexpected nil of type %T", v) 7747 } 7748 if value == nil { 7749 return nil 7750 } 7751 7752 shape, ok := value.([]interface{}) 7753 if !ok { 7754 return fmt.Errorf("unexpected JSON type %v", value) 7755 } 7756 7757 var cv []types.FailedWorkspaceChangeRequest 7758 if *v == nil { 7759 cv = []types.FailedWorkspaceChangeRequest{} 7760 } else { 7761 cv = *v 7762 } 7763 7764 for _, value := range shape { 7765 var col types.FailedWorkspaceChangeRequest 7766 destAddr := &col 7767 if err := awsAwsjson11_deserializeDocumentFailedWorkspaceChangeRequest(&destAddr, value); err != nil { 7768 return err 7769 } 7770 col = *destAddr 7771 cv = append(cv, col) 7772 7773 } 7774 *v = cv 7775 return nil 7776} 7777 7778func awsAwsjson11_deserializeDocumentFailedStartWorkspaceRequests(v *[]types.FailedWorkspaceChangeRequest, value interface{}) error { 7779 if v == nil { 7780 return fmt.Errorf("unexpected nil of type %T", v) 7781 } 7782 if value == nil { 7783 return nil 7784 } 7785 7786 shape, ok := value.([]interface{}) 7787 if !ok { 7788 return fmt.Errorf("unexpected JSON type %v", value) 7789 } 7790 7791 var cv []types.FailedWorkspaceChangeRequest 7792 if *v == nil { 7793 cv = []types.FailedWorkspaceChangeRequest{} 7794 } else { 7795 cv = *v 7796 } 7797 7798 for _, value := range shape { 7799 var col types.FailedWorkspaceChangeRequest 7800 destAddr := &col 7801 if err := awsAwsjson11_deserializeDocumentFailedWorkspaceChangeRequest(&destAddr, value); err != nil { 7802 return err 7803 } 7804 col = *destAddr 7805 cv = append(cv, col) 7806 7807 } 7808 *v = cv 7809 return nil 7810} 7811 7812func awsAwsjson11_deserializeDocumentFailedStopWorkspaceRequests(v *[]types.FailedWorkspaceChangeRequest, value interface{}) error { 7813 if v == nil { 7814 return fmt.Errorf("unexpected nil of type %T", v) 7815 } 7816 if value == nil { 7817 return nil 7818 } 7819 7820 shape, ok := value.([]interface{}) 7821 if !ok { 7822 return fmt.Errorf("unexpected JSON type %v", value) 7823 } 7824 7825 var cv []types.FailedWorkspaceChangeRequest 7826 if *v == nil { 7827 cv = []types.FailedWorkspaceChangeRequest{} 7828 } else { 7829 cv = *v 7830 } 7831 7832 for _, value := range shape { 7833 var col types.FailedWorkspaceChangeRequest 7834 destAddr := &col 7835 if err := awsAwsjson11_deserializeDocumentFailedWorkspaceChangeRequest(&destAddr, value); err != nil { 7836 return err 7837 } 7838 col = *destAddr 7839 cv = append(cv, col) 7840 7841 } 7842 *v = cv 7843 return nil 7844} 7845 7846func awsAwsjson11_deserializeDocumentFailedTerminateWorkspaceRequests(v *[]types.FailedWorkspaceChangeRequest, value interface{}) error { 7847 if v == nil { 7848 return fmt.Errorf("unexpected nil of type %T", v) 7849 } 7850 if value == nil { 7851 return nil 7852 } 7853 7854 shape, ok := value.([]interface{}) 7855 if !ok { 7856 return fmt.Errorf("unexpected JSON type %v", value) 7857 } 7858 7859 var cv []types.FailedWorkspaceChangeRequest 7860 if *v == nil { 7861 cv = []types.FailedWorkspaceChangeRequest{} 7862 } else { 7863 cv = *v 7864 } 7865 7866 for _, value := range shape { 7867 var col types.FailedWorkspaceChangeRequest 7868 destAddr := &col 7869 if err := awsAwsjson11_deserializeDocumentFailedWorkspaceChangeRequest(&destAddr, value); err != nil { 7870 return err 7871 } 7872 col = *destAddr 7873 cv = append(cv, col) 7874 7875 } 7876 *v = cv 7877 return nil 7878} 7879 7880func awsAwsjson11_deserializeDocumentFailedWorkspaceChangeRequest(v **types.FailedWorkspaceChangeRequest, value interface{}) error { 7881 if v == nil { 7882 return fmt.Errorf("unexpected nil of type %T", v) 7883 } 7884 if value == nil { 7885 return nil 7886 } 7887 7888 shape, ok := value.(map[string]interface{}) 7889 if !ok { 7890 return fmt.Errorf("unexpected JSON type %v", value) 7891 } 7892 7893 var sv *types.FailedWorkspaceChangeRequest 7894 if *v == nil { 7895 sv = &types.FailedWorkspaceChangeRequest{} 7896 } else { 7897 sv = *v 7898 } 7899 7900 for key, value := range shape { 7901 switch key { 7902 case "ErrorCode": 7903 if value != nil { 7904 jtv, ok := value.(string) 7905 if !ok { 7906 return fmt.Errorf("expected ErrorType to be of type string, got %T instead", value) 7907 } 7908 sv.ErrorCode = ptr.String(jtv) 7909 } 7910 7911 case "ErrorMessage": 7912 if value != nil { 7913 jtv, ok := value.(string) 7914 if !ok { 7915 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 7916 } 7917 sv.ErrorMessage = ptr.String(jtv) 7918 } 7919 7920 case "WorkspaceId": 7921 if value != nil { 7922 jtv, ok := value.(string) 7923 if !ok { 7924 return fmt.Errorf("expected WorkspaceId to be of type string, got %T instead", value) 7925 } 7926 sv.WorkspaceId = ptr.String(jtv) 7927 } 7928 7929 default: 7930 _, _ = key, value 7931 7932 } 7933 } 7934 *v = sv 7935 return nil 7936} 7937 7938func awsAwsjson11_deserializeDocumentImagePermission(v **types.ImagePermission, value interface{}) error { 7939 if v == nil { 7940 return fmt.Errorf("unexpected nil of type %T", v) 7941 } 7942 if value == nil { 7943 return nil 7944 } 7945 7946 shape, ok := value.(map[string]interface{}) 7947 if !ok { 7948 return fmt.Errorf("unexpected JSON type %v", value) 7949 } 7950 7951 var sv *types.ImagePermission 7952 if *v == nil { 7953 sv = &types.ImagePermission{} 7954 } else { 7955 sv = *v 7956 } 7957 7958 for key, value := range shape { 7959 switch key { 7960 case "SharedAccountId": 7961 if value != nil { 7962 jtv, ok := value.(string) 7963 if !ok { 7964 return fmt.Errorf("expected AwsAccount to be of type string, got %T instead", value) 7965 } 7966 sv.SharedAccountId = ptr.String(jtv) 7967 } 7968 7969 default: 7970 _, _ = key, value 7971 7972 } 7973 } 7974 *v = sv 7975 return nil 7976} 7977 7978func awsAwsjson11_deserializeDocumentImagePermissions(v *[]types.ImagePermission, value interface{}) error { 7979 if v == nil { 7980 return fmt.Errorf("unexpected nil of type %T", v) 7981 } 7982 if value == nil { 7983 return nil 7984 } 7985 7986 shape, ok := value.([]interface{}) 7987 if !ok { 7988 return fmt.Errorf("unexpected JSON type %v", value) 7989 } 7990 7991 var cv []types.ImagePermission 7992 if *v == nil { 7993 cv = []types.ImagePermission{} 7994 } else { 7995 cv = *v 7996 } 7997 7998 for _, value := range shape { 7999 var col types.ImagePermission 8000 destAddr := &col 8001 if err := awsAwsjson11_deserializeDocumentImagePermission(&destAddr, value); err != nil { 8002 return err 8003 } 8004 col = *destAddr 8005 cv = append(cv, col) 8006 8007 } 8008 *v = cv 8009 return nil 8010} 8011 8012func awsAwsjson11_deserializeDocumentInvalidParameterValuesException(v **types.InvalidParameterValuesException, value interface{}) error { 8013 if v == nil { 8014 return fmt.Errorf("unexpected nil of type %T", v) 8015 } 8016 if value == nil { 8017 return nil 8018 } 8019 8020 shape, ok := value.(map[string]interface{}) 8021 if !ok { 8022 return fmt.Errorf("unexpected JSON type %v", value) 8023 } 8024 8025 var sv *types.InvalidParameterValuesException 8026 if *v == nil { 8027 sv = &types.InvalidParameterValuesException{} 8028 } else { 8029 sv = *v 8030 } 8031 8032 for key, value := range shape { 8033 switch key { 8034 case "message": 8035 if value != nil { 8036 jtv, ok := value.(string) 8037 if !ok { 8038 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8039 } 8040 sv.Message = ptr.String(jtv) 8041 } 8042 8043 default: 8044 _, _ = key, value 8045 8046 } 8047 } 8048 *v = sv 8049 return nil 8050} 8051 8052func awsAwsjson11_deserializeDocumentInvalidResourceStateException(v **types.InvalidResourceStateException, value interface{}) error { 8053 if v == nil { 8054 return fmt.Errorf("unexpected nil of type %T", v) 8055 } 8056 if value == nil { 8057 return nil 8058 } 8059 8060 shape, ok := value.(map[string]interface{}) 8061 if !ok { 8062 return fmt.Errorf("unexpected JSON type %v", value) 8063 } 8064 8065 var sv *types.InvalidResourceStateException 8066 if *v == nil { 8067 sv = &types.InvalidResourceStateException{} 8068 } else { 8069 sv = *v 8070 } 8071 8072 for key, value := range shape { 8073 switch key { 8074 case "message": 8075 if value != nil { 8076 jtv, ok := value.(string) 8077 if !ok { 8078 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8079 } 8080 sv.Message = ptr.String(jtv) 8081 } 8082 8083 default: 8084 _, _ = key, value 8085 8086 } 8087 } 8088 *v = sv 8089 return nil 8090} 8091 8092func awsAwsjson11_deserializeDocumentIpGroupIdList(v *[]string, value interface{}) error { 8093 if v == nil { 8094 return fmt.Errorf("unexpected nil of type %T", v) 8095 } 8096 if value == nil { 8097 return nil 8098 } 8099 8100 shape, ok := value.([]interface{}) 8101 if !ok { 8102 return fmt.Errorf("unexpected JSON type %v", value) 8103 } 8104 8105 var cv []string 8106 if *v == nil { 8107 cv = []string{} 8108 } else { 8109 cv = *v 8110 } 8111 8112 for _, value := range shape { 8113 var col string 8114 if value != nil { 8115 jtv, ok := value.(string) 8116 if !ok { 8117 return fmt.Errorf("expected IpGroupId to be of type string, got %T instead", value) 8118 } 8119 col = jtv 8120 } 8121 cv = append(cv, col) 8122 8123 } 8124 *v = cv 8125 return nil 8126} 8127 8128func awsAwsjson11_deserializeDocumentIpRuleItem(v **types.IpRuleItem, value interface{}) error { 8129 if v == nil { 8130 return fmt.Errorf("unexpected nil of type %T", v) 8131 } 8132 if value == nil { 8133 return nil 8134 } 8135 8136 shape, ok := value.(map[string]interface{}) 8137 if !ok { 8138 return fmt.Errorf("unexpected JSON type %v", value) 8139 } 8140 8141 var sv *types.IpRuleItem 8142 if *v == nil { 8143 sv = &types.IpRuleItem{} 8144 } else { 8145 sv = *v 8146 } 8147 8148 for key, value := range shape { 8149 switch key { 8150 case "ipRule": 8151 if value != nil { 8152 jtv, ok := value.(string) 8153 if !ok { 8154 return fmt.Errorf("expected IpRule to be of type string, got %T instead", value) 8155 } 8156 sv.IpRule = ptr.String(jtv) 8157 } 8158 8159 case "ruleDesc": 8160 if value != nil { 8161 jtv, ok := value.(string) 8162 if !ok { 8163 return fmt.Errorf("expected IpRuleDesc to be of type string, got %T instead", value) 8164 } 8165 sv.RuleDesc = ptr.String(jtv) 8166 } 8167 8168 default: 8169 _, _ = key, value 8170 8171 } 8172 } 8173 *v = sv 8174 return nil 8175} 8176 8177func awsAwsjson11_deserializeDocumentIpRuleList(v *[]types.IpRuleItem, value interface{}) error { 8178 if v == nil { 8179 return fmt.Errorf("unexpected nil of type %T", v) 8180 } 8181 if value == nil { 8182 return nil 8183 } 8184 8185 shape, ok := value.([]interface{}) 8186 if !ok { 8187 return fmt.Errorf("unexpected JSON type %v", value) 8188 } 8189 8190 var cv []types.IpRuleItem 8191 if *v == nil { 8192 cv = []types.IpRuleItem{} 8193 } else { 8194 cv = *v 8195 } 8196 8197 for _, value := range shape { 8198 var col types.IpRuleItem 8199 destAddr := &col 8200 if err := awsAwsjson11_deserializeDocumentIpRuleItem(&destAddr, value); err != nil { 8201 return err 8202 } 8203 col = *destAddr 8204 cv = append(cv, col) 8205 8206 } 8207 *v = cv 8208 return nil 8209} 8210 8211func awsAwsjson11_deserializeDocumentModificationState(v **types.ModificationState, value interface{}) error { 8212 if v == nil { 8213 return fmt.Errorf("unexpected nil of type %T", v) 8214 } 8215 if value == nil { 8216 return nil 8217 } 8218 8219 shape, ok := value.(map[string]interface{}) 8220 if !ok { 8221 return fmt.Errorf("unexpected JSON type %v", value) 8222 } 8223 8224 var sv *types.ModificationState 8225 if *v == nil { 8226 sv = &types.ModificationState{} 8227 } else { 8228 sv = *v 8229 } 8230 8231 for key, value := range shape { 8232 switch key { 8233 case "Resource": 8234 if value != nil { 8235 jtv, ok := value.(string) 8236 if !ok { 8237 return fmt.Errorf("expected ModificationResourceEnum to be of type string, got %T instead", value) 8238 } 8239 sv.Resource = types.ModificationResourceEnum(jtv) 8240 } 8241 8242 case "State": 8243 if value != nil { 8244 jtv, ok := value.(string) 8245 if !ok { 8246 return fmt.Errorf("expected ModificationStateEnum to be of type string, got %T instead", value) 8247 } 8248 sv.State = types.ModificationStateEnum(jtv) 8249 } 8250 8251 default: 8252 _, _ = key, value 8253 8254 } 8255 } 8256 *v = sv 8257 return nil 8258} 8259 8260func awsAwsjson11_deserializeDocumentModificationStateList(v *[]types.ModificationState, value interface{}) error { 8261 if v == nil { 8262 return fmt.Errorf("unexpected nil of type %T", v) 8263 } 8264 if value == nil { 8265 return nil 8266 } 8267 8268 shape, ok := value.([]interface{}) 8269 if !ok { 8270 return fmt.Errorf("unexpected JSON type %v", value) 8271 } 8272 8273 var cv []types.ModificationState 8274 if *v == nil { 8275 cv = []types.ModificationState{} 8276 } else { 8277 cv = *v 8278 } 8279 8280 for _, value := range shape { 8281 var col types.ModificationState 8282 destAddr := &col 8283 if err := awsAwsjson11_deserializeDocumentModificationState(&destAddr, value); err != nil { 8284 return err 8285 } 8286 col = *destAddr 8287 cv = append(cv, col) 8288 8289 } 8290 *v = cv 8291 return nil 8292} 8293 8294func awsAwsjson11_deserializeDocumentOperatingSystem(v **types.OperatingSystem, value interface{}) error { 8295 if v == nil { 8296 return fmt.Errorf("unexpected nil of type %T", v) 8297 } 8298 if value == nil { 8299 return nil 8300 } 8301 8302 shape, ok := value.(map[string]interface{}) 8303 if !ok { 8304 return fmt.Errorf("unexpected JSON type %v", value) 8305 } 8306 8307 var sv *types.OperatingSystem 8308 if *v == nil { 8309 sv = &types.OperatingSystem{} 8310 } else { 8311 sv = *v 8312 } 8313 8314 for key, value := range shape { 8315 switch key { 8316 case "Type": 8317 if value != nil { 8318 jtv, ok := value.(string) 8319 if !ok { 8320 return fmt.Errorf("expected OperatingSystemType to be of type string, got %T instead", value) 8321 } 8322 sv.Type = types.OperatingSystemType(jtv) 8323 } 8324 8325 default: 8326 _, _ = key, value 8327 8328 } 8329 } 8330 *v = sv 8331 return nil 8332} 8333 8334func awsAwsjson11_deserializeDocumentOperationInProgressException(v **types.OperationInProgressException, value interface{}) error { 8335 if v == nil { 8336 return fmt.Errorf("unexpected nil of type %T", v) 8337 } 8338 if value == nil { 8339 return nil 8340 } 8341 8342 shape, ok := value.(map[string]interface{}) 8343 if !ok { 8344 return fmt.Errorf("unexpected JSON type %v", value) 8345 } 8346 8347 var sv *types.OperationInProgressException 8348 if *v == nil { 8349 sv = &types.OperationInProgressException{} 8350 } else { 8351 sv = *v 8352 } 8353 8354 for key, value := range shape { 8355 switch key { 8356 case "message": 8357 if value != nil { 8358 jtv, ok := value.(string) 8359 if !ok { 8360 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8361 } 8362 sv.Message = ptr.String(jtv) 8363 } 8364 8365 default: 8366 _, _ = key, value 8367 8368 } 8369 } 8370 *v = sv 8371 return nil 8372} 8373 8374func awsAwsjson11_deserializeDocumentOperationNotSupportedException(v **types.OperationNotSupportedException, value interface{}) error { 8375 if v == nil { 8376 return fmt.Errorf("unexpected nil of type %T", v) 8377 } 8378 if value == nil { 8379 return nil 8380 } 8381 8382 shape, ok := value.(map[string]interface{}) 8383 if !ok { 8384 return fmt.Errorf("unexpected JSON type %v", value) 8385 } 8386 8387 var sv *types.OperationNotSupportedException 8388 if *v == nil { 8389 sv = &types.OperationNotSupportedException{} 8390 } else { 8391 sv = *v 8392 } 8393 8394 for key, value := range shape { 8395 switch key { 8396 case "message": 8397 if value != nil { 8398 jtv, ok := value.(string) 8399 if !ok { 8400 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8401 } 8402 sv.Message = ptr.String(jtv) 8403 } 8404 8405 default: 8406 _, _ = key, value 8407 8408 } 8409 } 8410 *v = sv 8411 return nil 8412} 8413 8414func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, value interface{}) error { 8415 if v == nil { 8416 return fmt.Errorf("unexpected nil of type %T", v) 8417 } 8418 if value == nil { 8419 return nil 8420 } 8421 8422 shape, ok := value.(map[string]interface{}) 8423 if !ok { 8424 return fmt.Errorf("unexpected JSON type %v", value) 8425 } 8426 8427 var sv *types.ResourceAlreadyExistsException 8428 if *v == nil { 8429 sv = &types.ResourceAlreadyExistsException{} 8430 } else { 8431 sv = *v 8432 } 8433 8434 for key, value := range shape { 8435 switch key { 8436 case "message": 8437 if value != nil { 8438 jtv, ok := value.(string) 8439 if !ok { 8440 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8441 } 8442 sv.Message = ptr.String(jtv) 8443 } 8444 8445 default: 8446 _, _ = key, value 8447 8448 } 8449 } 8450 *v = sv 8451 return nil 8452} 8453 8454func awsAwsjson11_deserializeDocumentResourceAssociatedException(v **types.ResourceAssociatedException, value interface{}) error { 8455 if v == nil { 8456 return fmt.Errorf("unexpected nil of type %T", v) 8457 } 8458 if value == nil { 8459 return nil 8460 } 8461 8462 shape, ok := value.(map[string]interface{}) 8463 if !ok { 8464 return fmt.Errorf("unexpected JSON type %v", value) 8465 } 8466 8467 var sv *types.ResourceAssociatedException 8468 if *v == nil { 8469 sv = &types.ResourceAssociatedException{} 8470 } else { 8471 sv = *v 8472 } 8473 8474 for key, value := range shape { 8475 switch key { 8476 case "message": 8477 if value != nil { 8478 jtv, ok := value.(string) 8479 if !ok { 8480 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8481 } 8482 sv.Message = ptr.String(jtv) 8483 } 8484 8485 default: 8486 _, _ = key, value 8487 8488 } 8489 } 8490 *v = sv 8491 return nil 8492} 8493 8494func awsAwsjson11_deserializeDocumentResourceCreationFailedException(v **types.ResourceCreationFailedException, value interface{}) error { 8495 if v == nil { 8496 return fmt.Errorf("unexpected nil of type %T", v) 8497 } 8498 if value == nil { 8499 return nil 8500 } 8501 8502 shape, ok := value.(map[string]interface{}) 8503 if !ok { 8504 return fmt.Errorf("unexpected JSON type %v", value) 8505 } 8506 8507 var sv *types.ResourceCreationFailedException 8508 if *v == nil { 8509 sv = &types.ResourceCreationFailedException{} 8510 } else { 8511 sv = *v 8512 } 8513 8514 for key, value := range shape { 8515 switch key { 8516 case "message": 8517 if value != nil { 8518 jtv, ok := value.(string) 8519 if !ok { 8520 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8521 } 8522 sv.Message = ptr.String(jtv) 8523 } 8524 8525 default: 8526 _, _ = key, value 8527 8528 } 8529 } 8530 *v = sv 8531 return nil 8532} 8533 8534func awsAwsjson11_deserializeDocumentResourceLimitExceededException(v **types.ResourceLimitExceededException, value interface{}) error { 8535 if v == nil { 8536 return fmt.Errorf("unexpected nil of type %T", v) 8537 } 8538 if value == nil { 8539 return nil 8540 } 8541 8542 shape, ok := value.(map[string]interface{}) 8543 if !ok { 8544 return fmt.Errorf("unexpected JSON type %v", value) 8545 } 8546 8547 var sv *types.ResourceLimitExceededException 8548 if *v == nil { 8549 sv = &types.ResourceLimitExceededException{} 8550 } else { 8551 sv = *v 8552 } 8553 8554 for key, value := range shape { 8555 switch key { 8556 case "message": 8557 if value != nil { 8558 jtv, ok := value.(string) 8559 if !ok { 8560 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8561 } 8562 sv.Message = ptr.String(jtv) 8563 } 8564 8565 default: 8566 _, _ = key, value 8567 8568 } 8569 } 8570 *v = sv 8571 return nil 8572} 8573 8574func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 8575 if v == nil { 8576 return fmt.Errorf("unexpected nil of type %T", v) 8577 } 8578 if value == nil { 8579 return nil 8580 } 8581 8582 shape, ok := value.(map[string]interface{}) 8583 if !ok { 8584 return fmt.Errorf("unexpected JSON type %v", value) 8585 } 8586 8587 var sv *types.ResourceNotFoundException 8588 if *v == nil { 8589 sv = &types.ResourceNotFoundException{} 8590 } else { 8591 sv = *v 8592 } 8593 8594 for key, value := range shape { 8595 switch key { 8596 case "message": 8597 if value != nil { 8598 jtv, ok := value.(string) 8599 if !ok { 8600 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8601 } 8602 sv.Message = ptr.String(jtv) 8603 } 8604 8605 case "ResourceId": 8606 if value != nil { 8607 jtv, ok := value.(string) 8608 if !ok { 8609 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value) 8610 } 8611 sv.ResourceId = ptr.String(jtv) 8612 } 8613 8614 default: 8615 _, _ = key, value 8616 8617 } 8618 } 8619 *v = sv 8620 return nil 8621} 8622 8623func awsAwsjson11_deserializeDocumentResourceUnavailableException(v **types.ResourceUnavailableException, value interface{}) error { 8624 if v == nil { 8625 return fmt.Errorf("unexpected nil of type %T", v) 8626 } 8627 if value == nil { 8628 return nil 8629 } 8630 8631 shape, ok := value.(map[string]interface{}) 8632 if !ok { 8633 return fmt.Errorf("unexpected JSON type %v", value) 8634 } 8635 8636 var sv *types.ResourceUnavailableException 8637 if *v == nil { 8638 sv = &types.ResourceUnavailableException{} 8639 } else { 8640 sv = *v 8641 } 8642 8643 for key, value := range shape { 8644 switch key { 8645 case "message": 8646 if value != nil { 8647 jtv, ok := value.(string) 8648 if !ok { 8649 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8650 } 8651 sv.Message = ptr.String(jtv) 8652 } 8653 8654 case "ResourceId": 8655 if value != nil { 8656 jtv, ok := value.(string) 8657 if !ok { 8658 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value) 8659 } 8660 sv.ResourceId = ptr.String(jtv) 8661 } 8662 8663 default: 8664 _, _ = key, value 8665 8666 } 8667 } 8668 *v = sv 8669 return nil 8670} 8671 8672func awsAwsjson11_deserializeDocumentRootStorage(v **types.RootStorage, value interface{}) error { 8673 if v == nil { 8674 return fmt.Errorf("unexpected nil of type %T", v) 8675 } 8676 if value == nil { 8677 return nil 8678 } 8679 8680 shape, ok := value.(map[string]interface{}) 8681 if !ok { 8682 return fmt.Errorf("unexpected JSON type %v", value) 8683 } 8684 8685 var sv *types.RootStorage 8686 if *v == nil { 8687 sv = &types.RootStorage{} 8688 } else { 8689 sv = *v 8690 } 8691 8692 for key, value := range shape { 8693 switch key { 8694 case "Capacity": 8695 if value != nil { 8696 jtv, ok := value.(string) 8697 if !ok { 8698 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value) 8699 } 8700 sv.Capacity = ptr.String(jtv) 8701 } 8702 8703 default: 8704 _, _ = key, value 8705 8706 } 8707 } 8708 *v = sv 8709 return nil 8710} 8711 8712func awsAwsjson11_deserializeDocumentSelfservicePermissions(v **types.SelfservicePermissions, value interface{}) error { 8713 if v == nil { 8714 return fmt.Errorf("unexpected nil of type %T", v) 8715 } 8716 if value == nil { 8717 return nil 8718 } 8719 8720 shape, ok := value.(map[string]interface{}) 8721 if !ok { 8722 return fmt.Errorf("unexpected JSON type %v", value) 8723 } 8724 8725 var sv *types.SelfservicePermissions 8726 if *v == nil { 8727 sv = &types.SelfservicePermissions{} 8728 } else { 8729 sv = *v 8730 } 8731 8732 for key, value := range shape { 8733 switch key { 8734 case "ChangeComputeType": 8735 if value != nil { 8736 jtv, ok := value.(string) 8737 if !ok { 8738 return fmt.Errorf("expected ReconnectEnum to be of type string, got %T instead", value) 8739 } 8740 sv.ChangeComputeType = types.ReconnectEnum(jtv) 8741 } 8742 8743 case "IncreaseVolumeSize": 8744 if value != nil { 8745 jtv, ok := value.(string) 8746 if !ok { 8747 return fmt.Errorf("expected ReconnectEnum to be of type string, got %T instead", value) 8748 } 8749 sv.IncreaseVolumeSize = types.ReconnectEnum(jtv) 8750 } 8751 8752 case "RebuildWorkspace": 8753 if value != nil { 8754 jtv, ok := value.(string) 8755 if !ok { 8756 return fmt.Errorf("expected ReconnectEnum to be of type string, got %T instead", value) 8757 } 8758 sv.RebuildWorkspace = types.ReconnectEnum(jtv) 8759 } 8760 8761 case "RestartWorkspace": 8762 if value != nil { 8763 jtv, ok := value.(string) 8764 if !ok { 8765 return fmt.Errorf("expected ReconnectEnum to be of type string, got %T instead", value) 8766 } 8767 sv.RestartWorkspace = types.ReconnectEnum(jtv) 8768 } 8769 8770 case "SwitchRunningMode": 8771 if value != nil { 8772 jtv, ok := value.(string) 8773 if !ok { 8774 return fmt.Errorf("expected ReconnectEnum to be of type string, got %T instead", value) 8775 } 8776 sv.SwitchRunningMode = types.ReconnectEnum(jtv) 8777 } 8778 8779 default: 8780 _, _ = key, value 8781 8782 } 8783 } 8784 *v = sv 8785 return nil 8786} 8787 8788func awsAwsjson11_deserializeDocumentSnapshot(v **types.Snapshot, value interface{}) error { 8789 if v == nil { 8790 return fmt.Errorf("unexpected nil of type %T", v) 8791 } 8792 if value == nil { 8793 return nil 8794 } 8795 8796 shape, ok := value.(map[string]interface{}) 8797 if !ok { 8798 return fmt.Errorf("unexpected JSON type %v", value) 8799 } 8800 8801 var sv *types.Snapshot 8802 if *v == nil { 8803 sv = &types.Snapshot{} 8804 } else { 8805 sv = *v 8806 } 8807 8808 for key, value := range shape { 8809 switch key { 8810 case "SnapshotTime": 8811 if value != nil { 8812 jtv, ok := value.(json.Number) 8813 if !ok { 8814 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8815 } 8816 f64, err := jtv.Float64() 8817 if err != nil { 8818 return err 8819 } 8820 sv.SnapshotTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8821 } 8822 8823 default: 8824 _, _ = key, value 8825 8826 } 8827 } 8828 *v = sv 8829 return nil 8830} 8831 8832func awsAwsjson11_deserializeDocumentSnapshotList(v *[]types.Snapshot, value interface{}) error { 8833 if v == nil { 8834 return fmt.Errorf("unexpected nil of type %T", v) 8835 } 8836 if value == nil { 8837 return nil 8838 } 8839 8840 shape, ok := value.([]interface{}) 8841 if !ok { 8842 return fmt.Errorf("unexpected JSON type %v", value) 8843 } 8844 8845 var cv []types.Snapshot 8846 if *v == nil { 8847 cv = []types.Snapshot{} 8848 } else { 8849 cv = *v 8850 } 8851 8852 for _, value := range shape { 8853 var col types.Snapshot 8854 destAddr := &col 8855 if err := awsAwsjson11_deserializeDocumentSnapshot(&destAddr, value); err != nil { 8856 return err 8857 } 8858 col = *destAddr 8859 cv = append(cv, col) 8860 8861 } 8862 *v = cv 8863 return nil 8864} 8865 8866func awsAwsjson11_deserializeDocumentSubnetIds(v *[]string, value interface{}) error { 8867 if v == nil { 8868 return fmt.Errorf("unexpected nil of type %T", v) 8869 } 8870 if value == nil { 8871 return nil 8872 } 8873 8874 shape, ok := value.([]interface{}) 8875 if !ok { 8876 return fmt.Errorf("unexpected JSON type %v", value) 8877 } 8878 8879 var cv []string 8880 if *v == nil { 8881 cv = []string{} 8882 } else { 8883 cv = *v 8884 } 8885 8886 for _, value := range shape { 8887 var col string 8888 if value != nil { 8889 jtv, ok := value.(string) 8890 if !ok { 8891 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 8892 } 8893 col = jtv 8894 } 8895 cv = append(cv, col) 8896 8897 } 8898 *v = cv 8899 return nil 8900} 8901 8902func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 8903 if v == nil { 8904 return fmt.Errorf("unexpected nil of type %T", v) 8905 } 8906 if value == nil { 8907 return nil 8908 } 8909 8910 shape, ok := value.(map[string]interface{}) 8911 if !ok { 8912 return fmt.Errorf("unexpected JSON type %v", value) 8913 } 8914 8915 var sv *types.Tag 8916 if *v == nil { 8917 sv = &types.Tag{} 8918 } else { 8919 sv = *v 8920 } 8921 8922 for key, value := range shape { 8923 switch key { 8924 case "Key": 8925 if value != nil { 8926 jtv, ok := value.(string) 8927 if !ok { 8928 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 8929 } 8930 sv.Key = ptr.String(jtv) 8931 } 8932 8933 case "Value": 8934 if value != nil { 8935 jtv, ok := value.(string) 8936 if !ok { 8937 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 8938 } 8939 sv.Value = ptr.String(jtv) 8940 } 8941 8942 default: 8943 _, _ = key, value 8944 8945 } 8946 } 8947 *v = sv 8948 return nil 8949} 8950 8951func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 8952 if v == nil { 8953 return fmt.Errorf("unexpected nil of type %T", v) 8954 } 8955 if value == nil { 8956 return nil 8957 } 8958 8959 shape, ok := value.([]interface{}) 8960 if !ok { 8961 return fmt.Errorf("unexpected JSON type %v", value) 8962 } 8963 8964 var cv []types.Tag 8965 if *v == nil { 8966 cv = []types.Tag{} 8967 } else { 8968 cv = *v 8969 } 8970 8971 for _, value := range shape { 8972 var col types.Tag 8973 destAddr := &col 8974 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 8975 return err 8976 } 8977 col = *destAddr 8978 cv = append(cv, col) 8979 8980 } 8981 *v = cv 8982 return nil 8983} 8984 8985func awsAwsjson11_deserializeDocumentUnsupportedNetworkConfigurationException(v **types.UnsupportedNetworkConfigurationException, value interface{}) error { 8986 if v == nil { 8987 return fmt.Errorf("unexpected nil of type %T", v) 8988 } 8989 if value == nil { 8990 return nil 8991 } 8992 8993 shape, ok := value.(map[string]interface{}) 8994 if !ok { 8995 return fmt.Errorf("unexpected JSON type %v", value) 8996 } 8997 8998 var sv *types.UnsupportedNetworkConfigurationException 8999 if *v == nil { 9000 sv = &types.UnsupportedNetworkConfigurationException{} 9001 } else { 9002 sv = *v 9003 } 9004 9005 for key, value := range shape { 9006 switch key { 9007 case "message": 9008 if value != nil { 9009 jtv, ok := value.(string) 9010 if !ok { 9011 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9012 } 9013 sv.Message = ptr.String(jtv) 9014 } 9015 9016 default: 9017 _, _ = key, value 9018 9019 } 9020 } 9021 *v = sv 9022 return nil 9023} 9024 9025func awsAwsjson11_deserializeDocumentUnsupportedWorkspaceConfigurationException(v **types.UnsupportedWorkspaceConfigurationException, value interface{}) error { 9026 if v == nil { 9027 return fmt.Errorf("unexpected nil of type %T", v) 9028 } 9029 if value == nil { 9030 return nil 9031 } 9032 9033 shape, ok := value.(map[string]interface{}) 9034 if !ok { 9035 return fmt.Errorf("unexpected JSON type %v", value) 9036 } 9037 9038 var sv *types.UnsupportedWorkspaceConfigurationException 9039 if *v == nil { 9040 sv = &types.UnsupportedWorkspaceConfigurationException{} 9041 } else { 9042 sv = *v 9043 } 9044 9045 for key, value := range shape { 9046 switch key { 9047 case "message": 9048 if value != nil { 9049 jtv, ok := value.(string) 9050 if !ok { 9051 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9052 } 9053 sv.Message = ptr.String(jtv) 9054 } 9055 9056 default: 9057 _, _ = key, value 9058 9059 } 9060 } 9061 *v = sv 9062 return nil 9063} 9064 9065func awsAwsjson11_deserializeDocumentUserStorage(v **types.UserStorage, value interface{}) error { 9066 if v == nil { 9067 return fmt.Errorf("unexpected nil of type %T", v) 9068 } 9069 if value == nil { 9070 return nil 9071 } 9072 9073 shape, ok := value.(map[string]interface{}) 9074 if !ok { 9075 return fmt.Errorf("unexpected JSON type %v", value) 9076 } 9077 9078 var sv *types.UserStorage 9079 if *v == nil { 9080 sv = &types.UserStorage{} 9081 } else { 9082 sv = *v 9083 } 9084 9085 for key, value := range shape { 9086 switch key { 9087 case "Capacity": 9088 if value != nil { 9089 jtv, ok := value.(string) 9090 if !ok { 9091 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value) 9092 } 9093 sv.Capacity = ptr.String(jtv) 9094 } 9095 9096 default: 9097 _, _ = key, value 9098 9099 } 9100 } 9101 *v = sv 9102 return nil 9103} 9104 9105func awsAwsjson11_deserializeDocumentWorkspace(v **types.Workspace, value interface{}) error { 9106 if v == nil { 9107 return fmt.Errorf("unexpected nil of type %T", v) 9108 } 9109 if value == nil { 9110 return nil 9111 } 9112 9113 shape, ok := value.(map[string]interface{}) 9114 if !ok { 9115 return fmt.Errorf("unexpected JSON type %v", value) 9116 } 9117 9118 var sv *types.Workspace 9119 if *v == nil { 9120 sv = &types.Workspace{} 9121 } else { 9122 sv = *v 9123 } 9124 9125 for key, value := range shape { 9126 switch key { 9127 case "BundleId": 9128 if value != nil { 9129 jtv, ok := value.(string) 9130 if !ok { 9131 return fmt.Errorf("expected BundleId to be of type string, got %T instead", value) 9132 } 9133 sv.BundleId = ptr.String(jtv) 9134 } 9135 9136 case "ComputerName": 9137 if value != nil { 9138 jtv, ok := value.(string) 9139 if !ok { 9140 return fmt.Errorf("expected ComputerName to be of type string, got %T instead", value) 9141 } 9142 sv.ComputerName = ptr.String(jtv) 9143 } 9144 9145 case "DirectoryId": 9146 if value != nil { 9147 jtv, ok := value.(string) 9148 if !ok { 9149 return fmt.Errorf("expected DirectoryId to be of type string, got %T instead", value) 9150 } 9151 sv.DirectoryId = ptr.String(jtv) 9152 } 9153 9154 case "ErrorCode": 9155 if value != nil { 9156 jtv, ok := value.(string) 9157 if !ok { 9158 return fmt.Errorf("expected WorkspaceErrorCode to be of type string, got %T instead", value) 9159 } 9160 sv.ErrorCode = ptr.String(jtv) 9161 } 9162 9163 case "ErrorMessage": 9164 if value != nil { 9165 jtv, ok := value.(string) 9166 if !ok { 9167 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 9168 } 9169 sv.ErrorMessage = ptr.String(jtv) 9170 } 9171 9172 case "IpAddress": 9173 if value != nil { 9174 jtv, ok := value.(string) 9175 if !ok { 9176 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value) 9177 } 9178 sv.IpAddress = ptr.String(jtv) 9179 } 9180 9181 case "ModificationStates": 9182 if err := awsAwsjson11_deserializeDocumentModificationStateList(&sv.ModificationStates, value); err != nil { 9183 return err 9184 } 9185 9186 case "RootVolumeEncryptionEnabled": 9187 if value != nil { 9188 jtv, ok := value.(bool) 9189 if !ok { 9190 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 9191 } 9192 sv.RootVolumeEncryptionEnabled = ptr.Bool(jtv) 9193 } 9194 9195 case "State": 9196 if value != nil { 9197 jtv, ok := value.(string) 9198 if !ok { 9199 return fmt.Errorf("expected WorkspaceState to be of type string, got %T instead", value) 9200 } 9201 sv.State = types.WorkspaceState(jtv) 9202 } 9203 9204 case "SubnetId": 9205 if value != nil { 9206 jtv, ok := value.(string) 9207 if !ok { 9208 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 9209 } 9210 sv.SubnetId = ptr.String(jtv) 9211 } 9212 9213 case "UserName": 9214 if value != nil { 9215 jtv, ok := value.(string) 9216 if !ok { 9217 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 9218 } 9219 sv.UserName = ptr.String(jtv) 9220 } 9221 9222 case "UserVolumeEncryptionEnabled": 9223 if value != nil { 9224 jtv, ok := value.(bool) 9225 if !ok { 9226 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 9227 } 9228 sv.UserVolumeEncryptionEnabled = ptr.Bool(jtv) 9229 } 9230 9231 case "VolumeEncryptionKey": 9232 if value != nil { 9233 jtv, ok := value.(string) 9234 if !ok { 9235 return fmt.Errorf("expected VolumeEncryptionKey to be of type string, got %T instead", value) 9236 } 9237 sv.VolumeEncryptionKey = ptr.String(jtv) 9238 } 9239 9240 case "WorkspaceId": 9241 if value != nil { 9242 jtv, ok := value.(string) 9243 if !ok { 9244 return fmt.Errorf("expected WorkspaceId to be of type string, got %T instead", value) 9245 } 9246 sv.WorkspaceId = ptr.String(jtv) 9247 } 9248 9249 case "WorkspaceProperties": 9250 if err := awsAwsjson11_deserializeDocumentWorkspaceProperties(&sv.WorkspaceProperties, value); err != nil { 9251 return err 9252 } 9253 9254 default: 9255 _, _ = key, value 9256 9257 } 9258 } 9259 *v = sv 9260 return nil 9261} 9262 9263func awsAwsjson11_deserializeDocumentWorkspaceAccessProperties(v **types.WorkspaceAccessProperties, value interface{}) error { 9264 if v == nil { 9265 return fmt.Errorf("unexpected nil of type %T", v) 9266 } 9267 if value == nil { 9268 return nil 9269 } 9270 9271 shape, ok := value.(map[string]interface{}) 9272 if !ok { 9273 return fmt.Errorf("unexpected JSON type %v", value) 9274 } 9275 9276 var sv *types.WorkspaceAccessProperties 9277 if *v == nil { 9278 sv = &types.WorkspaceAccessProperties{} 9279 } else { 9280 sv = *v 9281 } 9282 9283 for key, value := range shape { 9284 switch key { 9285 case "DeviceTypeAndroid": 9286 if value != nil { 9287 jtv, ok := value.(string) 9288 if !ok { 9289 return fmt.Errorf("expected AccessPropertyValue to be of type string, got %T instead", value) 9290 } 9291 sv.DeviceTypeAndroid = types.AccessPropertyValue(jtv) 9292 } 9293 9294 case "DeviceTypeChromeOs": 9295 if value != nil { 9296 jtv, ok := value.(string) 9297 if !ok { 9298 return fmt.Errorf("expected AccessPropertyValue to be of type string, got %T instead", value) 9299 } 9300 sv.DeviceTypeChromeOs = types.AccessPropertyValue(jtv) 9301 } 9302 9303 case "DeviceTypeIos": 9304 if value != nil { 9305 jtv, ok := value.(string) 9306 if !ok { 9307 return fmt.Errorf("expected AccessPropertyValue to be of type string, got %T instead", value) 9308 } 9309 sv.DeviceTypeIos = types.AccessPropertyValue(jtv) 9310 } 9311 9312 case "DeviceTypeOsx": 9313 if value != nil { 9314 jtv, ok := value.(string) 9315 if !ok { 9316 return fmt.Errorf("expected AccessPropertyValue to be of type string, got %T instead", value) 9317 } 9318 sv.DeviceTypeOsx = types.AccessPropertyValue(jtv) 9319 } 9320 9321 case "DeviceTypeWeb": 9322 if value != nil { 9323 jtv, ok := value.(string) 9324 if !ok { 9325 return fmt.Errorf("expected AccessPropertyValue to be of type string, got %T instead", value) 9326 } 9327 sv.DeviceTypeWeb = types.AccessPropertyValue(jtv) 9328 } 9329 9330 case "DeviceTypeWindows": 9331 if value != nil { 9332 jtv, ok := value.(string) 9333 if !ok { 9334 return fmt.Errorf("expected AccessPropertyValue to be of type string, got %T instead", value) 9335 } 9336 sv.DeviceTypeWindows = types.AccessPropertyValue(jtv) 9337 } 9338 9339 case "DeviceTypeZeroClient": 9340 if value != nil { 9341 jtv, ok := value.(string) 9342 if !ok { 9343 return fmt.Errorf("expected AccessPropertyValue to be of type string, got %T instead", value) 9344 } 9345 sv.DeviceTypeZeroClient = types.AccessPropertyValue(jtv) 9346 } 9347 9348 default: 9349 _, _ = key, value 9350 9351 } 9352 } 9353 *v = sv 9354 return nil 9355} 9356 9357func awsAwsjson11_deserializeDocumentWorkspaceBundle(v **types.WorkspaceBundle, value interface{}) error { 9358 if v == nil { 9359 return fmt.Errorf("unexpected nil of type %T", v) 9360 } 9361 if value == nil { 9362 return nil 9363 } 9364 9365 shape, ok := value.(map[string]interface{}) 9366 if !ok { 9367 return fmt.Errorf("unexpected JSON type %v", value) 9368 } 9369 9370 var sv *types.WorkspaceBundle 9371 if *v == nil { 9372 sv = &types.WorkspaceBundle{} 9373 } else { 9374 sv = *v 9375 } 9376 9377 for key, value := range shape { 9378 switch key { 9379 case "BundleId": 9380 if value != nil { 9381 jtv, ok := value.(string) 9382 if !ok { 9383 return fmt.Errorf("expected BundleId to be of type string, got %T instead", value) 9384 } 9385 sv.BundleId = ptr.String(jtv) 9386 } 9387 9388 case "ComputeType": 9389 if err := awsAwsjson11_deserializeDocumentComputeType(&sv.ComputeType, value); err != nil { 9390 return err 9391 } 9392 9393 case "CreationTime": 9394 if value != nil { 9395 jtv, ok := value.(json.Number) 9396 if !ok { 9397 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9398 } 9399 f64, err := jtv.Float64() 9400 if err != nil { 9401 return err 9402 } 9403 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9404 } 9405 9406 case "Description": 9407 if value != nil { 9408 jtv, ok := value.(string) 9409 if !ok { 9410 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 9411 } 9412 sv.Description = ptr.String(jtv) 9413 } 9414 9415 case "ImageId": 9416 if value != nil { 9417 jtv, ok := value.(string) 9418 if !ok { 9419 return fmt.Errorf("expected WorkspaceImageId to be of type string, got %T instead", value) 9420 } 9421 sv.ImageId = ptr.String(jtv) 9422 } 9423 9424 case "LastUpdatedTime": 9425 if value != nil { 9426 jtv, ok := value.(json.Number) 9427 if !ok { 9428 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9429 } 9430 f64, err := jtv.Float64() 9431 if err != nil { 9432 return err 9433 } 9434 sv.LastUpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9435 } 9436 9437 case "Name": 9438 if value != nil { 9439 jtv, ok := value.(string) 9440 if !ok { 9441 return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value) 9442 } 9443 sv.Name = ptr.String(jtv) 9444 } 9445 9446 case "Owner": 9447 if value != nil { 9448 jtv, ok := value.(string) 9449 if !ok { 9450 return fmt.Errorf("expected BundleOwner to be of type string, got %T instead", value) 9451 } 9452 sv.Owner = ptr.String(jtv) 9453 } 9454 9455 case "RootStorage": 9456 if err := awsAwsjson11_deserializeDocumentRootStorage(&sv.RootStorage, value); err != nil { 9457 return err 9458 } 9459 9460 case "UserStorage": 9461 if err := awsAwsjson11_deserializeDocumentUserStorage(&sv.UserStorage, value); err != nil { 9462 return err 9463 } 9464 9465 default: 9466 _, _ = key, value 9467 9468 } 9469 } 9470 *v = sv 9471 return nil 9472} 9473 9474func awsAwsjson11_deserializeDocumentWorkspaceConnectionStatus(v **types.WorkspaceConnectionStatus, value interface{}) error { 9475 if v == nil { 9476 return fmt.Errorf("unexpected nil of type %T", v) 9477 } 9478 if value == nil { 9479 return nil 9480 } 9481 9482 shape, ok := value.(map[string]interface{}) 9483 if !ok { 9484 return fmt.Errorf("unexpected JSON type %v", value) 9485 } 9486 9487 var sv *types.WorkspaceConnectionStatus 9488 if *v == nil { 9489 sv = &types.WorkspaceConnectionStatus{} 9490 } else { 9491 sv = *v 9492 } 9493 9494 for key, value := range shape { 9495 switch key { 9496 case "ConnectionState": 9497 if value != nil { 9498 jtv, ok := value.(string) 9499 if !ok { 9500 return fmt.Errorf("expected ConnectionState to be of type string, got %T instead", value) 9501 } 9502 sv.ConnectionState = types.ConnectionState(jtv) 9503 } 9504 9505 case "ConnectionStateCheckTimestamp": 9506 if value != nil { 9507 jtv, ok := value.(json.Number) 9508 if !ok { 9509 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9510 } 9511 f64, err := jtv.Float64() 9512 if err != nil { 9513 return err 9514 } 9515 sv.ConnectionStateCheckTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9516 } 9517 9518 case "LastKnownUserConnectionTimestamp": 9519 if value != nil { 9520 jtv, ok := value.(json.Number) 9521 if !ok { 9522 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9523 } 9524 f64, err := jtv.Float64() 9525 if err != nil { 9526 return err 9527 } 9528 sv.LastKnownUserConnectionTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9529 } 9530 9531 case "WorkspaceId": 9532 if value != nil { 9533 jtv, ok := value.(string) 9534 if !ok { 9535 return fmt.Errorf("expected WorkspaceId to be of type string, got %T instead", value) 9536 } 9537 sv.WorkspaceId = ptr.String(jtv) 9538 } 9539 9540 default: 9541 _, _ = key, value 9542 9543 } 9544 } 9545 *v = sv 9546 return nil 9547} 9548 9549func awsAwsjson11_deserializeDocumentWorkspaceConnectionStatusList(v *[]types.WorkspaceConnectionStatus, value interface{}) error { 9550 if v == nil { 9551 return fmt.Errorf("unexpected nil of type %T", v) 9552 } 9553 if value == nil { 9554 return nil 9555 } 9556 9557 shape, ok := value.([]interface{}) 9558 if !ok { 9559 return fmt.Errorf("unexpected JSON type %v", value) 9560 } 9561 9562 var cv []types.WorkspaceConnectionStatus 9563 if *v == nil { 9564 cv = []types.WorkspaceConnectionStatus{} 9565 } else { 9566 cv = *v 9567 } 9568 9569 for _, value := range shape { 9570 var col types.WorkspaceConnectionStatus 9571 destAddr := &col 9572 if err := awsAwsjson11_deserializeDocumentWorkspaceConnectionStatus(&destAddr, value); err != nil { 9573 return err 9574 } 9575 col = *destAddr 9576 cv = append(cv, col) 9577 9578 } 9579 *v = cv 9580 return nil 9581} 9582 9583func awsAwsjson11_deserializeDocumentWorkspaceDirectory(v **types.WorkspaceDirectory, value interface{}) error { 9584 if v == nil { 9585 return fmt.Errorf("unexpected nil of type %T", v) 9586 } 9587 if value == nil { 9588 return nil 9589 } 9590 9591 shape, ok := value.(map[string]interface{}) 9592 if !ok { 9593 return fmt.Errorf("unexpected JSON type %v", value) 9594 } 9595 9596 var sv *types.WorkspaceDirectory 9597 if *v == nil { 9598 sv = &types.WorkspaceDirectory{} 9599 } else { 9600 sv = *v 9601 } 9602 9603 for key, value := range shape { 9604 switch key { 9605 case "Alias": 9606 if value != nil { 9607 jtv, ok := value.(string) 9608 if !ok { 9609 return fmt.Errorf("expected Alias to be of type string, got %T instead", value) 9610 } 9611 sv.Alias = ptr.String(jtv) 9612 } 9613 9614 case "CustomerUserName": 9615 if value != nil { 9616 jtv, ok := value.(string) 9617 if !ok { 9618 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 9619 } 9620 sv.CustomerUserName = ptr.String(jtv) 9621 } 9622 9623 case "DirectoryId": 9624 if value != nil { 9625 jtv, ok := value.(string) 9626 if !ok { 9627 return fmt.Errorf("expected DirectoryId to be of type string, got %T instead", value) 9628 } 9629 sv.DirectoryId = ptr.String(jtv) 9630 } 9631 9632 case "DirectoryName": 9633 if value != nil { 9634 jtv, ok := value.(string) 9635 if !ok { 9636 return fmt.Errorf("expected DirectoryName to be of type string, got %T instead", value) 9637 } 9638 sv.DirectoryName = ptr.String(jtv) 9639 } 9640 9641 case "DirectoryType": 9642 if value != nil { 9643 jtv, ok := value.(string) 9644 if !ok { 9645 return fmt.Errorf("expected WorkspaceDirectoryType to be of type string, got %T instead", value) 9646 } 9647 sv.DirectoryType = types.WorkspaceDirectoryType(jtv) 9648 } 9649 9650 case "DnsIpAddresses": 9651 if err := awsAwsjson11_deserializeDocumentDnsIpAddresses(&sv.DnsIpAddresses, value); err != nil { 9652 return err 9653 } 9654 9655 case "IamRoleId": 9656 if value != nil { 9657 jtv, ok := value.(string) 9658 if !ok { 9659 return fmt.Errorf("expected ARN to be of type string, got %T instead", value) 9660 } 9661 sv.IamRoleId = ptr.String(jtv) 9662 } 9663 9664 case "ipGroupIds": 9665 if err := awsAwsjson11_deserializeDocumentIpGroupIdList(&sv.IpGroupIds, value); err != nil { 9666 return err 9667 } 9668 9669 case "RegistrationCode": 9670 if value != nil { 9671 jtv, ok := value.(string) 9672 if !ok { 9673 return fmt.Errorf("expected RegistrationCode to be of type string, got %T instead", value) 9674 } 9675 sv.RegistrationCode = ptr.String(jtv) 9676 } 9677 9678 case "SelfservicePermissions": 9679 if err := awsAwsjson11_deserializeDocumentSelfservicePermissions(&sv.SelfservicePermissions, value); err != nil { 9680 return err 9681 } 9682 9683 case "State": 9684 if value != nil { 9685 jtv, ok := value.(string) 9686 if !ok { 9687 return fmt.Errorf("expected WorkspaceDirectoryState to be of type string, got %T instead", value) 9688 } 9689 sv.State = types.WorkspaceDirectoryState(jtv) 9690 } 9691 9692 case "SubnetIds": 9693 if err := awsAwsjson11_deserializeDocumentSubnetIds(&sv.SubnetIds, value); err != nil { 9694 return err 9695 } 9696 9697 case "Tenancy": 9698 if value != nil { 9699 jtv, ok := value.(string) 9700 if !ok { 9701 return fmt.Errorf("expected Tenancy to be of type string, got %T instead", value) 9702 } 9703 sv.Tenancy = types.Tenancy(jtv) 9704 } 9705 9706 case "WorkspaceAccessProperties": 9707 if err := awsAwsjson11_deserializeDocumentWorkspaceAccessProperties(&sv.WorkspaceAccessProperties, value); err != nil { 9708 return err 9709 } 9710 9711 case "WorkspaceCreationProperties": 9712 if err := awsAwsjson11_deserializeDocumentDefaultWorkspaceCreationProperties(&sv.WorkspaceCreationProperties, value); err != nil { 9713 return err 9714 } 9715 9716 case "WorkspaceSecurityGroupId": 9717 if value != nil { 9718 jtv, ok := value.(string) 9719 if !ok { 9720 return fmt.Errorf("expected SecurityGroupId to be of type string, got %T instead", value) 9721 } 9722 sv.WorkspaceSecurityGroupId = ptr.String(jtv) 9723 } 9724 9725 default: 9726 _, _ = key, value 9727 9728 } 9729 } 9730 *v = sv 9731 return nil 9732} 9733 9734func awsAwsjson11_deserializeDocumentWorkspaceImage(v **types.WorkspaceImage, value interface{}) error { 9735 if v == nil { 9736 return fmt.Errorf("unexpected nil of type %T", v) 9737 } 9738 if value == nil { 9739 return nil 9740 } 9741 9742 shape, ok := value.(map[string]interface{}) 9743 if !ok { 9744 return fmt.Errorf("unexpected JSON type %v", value) 9745 } 9746 9747 var sv *types.WorkspaceImage 9748 if *v == nil { 9749 sv = &types.WorkspaceImage{} 9750 } else { 9751 sv = *v 9752 } 9753 9754 for key, value := range shape { 9755 switch key { 9756 case "Created": 9757 if value != nil { 9758 jtv, ok := value.(json.Number) 9759 if !ok { 9760 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9761 } 9762 f64, err := jtv.Float64() 9763 if err != nil { 9764 return err 9765 } 9766 sv.Created = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9767 } 9768 9769 case "Description": 9770 if value != nil { 9771 jtv, ok := value.(string) 9772 if !ok { 9773 return fmt.Errorf("expected WorkspaceImageDescription to be of type string, got %T instead", value) 9774 } 9775 sv.Description = ptr.String(jtv) 9776 } 9777 9778 case "ErrorCode": 9779 if value != nil { 9780 jtv, ok := value.(string) 9781 if !ok { 9782 return fmt.Errorf("expected WorkspaceImageErrorCode to be of type string, got %T instead", value) 9783 } 9784 sv.ErrorCode = ptr.String(jtv) 9785 } 9786 9787 case "ErrorMessage": 9788 if value != nil { 9789 jtv, ok := value.(string) 9790 if !ok { 9791 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 9792 } 9793 sv.ErrorMessage = ptr.String(jtv) 9794 } 9795 9796 case "ImageId": 9797 if value != nil { 9798 jtv, ok := value.(string) 9799 if !ok { 9800 return fmt.Errorf("expected WorkspaceImageId to be of type string, got %T instead", value) 9801 } 9802 sv.ImageId = ptr.String(jtv) 9803 } 9804 9805 case "Name": 9806 if value != nil { 9807 jtv, ok := value.(string) 9808 if !ok { 9809 return fmt.Errorf("expected WorkspaceImageName to be of type string, got %T instead", value) 9810 } 9811 sv.Name = ptr.String(jtv) 9812 } 9813 9814 case "OperatingSystem": 9815 if err := awsAwsjson11_deserializeDocumentOperatingSystem(&sv.OperatingSystem, value); err != nil { 9816 return err 9817 } 9818 9819 case "OwnerAccountId": 9820 if value != nil { 9821 jtv, ok := value.(string) 9822 if !ok { 9823 return fmt.Errorf("expected AwsAccount to be of type string, got %T instead", value) 9824 } 9825 sv.OwnerAccountId = ptr.String(jtv) 9826 } 9827 9828 case "RequiredTenancy": 9829 if value != nil { 9830 jtv, ok := value.(string) 9831 if !ok { 9832 return fmt.Errorf("expected WorkspaceImageRequiredTenancy to be of type string, got %T instead", value) 9833 } 9834 sv.RequiredTenancy = types.WorkspaceImageRequiredTenancy(jtv) 9835 } 9836 9837 case "State": 9838 if value != nil { 9839 jtv, ok := value.(string) 9840 if !ok { 9841 return fmt.Errorf("expected WorkspaceImageState to be of type string, got %T instead", value) 9842 } 9843 sv.State = types.WorkspaceImageState(jtv) 9844 } 9845 9846 default: 9847 _, _ = key, value 9848 9849 } 9850 } 9851 *v = sv 9852 return nil 9853} 9854 9855func awsAwsjson11_deserializeDocumentWorkspaceImageList(v *[]types.WorkspaceImage, value interface{}) error { 9856 if v == nil { 9857 return fmt.Errorf("unexpected nil of type %T", v) 9858 } 9859 if value == nil { 9860 return nil 9861 } 9862 9863 shape, ok := value.([]interface{}) 9864 if !ok { 9865 return fmt.Errorf("unexpected JSON type %v", value) 9866 } 9867 9868 var cv []types.WorkspaceImage 9869 if *v == nil { 9870 cv = []types.WorkspaceImage{} 9871 } else { 9872 cv = *v 9873 } 9874 9875 for _, value := range shape { 9876 var col types.WorkspaceImage 9877 destAddr := &col 9878 if err := awsAwsjson11_deserializeDocumentWorkspaceImage(&destAddr, value); err != nil { 9879 return err 9880 } 9881 col = *destAddr 9882 cv = append(cv, col) 9883 9884 } 9885 *v = cv 9886 return nil 9887} 9888 9889func awsAwsjson11_deserializeDocumentWorkspaceList(v *[]types.Workspace, value interface{}) error { 9890 if v == nil { 9891 return fmt.Errorf("unexpected nil of type %T", v) 9892 } 9893 if value == nil { 9894 return nil 9895 } 9896 9897 shape, ok := value.([]interface{}) 9898 if !ok { 9899 return fmt.Errorf("unexpected JSON type %v", value) 9900 } 9901 9902 var cv []types.Workspace 9903 if *v == nil { 9904 cv = []types.Workspace{} 9905 } else { 9906 cv = *v 9907 } 9908 9909 for _, value := range shape { 9910 var col types.Workspace 9911 destAddr := &col 9912 if err := awsAwsjson11_deserializeDocumentWorkspace(&destAddr, value); err != nil { 9913 return err 9914 } 9915 col = *destAddr 9916 cv = append(cv, col) 9917 9918 } 9919 *v = cv 9920 return nil 9921} 9922 9923func awsAwsjson11_deserializeDocumentWorkspaceProperties(v **types.WorkspaceProperties, value interface{}) error { 9924 if v == nil { 9925 return fmt.Errorf("unexpected nil of type %T", v) 9926 } 9927 if value == nil { 9928 return nil 9929 } 9930 9931 shape, ok := value.(map[string]interface{}) 9932 if !ok { 9933 return fmt.Errorf("unexpected JSON type %v", value) 9934 } 9935 9936 var sv *types.WorkspaceProperties 9937 if *v == nil { 9938 sv = &types.WorkspaceProperties{} 9939 } else { 9940 sv = *v 9941 } 9942 9943 for key, value := range shape { 9944 switch key { 9945 case "ComputeTypeName": 9946 if value != nil { 9947 jtv, ok := value.(string) 9948 if !ok { 9949 return fmt.Errorf("expected Compute to be of type string, got %T instead", value) 9950 } 9951 sv.ComputeTypeName = types.Compute(jtv) 9952 } 9953 9954 case "RootVolumeSizeGib": 9955 if value != nil { 9956 jtv, ok := value.(json.Number) 9957 if !ok { 9958 return fmt.Errorf("expected RootVolumeSizeGib to be json.Number, got %T instead", value) 9959 } 9960 i64, err := jtv.Int64() 9961 if err != nil { 9962 return err 9963 } 9964 sv.RootVolumeSizeGib = ptr.Int32(int32(i64)) 9965 } 9966 9967 case "RunningMode": 9968 if value != nil { 9969 jtv, ok := value.(string) 9970 if !ok { 9971 return fmt.Errorf("expected RunningMode to be of type string, got %T instead", value) 9972 } 9973 sv.RunningMode = types.RunningMode(jtv) 9974 } 9975 9976 case "RunningModeAutoStopTimeoutInMinutes": 9977 if value != nil { 9978 jtv, ok := value.(json.Number) 9979 if !ok { 9980 return fmt.Errorf("expected RunningModeAutoStopTimeoutInMinutes to be json.Number, got %T instead", value) 9981 } 9982 i64, err := jtv.Int64() 9983 if err != nil { 9984 return err 9985 } 9986 sv.RunningModeAutoStopTimeoutInMinutes = ptr.Int32(int32(i64)) 9987 } 9988 9989 case "UserVolumeSizeGib": 9990 if value != nil { 9991 jtv, ok := value.(json.Number) 9992 if !ok { 9993 return fmt.Errorf("expected UserVolumeSizeGib to be json.Number, got %T instead", value) 9994 } 9995 i64, err := jtv.Int64() 9996 if err != nil { 9997 return err 9998 } 9999 sv.UserVolumeSizeGib = ptr.Int32(int32(i64)) 10000 } 10001 10002 default: 10003 _, _ = key, value 10004 10005 } 10006 } 10007 *v = sv 10008 return nil 10009} 10010 10011func awsAwsjson11_deserializeDocumentWorkspaceRequest(v **types.WorkspaceRequest, value interface{}) error { 10012 if v == nil { 10013 return fmt.Errorf("unexpected nil of type %T", v) 10014 } 10015 if value == nil { 10016 return nil 10017 } 10018 10019 shape, ok := value.(map[string]interface{}) 10020 if !ok { 10021 return fmt.Errorf("unexpected JSON type %v", value) 10022 } 10023 10024 var sv *types.WorkspaceRequest 10025 if *v == nil { 10026 sv = &types.WorkspaceRequest{} 10027 } else { 10028 sv = *v 10029 } 10030 10031 for key, value := range shape { 10032 switch key { 10033 case "BundleId": 10034 if value != nil { 10035 jtv, ok := value.(string) 10036 if !ok { 10037 return fmt.Errorf("expected BundleId to be of type string, got %T instead", value) 10038 } 10039 sv.BundleId = ptr.String(jtv) 10040 } 10041 10042 case "DirectoryId": 10043 if value != nil { 10044 jtv, ok := value.(string) 10045 if !ok { 10046 return fmt.Errorf("expected DirectoryId to be of type string, got %T instead", value) 10047 } 10048 sv.DirectoryId = ptr.String(jtv) 10049 } 10050 10051 case "RootVolumeEncryptionEnabled": 10052 if value != nil { 10053 jtv, ok := value.(bool) 10054 if !ok { 10055 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 10056 } 10057 sv.RootVolumeEncryptionEnabled = ptr.Bool(jtv) 10058 } 10059 10060 case "Tags": 10061 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 10062 return err 10063 } 10064 10065 case "UserName": 10066 if value != nil { 10067 jtv, ok := value.(string) 10068 if !ok { 10069 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 10070 } 10071 sv.UserName = ptr.String(jtv) 10072 } 10073 10074 case "UserVolumeEncryptionEnabled": 10075 if value != nil { 10076 jtv, ok := value.(bool) 10077 if !ok { 10078 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 10079 } 10080 sv.UserVolumeEncryptionEnabled = ptr.Bool(jtv) 10081 } 10082 10083 case "VolumeEncryptionKey": 10084 if value != nil { 10085 jtv, ok := value.(string) 10086 if !ok { 10087 return fmt.Errorf("expected VolumeEncryptionKey to be of type string, got %T instead", value) 10088 } 10089 sv.VolumeEncryptionKey = ptr.String(jtv) 10090 } 10091 10092 case "WorkspaceProperties": 10093 if err := awsAwsjson11_deserializeDocumentWorkspaceProperties(&sv.WorkspaceProperties, value); err != nil { 10094 return err 10095 } 10096 10097 default: 10098 _, _ = key, value 10099 10100 } 10101 } 10102 *v = sv 10103 return nil 10104} 10105 10106func awsAwsjson11_deserializeDocumentWorkspacesDefaultRoleNotFoundException(v **types.WorkspacesDefaultRoleNotFoundException, value interface{}) error { 10107 if v == nil { 10108 return fmt.Errorf("unexpected nil of type %T", v) 10109 } 10110 if value == nil { 10111 return nil 10112 } 10113 10114 shape, ok := value.(map[string]interface{}) 10115 if !ok { 10116 return fmt.Errorf("unexpected JSON type %v", value) 10117 } 10118 10119 var sv *types.WorkspacesDefaultRoleNotFoundException 10120 if *v == nil { 10121 sv = &types.WorkspacesDefaultRoleNotFoundException{} 10122 } else { 10123 sv = *v 10124 } 10125 10126 for key, value := range shape { 10127 switch key { 10128 case "message": 10129 if value != nil { 10130 jtv, ok := value.(string) 10131 if !ok { 10132 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10133 } 10134 sv.Message = ptr.String(jtv) 10135 } 10136 10137 default: 10138 _, _ = key, value 10139 10140 } 10141 } 10142 *v = sv 10143 return nil 10144} 10145 10146func awsAwsjson11_deserializeDocumentWorkspacesIpGroup(v **types.WorkspacesIpGroup, value interface{}) error { 10147 if v == nil { 10148 return fmt.Errorf("unexpected nil of type %T", v) 10149 } 10150 if value == nil { 10151 return nil 10152 } 10153 10154 shape, ok := value.(map[string]interface{}) 10155 if !ok { 10156 return fmt.Errorf("unexpected JSON type %v", value) 10157 } 10158 10159 var sv *types.WorkspacesIpGroup 10160 if *v == nil { 10161 sv = &types.WorkspacesIpGroup{} 10162 } else { 10163 sv = *v 10164 } 10165 10166 for key, value := range shape { 10167 switch key { 10168 case "groupDesc": 10169 if value != nil { 10170 jtv, ok := value.(string) 10171 if !ok { 10172 return fmt.Errorf("expected IpGroupDesc to be of type string, got %T instead", value) 10173 } 10174 sv.GroupDesc = ptr.String(jtv) 10175 } 10176 10177 case "groupId": 10178 if value != nil { 10179 jtv, ok := value.(string) 10180 if !ok { 10181 return fmt.Errorf("expected IpGroupId to be of type string, got %T instead", value) 10182 } 10183 sv.GroupId = ptr.String(jtv) 10184 } 10185 10186 case "groupName": 10187 if value != nil { 10188 jtv, ok := value.(string) 10189 if !ok { 10190 return fmt.Errorf("expected IpGroupName to be of type string, got %T instead", value) 10191 } 10192 sv.GroupName = ptr.String(jtv) 10193 } 10194 10195 case "userRules": 10196 if err := awsAwsjson11_deserializeDocumentIpRuleList(&sv.UserRules, value); err != nil { 10197 return err 10198 } 10199 10200 default: 10201 _, _ = key, value 10202 10203 } 10204 } 10205 *v = sv 10206 return nil 10207} 10208 10209func awsAwsjson11_deserializeDocumentWorkspacesIpGroupsList(v *[]types.WorkspacesIpGroup, value interface{}) error { 10210 if v == nil { 10211 return fmt.Errorf("unexpected nil of type %T", v) 10212 } 10213 if value == nil { 10214 return nil 10215 } 10216 10217 shape, ok := value.([]interface{}) 10218 if !ok { 10219 return fmt.Errorf("unexpected JSON type %v", value) 10220 } 10221 10222 var cv []types.WorkspacesIpGroup 10223 if *v == nil { 10224 cv = []types.WorkspacesIpGroup{} 10225 } else { 10226 cv = *v 10227 } 10228 10229 for _, value := range shape { 10230 var col types.WorkspacesIpGroup 10231 destAddr := &col 10232 if err := awsAwsjson11_deserializeDocumentWorkspacesIpGroup(&destAddr, value); err != nil { 10233 return err 10234 } 10235 col = *destAddr 10236 cv = append(cv, col) 10237 10238 } 10239 *v = cv 10240 return nil 10241} 10242 10243func awsAwsjson11_deserializeOpDocumentAssociateConnectionAliasOutput(v **AssociateConnectionAliasOutput, value interface{}) error { 10244 if v == nil { 10245 return fmt.Errorf("unexpected nil of type %T", v) 10246 } 10247 if value == nil { 10248 return nil 10249 } 10250 10251 shape, ok := value.(map[string]interface{}) 10252 if !ok { 10253 return fmt.Errorf("unexpected JSON type %v", value) 10254 } 10255 10256 var sv *AssociateConnectionAliasOutput 10257 if *v == nil { 10258 sv = &AssociateConnectionAliasOutput{} 10259 } else { 10260 sv = *v 10261 } 10262 10263 for key, value := range shape { 10264 switch key { 10265 case "ConnectionIdentifier": 10266 if value != nil { 10267 jtv, ok := value.(string) 10268 if !ok { 10269 return fmt.Errorf("expected ConnectionIdentifier to be of type string, got %T instead", value) 10270 } 10271 sv.ConnectionIdentifier = ptr.String(jtv) 10272 } 10273 10274 default: 10275 _, _ = key, value 10276 10277 } 10278 } 10279 *v = sv 10280 return nil 10281} 10282 10283func awsAwsjson11_deserializeOpDocumentAssociateIpGroupsOutput(v **AssociateIpGroupsOutput, value interface{}) error { 10284 if v == nil { 10285 return fmt.Errorf("unexpected nil of type %T", v) 10286 } 10287 if value == nil { 10288 return nil 10289 } 10290 10291 shape, ok := value.(map[string]interface{}) 10292 if !ok { 10293 return fmt.Errorf("unexpected JSON type %v", value) 10294 } 10295 10296 var sv *AssociateIpGroupsOutput 10297 if *v == nil { 10298 sv = &AssociateIpGroupsOutput{} 10299 } else { 10300 sv = *v 10301 } 10302 10303 for key, value := range shape { 10304 switch key { 10305 default: 10306 _, _ = key, value 10307 10308 } 10309 } 10310 *v = sv 10311 return nil 10312} 10313 10314func awsAwsjson11_deserializeOpDocumentAuthorizeIpRulesOutput(v **AuthorizeIpRulesOutput, value interface{}) error { 10315 if v == nil { 10316 return fmt.Errorf("unexpected nil of type %T", v) 10317 } 10318 if value == nil { 10319 return nil 10320 } 10321 10322 shape, ok := value.(map[string]interface{}) 10323 if !ok { 10324 return fmt.Errorf("unexpected JSON type %v", value) 10325 } 10326 10327 var sv *AuthorizeIpRulesOutput 10328 if *v == nil { 10329 sv = &AuthorizeIpRulesOutput{} 10330 } else { 10331 sv = *v 10332 } 10333 10334 for key, value := range shape { 10335 switch key { 10336 default: 10337 _, _ = key, value 10338 10339 } 10340 } 10341 *v = sv 10342 return nil 10343} 10344 10345func awsAwsjson11_deserializeOpDocumentCopyWorkspaceImageOutput(v **CopyWorkspaceImageOutput, value interface{}) error { 10346 if v == nil { 10347 return fmt.Errorf("unexpected nil of type %T", v) 10348 } 10349 if value == nil { 10350 return nil 10351 } 10352 10353 shape, ok := value.(map[string]interface{}) 10354 if !ok { 10355 return fmt.Errorf("unexpected JSON type %v", value) 10356 } 10357 10358 var sv *CopyWorkspaceImageOutput 10359 if *v == nil { 10360 sv = &CopyWorkspaceImageOutput{} 10361 } else { 10362 sv = *v 10363 } 10364 10365 for key, value := range shape { 10366 switch key { 10367 case "ImageId": 10368 if value != nil { 10369 jtv, ok := value.(string) 10370 if !ok { 10371 return fmt.Errorf("expected WorkspaceImageId to be of type string, got %T instead", value) 10372 } 10373 sv.ImageId = ptr.String(jtv) 10374 } 10375 10376 default: 10377 _, _ = key, value 10378 10379 } 10380 } 10381 *v = sv 10382 return nil 10383} 10384 10385func awsAwsjson11_deserializeOpDocumentCreateConnectionAliasOutput(v **CreateConnectionAliasOutput, value interface{}) error { 10386 if v == nil { 10387 return fmt.Errorf("unexpected nil of type %T", v) 10388 } 10389 if value == nil { 10390 return nil 10391 } 10392 10393 shape, ok := value.(map[string]interface{}) 10394 if !ok { 10395 return fmt.Errorf("unexpected JSON type %v", value) 10396 } 10397 10398 var sv *CreateConnectionAliasOutput 10399 if *v == nil { 10400 sv = &CreateConnectionAliasOutput{} 10401 } else { 10402 sv = *v 10403 } 10404 10405 for key, value := range shape { 10406 switch key { 10407 case "AliasId": 10408 if value != nil { 10409 jtv, ok := value.(string) 10410 if !ok { 10411 return fmt.Errorf("expected ConnectionAliasId to be of type string, got %T instead", value) 10412 } 10413 sv.AliasId = ptr.String(jtv) 10414 } 10415 10416 default: 10417 _, _ = key, value 10418 10419 } 10420 } 10421 *v = sv 10422 return nil 10423} 10424 10425func awsAwsjson11_deserializeOpDocumentCreateIpGroupOutput(v **CreateIpGroupOutput, value interface{}) error { 10426 if v == nil { 10427 return fmt.Errorf("unexpected nil of type %T", v) 10428 } 10429 if value == nil { 10430 return nil 10431 } 10432 10433 shape, ok := value.(map[string]interface{}) 10434 if !ok { 10435 return fmt.Errorf("unexpected JSON type %v", value) 10436 } 10437 10438 var sv *CreateIpGroupOutput 10439 if *v == nil { 10440 sv = &CreateIpGroupOutput{} 10441 } else { 10442 sv = *v 10443 } 10444 10445 for key, value := range shape { 10446 switch key { 10447 case "GroupId": 10448 if value != nil { 10449 jtv, ok := value.(string) 10450 if !ok { 10451 return fmt.Errorf("expected IpGroupId to be of type string, got %T instead", value) 10452 } 10453 sv.GroupId = ptr.String(jtv) 10454 } 10455 10456 default: 10457 _, _ = key, value 10458 10459 } 10460 } 10461 *v = sv 10462 return nil 10463} 10464 10465func awsAwsjson11_deserializeOpDocumentCreateTagsOutput(v **CreateTagsOutput, value interface{}) error { 10466 if v == nil { 10467 return fmt.Errorf("unexpected nil of type %T", v) 10468 } 10469 if value == nil { 10470 return nil 10471 } 10472 10473 shape, ok := value.(map[string]interface{}) 10474 if !ok { 10475 return fmt.Errorf("unexpected JSON type %v", value) 10476 } 10477 10478 var sv *CreateTagsOutput 10479 if *v == nil { 10480 sv = &CreateTagsOutput{} 10481 } else { 10482 sv = *v 10483 } 10484 10485 for key, value := range shape { 10486 switch key { 10487 default: 10488 _, _ = key, value 10489 10490 } 10491 } 10492 *v = sv 10493 return nil 10494} 10495 10496func awsAwsjson11_deserializeOpDocumentCreateWorkspaceBundleOutput(v **CreateWorkspaceBundleOutput, value interface{}) error { 10497 if v == nil { 10498 return fmt.Errorf("unexpected nil of type %T", v) 10499 } 10500 if value == nil { 10501 return nil 10502 } 10503 10504 shape, ok := value.(map[string]interface{}) 10505 if !ok { 10506 return fmt.Errorf("unexpected JSON type %v", value) 10507 } 10508 10509 var sv *CreateWorkspaceBundleOutput 10510 if *v == nil { 10511 sv = &CreateWorkspaceBundleOutput{} 10512 } else { 10513 sv = *v 10514 } 10515 10516 for key, value := range shape { 10517 switch key { 10518 case "WorkspaceBundle": 10519 if err := awsAwsjson11_deserializeDocumentWorkspaceBundle(&sv.WorkspaceBundle, value); err != nil { 10520 return err 10521 } 10522 10523 default: 10524 _, _ = key, value 10525 10526 } 10527 } 10528 *v = sv 10529 return nil 10530} 10531 10532func awsAwsjson11_deserializeOpDocumentCreateWorkspacesOutput(v **CreateWorkspacesOutput, value interface{}) error { 10533 if v == nil { 10534 return fmt.Errorf("unexpected nil of type %T", v) 10535 } 10536 if value == nil { 10537 return nil 10538 } 10539 10540 shape, ok := value.(map[string]interface{}) 10541 if !ok { 10542 return fmt.Errorf("unexpected JSON type %v", value) 10543 } 10544 10545 var sv *CreateWorkspacesOutput 10546 if *v == nil { 10547 sv = &CreateWorkspacesOutput{} 10548 } else { 10549 sv = *v 10550 } 10551 10552 for key, value := range shape { 10553 switch key { 10554 case "FailedRequests": 10555 if err := awsAwsjson11_deserializeDocumentFailedCreateWorkspaceRequests(&sv.FailedRequests, value); err != nil { 10556 return err 10557 } 10558 10559 case "PendingRequests": 10560 if err := awsAwsjson11_deserializeDocumentWorkspaceList(&sv.PendingRequests, value); err != nil { 10561 return err 10562 } 10563 10564 default: 10565 _, _ = key, value 10566 10567 } 10568 } 10569 *v = sv 10570 return nil 10571} 10572 10573func awsAwsjson11_deserializeOpDocumentDeleteConnectionAliasOutput(v **DeleteConnectionAliasOutput, value interface{}) error { 10574 if v == nil { 10575 return fmt.Errorf("unexpected nil of type %T", v) 10576 } 10577 if value == nil { 10578 return nil 10579 } 10580 10581 shape, ok := value.(map[string]interface{}) 10582 if !ok { 10583 return fmt.Errorf("unexpected JSON type %v", value) 10584 } 10585 10586 var sv *DeleteConnectionAliasOutput 10587 if *v == nil { 10588 sv = &DeleteConnectionAliasOutput{} 10589 } else { 10590 sv = *v 10591 } 10592 10593 for key, value := range shape { 10594 switch key { 10595 default: 10596 _, _ = key, value 10597 10598 } 10599 } 10600 *v = sv 10601 return nil 10602} 10603 10604func awsAwsjson11_deserializeOpDocumentDeleteIpGroupOutput(v **DeleteIpGroupOutput, value interface{}) error { 10605 if v == nil { 10606 return fmt.Errorf("unexpected nil of type %T", v) 10607 } 10608 if value == nil { 10609 return nil 10610 } 10611 10612 shape, ok := value.(map[string]interface{}) 10613 if !ok { 10614 return fmt.Errorf("unexpected JSON type %v", value) 10615 } 10616 10617 var sv *DeleteIpGroupOutput 10618 if *v == nil { 10619 sv = &DeleteIpGroupOutput{} 10620 } else { 10621 sv = *v 10622 } 10623 10624 for key, value := range shape { 10625 switch key { 10626 default: 10627 _, _ = key, value 10628 10629 } 10630 } 10631 *v = sv 10632 return nil 10633} 10634 10635func awsAwsjson11_deserializeOpDocumentDeleteTagsOutput(v **DeleteTagsOutput, value interface{}) error { 10636 if v == nil { 10637 return fmt.Errorf("unexpected nil of type %T", v) 10638 } 10639 if value == nil { 10640 return nil 10641 } 10642 10643 shape, ok := value.(map[string]interface{}) 10644 if !ok { 10645 return fmt.Errorf("unexpected JSON type %v", value) 10646 } 10647 10648 var sv *DeleteTagsOutput 10649 if *v == nil { 10650 sv = &DeleteTagsOutput{} 10651 } else { 10652 sv = *v 10653 } 10654 10655 for key, value := range shape { 10656 switch key { 10657 default: 10658 _, _ = key, value 10659 10660 } 10661 } 10662 *v = sv 10663 return nil 10664} 10665 10666func awsAwsjson11_deserializeOpDocumentDeleteWorkspaceBundleOutput(v **DeleteWorkspaceBundleOutput, value interface{}) error { 10667 if v == nil { 10668 return fmt.Errorf("unexpected nil of type %T", v) 10669 } 10670 if value == nil { 10671 return nil 10672 } 10673 10674 shape, ok := value.(map[string]interface{}) 10675 if !ok { 10676 return fmt.Errorf("unexpected JSON type %v", value) 10677 } 10678 10679 var sv *DeleteWorkspaceBundleOutput 10680 if *v == nil { 10681 sv = &DeleteWorkspaceBundleOutput{} 10682 } else { 10683 sv = *v 10684 } 10685 10686 for key, value := range shape { 10687 switch key { 10688 default: 10689 _, _ = key, value 10690 10691 } 10692 } 10693 *v = sv 10694 return nil 10695} 10696 10697func awsAwsjson11_deserializeOpDocumentDeleteWorkspaceImageOutput(v **DeleteWorkspaceImageOutput, value interface{}) error { 10698 if v == nil { 10699 return fmt.Errorf("unexpected nil of type %T", v) 10700 } 10701 if value == nil { 10702 return nil 10703 } 10704 10705 shape, ok := value.(map[string]interface{}) 10706 if !ok { 10707 return fmt.Errorf("unexpected JSON type %v", value) 10708 } 10709 10710 var sv *DeleteWorkspaceImageOutput 10711 if *v == nil { 10712 sv = &DeleteWorkspaceImageOutput{} 10713 } else { 10714 sv = *v 10715 } 10716 10717 for key, value := range shape { 10718 switch key { 10719 default: 10720 _, _ = key, value 10721 10722 } 10723 } 10724 *v = sv 10725 return nil 10726} 10727 10728func awsAwsjson11_deserializeOpDocumentDeregisterWorkspaceDirectoryOutput(v **DeregisterWorkspaceDirectoryOutput, value interface{}) error { 10729 if v == nil { 10730 return fmt.Errorf("unexpected nil of type %T", v) 10731 } 10732 if value == nil { 10733 return nil 10734 } 10735 10736 shape, ok := value.(map[string]interface{}) 10737 if !ok { 10738 return fmt.Errorf("unexpected JSON type %v", value) 10739 } 10740 10741 var sv *DeregisterWorkspaceDirectoryOutput 10742 if *v == nil { 10743 sv = &DeregisterWorkspaceDirectoryOutput{} 10744 } else { 10745 sv = *v 10746 } 10747 10748 for key, value := range shape { 10749 switch key { 10750 default: 10751 _, _ = key, value 10752 10753 } 10754 } 10755 *v = sv 10756 return nil 10757} 10758 10759func awsAwsjson11_deserializeOpDocumentDescribeAccountModificationsOutput(v **DescribeAccountModificationsOutput, value interface{}) error { 10760 if v == nil { 10761 return fmt.Errorf("unexpected nil of type %T", v) 10762 } 10763 if value == nil { 10764 return nil 10765 } 10766 10767 shape, ok := value.(map[string]interface{}) 10768 if !ok { 10769 return fmt.Errorf("unexpected JSON type %v", value) 10770 } 10771 10772 var sv *DescribeAccountModificationsOutput 10773 if *v == nil { 10774 sv = &DescribeAccountModificationsOutput{} 10775 } else { 10776 sv = *v 10777 } 10778 10779 for key, value := range shape { 10780 switch key { 10781 case "AccountModifications": 10782 if err := awsAwsjson11_deserializeDocumentAccountModificationList(&sv.AccountModifications, value); err != nil { 10783 return err 10784 } 10785 10786 case "NextToken": 10787 if value != nil { 10788 jtv, ok := value.(string) 10789 if !ok { 10790 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 10791 } 10792 sv.NextToken = ptr.String(jtv) 10793 } 10794 10795 default: 10796 _, _ = key, value 10797 10798 } 10799 } 10800 *v = sv 10801 return nil 10802} 10803 10804func awsAwsjson11_deserializeOpDocumentDescribeAccountOutput(v **DescribeAccountOutput, value interface{}) error { 10805 if v == nil { 10806 return fmt.Errorf("unexpected nil of type %T", v) 10807 } 10808 if value == nil { 10809 return nil 10810 } 10811 10812 shape, ok := value.(map[string]interface{}) 10813 if !ok { 10814 return fmt.Errorf("unexpected JSON type %v", value) 10815 } 10816 10817 var sv *DescribeAccountOutput 10818 if *v == nil { 10819 sv = &DescribeAccountOutput{} 10820 } else { 10821 sv = *v 10822 } 10823 10824 for key, value := range shape { 10825 switch key { 10826 case "DedicatedTenancyManagementCidrRange": 10827 if value != nil { 10828 jtv, ok := value.(string) 10829 if !ok { 10830 return fmt.Errorf("expected DedicatedTenancyManagementCidrRange to be of type string, got %T instead", value) 10831 } 10832 sv.DedicatedTenancyManagementCidrRange = ptr.String(jtv) 10833 } 10834 10835 case "DedicatedTenancySupport": 10836 if value != nil { 10837 jtv, ok := value.(string) 10838 if !ok { 10839 return fmt.Errorf("expected DedicatedTenancySupportResultEnum to be of type string, got %T instead", value) 10840 } 10841 sv.DedicatedTenancySupport = types.DedicatedTenancySupportResultEnum(jtv) 10842 } 10843 10844 default: 10845 _, _ = key, value 10846 10847 } 10848 } 10849 *v = sv 10850 return nil 10851} 10852 10853func awsAwsjson11_deserializeOpDocumentDescribeClientPropertiesOutput(v **DescribeClientPropertiesOutput, value interface{}) error { 10854 if v == nil { 10855 return fmt.Errorf("unexpected nil of type %T", v) 10856 } 10857 if value == nil { 10858 return nil 10859 } 10860 10861 shape, ok := value.(map[string]interface{}) 10862 if !ok { 10863 return fmt.Errorf("unexpected JSON type %v", value) 10864 } 10865 10866 var sv *DescribeClientPropertiesOutput 10867 if *v == nil { 10868 sv = &DescribeClientPropertiesOutput{} 10869 } else { 10870 sv = *v 10871 } 10872 10873 for key, value := range shape { 10874 switch key { 10875 case "ClientPropertiesList": 10876 if err := awsAwsjson11_deserializeDocumentClientPropertiesList(&sv.ClientPropertiesList, value); err != nil { 10877 return err 10878 } 10879 10880 default: 10881 _, _ = key, value 10882 10883 } 10884 } 10885 *v = sv 10886 return nil 10887} 10888 10889func awsAwsjson11_deserializeOpDocumentDescribeConnectionAliasesOutput(v **DescribeConnectionAliasesOutput, value interface{}) error { 10890 if v == nil { 10891 return fmt.Errorf("unexpected nil of type %T", v) 10892 } 10893 if value == nil { 10894 return nil 10895 } 10896 10897 shape, ok := value.(map[string]interface{}) 10898 if !ok { 10899 return fmt.Errorf("unexpected JSON type %v", value) 10900 } 10901 10902 var sv *DescribeConnectionAliasesOutput 10903 if *v == nil { 10904 sv = &DescribeConnectionAliasesOutput{} 10905 } else { 10906 sv = *v 10907 } 10908 10909 for key, value := range shape { 10910 switch key { 10911 case "ConnectionAliases": 10912 if err := awsAwsjson11_deserializeDocumentConnectionAliasList(&sv.ConnectionAliases, value); err != nil { 10913 return err 10914 } 10915 10916 case "NextToken": 10917 if value != nil { 10918 jtv, ok := value.(string) 10919 if !ok { 10920 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 10921 } 10922 sv.NextToken = ptr.String(jtv) 10923 } 10924 10925 default: 10926 _, _ = key, value 10927 10928 } 10929 } 10930 *v = sv 10931 return nil 10932} 10933 10934func awsAwsjson11_deserializeOpDocumentDescribeConnectionAliasPermissionsOutput(v **DescribeConnectionAliasPermissionsOutput, value interface{}) error { 10935 if v == nil { 10936 return fmt.Errorf("unexpected nil of type %T", v) 10937 } 10938 if value == nil { 10939 return nil 10940 } 10941 10942 shape, ok := value.(map[string]interface{}) 10943 if !ok { 10944 return fmt.Errorf("unexpected JSON type %v", value) 10945 } 10946 10947 var sv *DescribeConnectionAliasPermissionsOutput 10948 if *v == nil { 10949 sv = &DescribeConnectionAliasPermissionsOutput{} 10950 } else { 10951 sv = *v 10952 } 10953 10954 for key, value := range shape { 10955 switch key { 10956 case "AliasId": 10957 if value != nil { 10958 jtv, ok := value.(string) 10959 if !ok { 10960 return fmt.Errorf("expected ConnectionAliasId to be of type string, got %T instead", value) 10961 } 10962 sv.AliasId = ptr.String(jtv) 10963 } 10964 10965 case "ConnectionAliasPermissions": 10966 if err := awsAwsjson11_deserializeDocumentConnectionAliasPermissions(&sv.ConnectionAliasPermissions, value); err != nil { 10967 return err 10968 } 10969 10970 case "NextToken": 10971 if value != nil { 10972 jtv, ok := value.(string) 10973 if !ok { 10974 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 10975 } 10976 sv.NextToken = ptr.String(jtv) 10977 } 10978 10979 default: 10980 _, _ = key, value 10981 10982 } 10983 } 10984 *v = sv 10985 return nil 10986} 10987 10988func awsAwsjson11_deserializeOpDocumentDescribeIpGroupsOutput(v **DescribeIpGroupsOutput, value interface{}) error { 10989 if v == nil { 10990 return fmt.Errorf("unexpected nil of type %T", v) 10991 } 10992 if value == nil { 10993 return nil 10994 } 10995 10996 shape, ok := value.(map[string]interface{}) 10997 if !ok { 10998 return fmt.Errorf("unexpected JSON type %v", value) 10999 } 11000 11001 var sv *DescribeIpGroupsOutput 11002 if *v == nil { 11003 sv = &DescribeIpGroupsOutput{} 11004 } else { 11005 sv = *v 11006 } 11007 11008 for key, value := range shape { 11009 switch key { 11010 case "NextToken": 11011 if value != nil { 11012 jtv, ok := value.(string) 11013 if !ok { 11014 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11015 } 11016 sv.NextToken = ptr.String(jtv) 11017 } 11018 11019 case "Result": 11020 if err := awsAwsjson11_deserializeDocumentWorkspacesIpGroupsList(&sv.Result, value); err != nil { 11021 return err 11022 } 11023 11024 default: 11025 _, _ = key, value 11026 11027 } 11028 } 11029 *v = sv 11030 return nil 11031} 11032 11033func awsAwsjson11_deserializeOpDocumentDescribeTagsOutput(v **DescribeTagsOutput, value interface{}) error { 11034 if v == nil { 11035 return fmt.Errorf("unexpected nil of type %T", v) 11036 } 11037 if value == nil { 11038 return nil 11039 } 11040 11041 shape, ok := value.(map[string]interface{}) 11042 if !ok { 11043 return fmt.Errorf("unexpected JSON type %v", value) 11044 } 11045 11046 var sv *DescribeTagsOutput 11047 if *v == nil { 11048 sv = &DescribeTagsOutput{} 11049 } else { 11050 sv = *v 11051 } 11052 11053 for key, value := range shape { 11054 switch key { 11055 case "TagList": 11056 if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil { 11057 return err 11058 } 11059 11060 default: 11061 _, _ = key, value 11062 11063 } 11064 } 11065 *v = sv 11066 return nil 11067} 11068 11069func awsAwsjson11_deserializeOpDocumentDescribeWorkspaceBundlesOutput(v **DescribeWorkspaceBundlesOutput, value interface{}) error { 11070 if v == nil { 11071 return fmt.Errorf("unexpected nil of type %T", v) 11072 } 11073 if value == nil { 11074 return nil 11075 } 11076 11077 shape, ok := value.(map[string]interface{}) 11078 if !ok { 11079 return fmt.Errorf("unexpected JSON type %v", value) 11080 } 11081 11082 var sv *DescribeWorkspaceBundlesOutput 11083 if *v == nil { 11084 sv = &DescribeWorkspaceBundlesOutput{} 11085 } else { 11086 sv = *v 11087 } 11088 11089 for key, value := range shape { 11090 switch key { 11091 case "Bundles": 11092 if err := awsAwsjson11_deserializeDocumentBundleList(&sv.Bundles, value); err != nil { 11093 return err 11094 } 11095 11096 case "NextToken": 11097 if value != nil { 11098 jtv, ok := value.(string) 11099 if !ok { 11100 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11101 } 11102 sv.NextToken = ptr.String(jtv) 11103 } 11104 11105 default: 11106 _, _ = key, value 11107 11108 } 11109 } 11110 *v = sv 11111 return nil 11112} 11113 11114func awsAwsjson11_deserializeOpDocumentDescribeWorkspaceDirectoriesOutput(v **DescribeWorkspaceDirectoriesOutput, value interface{}) error { 11115 if v == nil { 11116 return fmt.Errorf("unexpected nil of type %T", v) 11117 } 11118 if value == nil { 11119 return nil 11120 } 11121 11122 shape, ok := value.(map[string]interface{}) 11123 if !ok { 11124 return fmt.Errorf("unexpected JSON type %v", value) 11125 } 11126 11127 var sv *DescribeWorkspaceDirectoriesOutput 11128 if *v == nil { 11129 sv = &DescribeWorkspaceDirectoriesOutput{} 11130 } else { 11131 sv = *v 11132 } 11133 11134 for key, value := range shape { 11135 switch key { 11136 case "Directories": 11137 if err := awsAwsjson11_deserializeDocumentDirectoryList(&sv.Directories, value); err != nil { 11138 return err 11139 } 11140 11141 case "NextToken": 11142 if value != nil { 11143 jtv, ok := value.(string) 11144 if !ok { 11145 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11146 } 11147 sv.NextToken = ptr.String(jtv) 11148 } 11149 11150 default: 11151 _, _ = key, value 11152 11153 } 11154 } 11155 *v = sv 11156 return nil 11157} 11158 11159func awsAwsjson11_deserializeOpDocumentDescribeWorkspaceImagePermissionsOutput(v **DescribeWorkspaceImagePermissionsOutput, value interface{}) error { 11160 if v == nil { 11161 return fmt.Errorf("unexpected nil of type %T", v) 11162 } 11163 if value == nil { 11164 return nil 11165 } 11166 11167 shape, ok := value.(map[string]interface{}) 11168 if !ok { 11169 return fmt.Errorf("unexpected JSON type %v", value) 11170 } 11171 11172 var sv *DescribeWorkspaceImagePermissionsOutput 11173 if *v == nil { 11174 sv = &DescribeWorkspaceImagePermissionsOutput{} 11175 } else { 11176 sv = *v 11177 } 11178 11179 for key, value := range shape { 11180 switch key { 11181 case "ImageId": 11182 if value != nil { 11183 jtv, ok := value.(string) 11184 if !ok { 11185 return fmt.Errorf("expected WorkspaceImageId to be of type string, got %T instead", value) 11186 } 11187 sv.ImageId = ptr.String(jtv) 11188 } 11189 11190 case "ImagePermissions": 11191 if err := awsAwsjson11_deserializeDocumentImagePermissions(&sv.ImagePermissions, value); err != nil { 11192 return err 11193 } 11194 11195 case "NextToken": 11196 if value != nil { 11197 jtv, ok := value.(string) 11198 if !ok { 11199 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11200 } 11201 sv.NextToken = ptr.String(jtv) 11202 } 11203 11204 default: 11205 _, _ = key, value 11206 11207 } 11208 } 11209 *v = sv 11210 return nil 11211} 11212 11213func awsAwsjson11_deserializeOpDocumentDescribeWorkspaceImagesOutput(v **DescribeWorkspaceImagesOutput, value interface{}) error { 11214 if v == nil { 11215 return fmt.Errorf("unexpected nil of type %T", v) 11216 } 11217 if value == nil { 11218 return nil 11219 } 11220 11221 shape, ok := value.(map[string]interface{}) 11222 if !ok { 11223 return fmt.Errorf("unexpected JSON type %v", value) 11224 } 11225 11226 var sv *DescribeWorkspaceImagesOutput 11227 if *v == nil { 11228 sv = &DescribeWorkspaceImagesOutput{} 11229 } else { 11230 sv = *v 11231 } 11232 11233 for key, value := range shape { 11234 switch key { 11235 case "Images": 11236 if err := awsAwsjson11_deserializeDocumentWorkspaceImageList(&sv.Images, value); err != nil { 11237 return err 11238 } 11239 11240 case "NextToken": 11241 if value != nil { 11242 jtv, ok := value.(string) 11243 if !ok { 11244 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11245 } 11246 sv.NextToken = ptr.String(jtv) 11247 } 11248 11249 default: 11250 _, _ = key, value 11251 11252 } 11253 } 11254 *v = sv 11255 return nil 11256} 11257 11258func awsAwsjson11_deserializeOpDocumentDescribeWorkspacesConnectionStatusOutput(v **DescribeWorkspacesConnectionStatusOutput, value interface{}) error { 11259 if v == nil { 11260 return fmt.Errorf("unexpected nil of type %T", v) 11261 } 11262 if value == nil { 11263 return nil 11264 } 11265 11266 shape, ok := value.(map[string]interface{}) 11267 if !ok { 11268 return fmt.Errorf("unexpected JSON type %v", value) 11269 } 11270 11271 var sv *DescribeWorkspacesConnectionStatusOutput 11272 if *v == nil { 11273 sv = &DescribeWorkspacesConnectionStatusOutput{} 11274 } else { 11275 sv = *v 11276 } 11277 11278 for key, value := range shape { 11279 switch key { 11280 case "NextToken": 11281 if value != nil { 11282 jtv, ok := value.(string) 11283 if !ok { 11284 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11285 } 11286 sv.NextToken = ptr.String(jtv) 11287 } 11288 11289 case "WorkspacesConnectionStatus": 11290 if err := awsAwsjson11_deserializeDocumentWorkspaceConnectionStatusList(&sv.WorkspacesConnectionStatus, value); err != nil { 11291 return err 11292 } 11293 11294 default: 11295 _, _ = key, value 11296 11297 } 11298 } 11299 *v = sv 11300 return nil 11301} 11302 11303func awsAwsjson11_deserializeOpDocumentDescribeWorkspaceSnapshotsOutput(v **DescribeWorkspaceSnapshotsOutput, value interface{}) error { 11304 if v == nil { 11305 return fmt.Errorf("unexpected nil of type %T", v) 11306 } 11307 if value == nil { 11308 return nil 11309 } 11310 11311 shape, ok := value.(map[string]interface{}) 11312 if !ok { 11313 return fmt.Errorf("unexpected JSON type %v", value) 11314 } 11315 11316 var sv *DescribeWorkspaceSnapshotsOutput 11317 if *v == nil { 11318 sv = &DescribeWorkspaceSnapshotsOutput{} 11319 } else { 11320 sv = *v 11321 } 11322 11323 for key, value := range shape { 11324 switch key { 11325 case "RebuildSnapshots": 11326 if err := awsAwsjson11_deserializeDocumentSnapshotList(&sv.RebuildSnapshots, value); err != nil { 11327 return err 11328 } 11329 11330 case "RestoreSnapshots": 11331 if err := awsAwsjson11_deserializeDocumentSnapshotList(&sv.RestoreSnapshots, value); err != nil { 11332 return err 11333 } 11334 11335 default: 11336 _, _ = key, value 11337 11338 } 11339 } 11340 *v = sv 11341 return nil 11342} 11343 11344func awsAwsjson11_deserializeOpDocumentDescribeWorkspacesOutput(v **DescribeWorkspacesOutput, value interface{}) error { 11345 if v == nil { 11346 return fmt.Errorf("unexpected nil of type %T", v) 11347 } 11348 if value == nil { 11349 return nil 11350 } 11351 11352 shape, ok := value.(map[string]interface{}) 11353 if !ok { 11354 return fmt.Errorf("unexpected JSON type %v", value) 11355 } 11356 11357 var sv *DescribeWorkspacesOutput 11358 if *v == nil { 11359 sv = &DescribeWorkspacesOutput{} 11360 } else { 11361 sv = *v 11362 } 11363 11364 for key, value := range shape { 11365 switch key { 11366 case "NextToken": 11367 if value != nil { 11368 jtv, ok := value.(string) 11369 if !ok { 11370 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11371 } 11372 sv.NextToken = ptr.String(jtv) 11373 } 11374 11375 case "Workspaces": 11376 if err := awsAwsjson11_deserializeDocumentWorkspaceList(&sv.Workspaces, value); err != nil { 11377 return err 11378 } 11379 11380 default: 11381 _, _ = key, value 11382 11383 } 11384 } 11385 *v = sv 11386 return nil 11387} 11388 11389func awsAwsjson11_deserializeOpDocumentDisassociateConnectionAliasOutput(v **DisassociateConnectionAliasOutput, value interface{}) error { 11390 if v == nil { 11391 return fmt.Errorf("unexpected nil of type %T", v) 11392 } 11393 if value == nil { 11394 return nil 11395 } 11396 11397 shape, ok := value.(map[string]interface{}) 11398 if !ok { 11399 return fmt.Errorf("unexpected JSON type %v", value) 11400 } 11401 11402 var sv *DisassociateConnectionAliasOutput 11403 if *v == nil { 11404 sv = &DisassociateConnectionAliasOutput{} 11405 } else { 11406 sv = *v 11407 } 11408 11409 for key, value := range shape { 11410 switch key { 11411 default: 11412 _, _ = key, value 11413 11414 } 11415 } 11416 *v = sv 11417 return nil 11418} 11419 11420func awsAwsjson11_deserializeOpDocumentDisassociateIpGroupsOutput(v **DisassociateIpGroupsOutput, value interface{}) error { 11421 if v == nil { 11422 return fmt.Errorf("unexpected nil of type %T", v) 11423 } 11424 if value == nil { 11425 return nil 11426 } 11427 11428 shape, ok := value.(map[string]interface{}) 11429 if !ok { 11430 return fmt.Errorf("unexpected JSON type %v", value) 11431 } 11432 11433 var sv *DisassociateIpGroupsOutput 11434 if *v == nil { 11435 sv = &DisassociateIpGroupsOutput{} 11436 } else { 11437 sv = *v 11438 } 11439 11440 for key, value := range shape { 11441 switch key { 11442 default: 11443 _, _ = key, value 11444 11445 } 11446 } 11447 *v = sv 11448 return nil 11449} 11450 11451func awsAwsjson11_deserializeOpDocumentImportWorkspaceImageOutput(v **ImportWorkspaceImageOutput, value interface{}) error { 11452 if v == nil { 11453 return fmt.Errorf("unexpected nil of type %T", v) 11454 } 11455 if value == nil { 11456 return nil 11457 } 11458 11459 shape, ok := value.(map[string]interface{}) 11460 if !ok { 11461 return fmt.Errorf("unexpected JSON type %v", value) 11462 } 11463 11464 var sv *ImportWorkspaceImageOutput 11465 if *v == nil { 11466 sv = &ImportWorkspaceImageOutput{} 11467 } else { 11468 sv = *v 11469 } 11470 11471 for key, value := range shape { 11472 switch key { 11473 case "ImageId": 11474 if value != nil { 11475 jtv, ok := value.(string) 11476 if !ok { 11477 return fmt.Errorf("expected WorkspaceImageId to be of type string, got %T instead", value) 11478 } 11479 sv.ImageId = ptr.String(jtv) 11480 } 11481 11482 default: 11483 _, _ = key, value 11484 11485 } 11486 } 11487 *v = sv 11488 return nil 11489} 11490 11491func awsAwsjson11_deserializeOpDocumentListAvailableManagementCidrRangesOutput(v **ListAvailableManagementCidrRangesOutput, value interface{}) error { 11492 if v == nil { 11493 return fmt.Errorf("unexpected nil of type %T", v) 11494 } 11495 if value == nil { 11496 return nil 11497 } 11498 11499 shape, ok := value.(map[string]interface{}) 11500 if !ok { 11501 return fmt.Errorf("unexpected JSON type %v", value) 11502 } 11503 11504 var sv *ListAvailableManagementCidrRangesOutput 11505 if *v == nil { 11506 sv = &ListAvailableManagementCidrRangesOutput{} 11507 } else { 11508 sv = *v 11509 } 11510 11511 for key, value := range shape { 11512 switch key { 11513 case "ManagementCidrRanges": 11514 if err := awsAwsjson11_deserializeDocumentDedicatedTenancyCidrRangeList(&sv.ManagementCidrRanges, value); err != nil { 11515 return err 11516 } 11517 11518 case "NextToken": 11519 if value != nil { 11520 jtv, ok := value.(string) 11521 if !ok { 11522 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 11523 } 11524 sv.NextToken = ptr.String(jtv) 11525 } 11526 11527 default: 11528 _, _ = key, value 11529 11530 } 11531 } 11532 *v = sv 11533 return nil 11534} 11535 11536func awsAwsjson11_deserializeOpDocumentMigrateWorkspaceOutput(v **MigrateWorkspaceOutput, value interface{}) error { 11537 if v == nil { 11538 return fmt.Errorf("unexpected nil of type %T", v) 11539 } 11540 if value == nil { 11541 return nil 11542 } 11543 11544 shape, ok := value.(map[string]interface{}) 11545 if !ok { 11546 return fmt.Errorf("unexpected JSON type %v", value) 11547 } 11548 11549 var sv *MigrateWorkspaceOutput 11550 if *v == nil { 11551 sv = &MigrateWorkspaceOutput{} 11552 } else { 11553 sv = *v 11554 } 11555 11556 for key, value := range shape { 11557 switch key { 11558 case "SourceWorkspaceId": 11559 if value != nil { 11560 jtv, ok := value.(string) 11561 if !ok { 11562 return fmt.Errorf("expected WorkspaceId to be of type string, got %T instead", value) 11563 } 11564 sv.SourceWorkspaceId = ptr.String(jtv) 11565 } 11566 11567 case "TargetWorkspaceId": 11568 if value != nil { 11569 jtv, ok := value.(string) 11570 if !ok { 11571 return fmt.Errorf("expected WorkspaceId to be of type string, got %T instead", value) 11572 } 11573 sv.TargetWorkspaceId = ptr.String(jtv) 11574 } 11575 11576 default: 11577 _, _ = key, value 11578 11579 } 11580 } 11581 *v = sv 11582 return nil 11583} 11584 11585func awsAwsjson11_deserializeOpDocumentModifyAccountOutput(v **ModifyAccountOutput, value interface{}) error { 11586 if v == nil { 11587 return fmt.Errorf("unexpected nil of type %T", v) 11588 } 11589 if value == nil { 11590 return nil 11591 } 11592 11593 shape, ok := value.(map[string]interface{}) 11594 if !ok { 11595 return fmt.Errorf("unexpected JSON type %v", value) 11596 } 11597 11598 var sv *ModifyAccountOutput 11599 if *v == nil { 11600 sv = &ModifyAccountOutput{} 11601 } else { 11602 sv = *v 11603 } 11604 11605 for key, value := range shape { 11606 switch key { 11607 default: 11608 _, _ = key, value 11609 11610 } 11611 } 11612 *v = sv 11613 return nil 11614} 11615 11616func awsAwsjson11_deserializeOpDocumentModifyClientPropertiesOutput(v **ModifyClientPropertiesOutput, value interface{}) error { 11617 if v == nil { 11618 return fmt.Errorf("unexpected nil of type %T", v) 11619 } 11620 if value == nil { 11621 return nil 11622 } 11623 11624 shape, ok := value.(map[string]interface{}) 11625 if !ok { 11626 return fmt.Errorf("unexpected JSON type %v", value) 11627 } 11628 11629 var sv *ModifyClientPropertiesOutput 11630 if *v == nil { 11631 sv = &ModifyClientPropertiesOutput{} 11632 } else { 11633 sv = *v 11634 } 11635 11636 for key, value := range shape { 11637 switch key { 11638 default: 11639 _, _ = key, value 11640 11641 } 11642 } 11643 *v = sv 11644 return nil 11645} 11646 11647func awsAwsjson11_deserializeOpDocumentModifySelfservicePermissionsOutput(v **ModifySelfservicePermissionsOutput, value interface{}) error { 11648 if v == nil { 11649 return fmt.Errorf("unexpected nil of type %T", v) 11650 } 11651 if value == nil { 11652 return nil 11653 } 11654 11655 shape, ok := value.(map[string]interface{}) 11656 if !ok { 11657 return fmt.Errorf("unexpected JSON type %v", value) 11658 } 11659 11660 var sv *ModifySelfservicePermissionsOutput 11661 if *v == nil { 11662 sv = &ModifySelfservicePermissionsOutput{} 11663 } else { 11664 sv = *v 11665 } 11666 11667 for key, value := range shape { 11668 switch key { 11669 default: 11670 _, _ = key, value 11671 11672 } 11673 } 11674 *v = sv 11675 return nil 11676} 11677 11678func awsAwsjson11_deserializeOpDocumentModifyWorkspaceAccessPropertiesOutput(v **ModifyWorkspaceAccessPropertiesOutput, value interface{}) error { 11679 if v == nil { 11680 return fmt.Errorf("unexpected nil of type %T", v) 11681 } 11682 if value == nil { 11683 return nil 11684 } 11685 11686 shape, ok := value.(map[string]interface{}) 11687 if !ok { 11688 return fmt.Errorf("unexpected JSON type %v", value) 11689 } 11690 11691 var sv *ModifyWorkspaceAccessPropertiesOutput 11692 if *v == nil { 11693 sv = &ModifyWorkspaceAccessPropertiesOutput{} 11694 } else { 11695 sv = *v 11696 } 11697 11698 for key, value := range shape { 11699 switch key { 11700 default: 11701 _, _ = key, value 11702 11703 } 11704 } 11705 *v = sv 11706 return nil 11707} 11708 11709func awsAwsjson11_deserializeOpDocumentModifyWorkspaceCreationPropertiesOutput(v **ModifyWorkspaceCreationPropertiesOutput, value interface{}) error { 11710 if v == nil { 11711 return fmt.Errorf("unexpected nil of type %T", v) 11712 } 11713 if value == nil { 11714 return nil 11715 } 11716 11717 shape, ok := value.(map[string]interface{}) 11718 if !ok { 11719 return fmt.Errorf("unexpected JSON type %v", value) 11720 } 11721 11722 var sv *ModifyWorkspaceCreationPropertiesOutput 11723 if *v == nil { 11724 sv = &ModifyWorkspaceCreationPropertiesOutput{} 11725 } else { 11726 sv = *v 11727 } 11728 11729 for key, value := range shape { 11730 switch key { 11731 default: 11732 _, _ = key, value 11733 11734 } 11735 } 11736 *v = sv 11737 return nil 11738} 11739 11740func awsAwsjson11_deserializeOpDocumentModifyWorkspacePropertiesOutput(v **ModifyWorkspacePropertiesOutput, value interface{}) error { 11741 if v == nil { 11742 return fmt.Errorf("unexpected nil of type %T", v) 11743 } 11744 if value == nil { 11745 return nil 11746 } 11747 11748 shape, ok := value.(map[string]interface{}) 11749 if !ok { 11750 return fmt.Errorf("unexpected JSON type %v", value) 11751 } 11752 11753 var sv *ModifyWorkspacePropertiesOutput 11754 if *v == nil { 11755 sv = &ModifyWorkspacePropertiesOutput{} 11756 } else { 11757 sv = *v 11758 } 11759 11760 for key, value := range shape { 11761 switch key { 11762 default: 11763 _, _ = key, value 11764 11765 } 11766 } 11767 *v = sv 11768 return nil 11769} 11770 11771func awsAwsjson11_deserializeOpDocumentModifyWorkspaceStateOutput(v **ModifyWorkspaceStateOutput, value interface{}) error { 11772 if v == nil { 11773 return fmt.Errorf("unexpected nil of type %T", v) 11774 } 11775 if value == nil { 11776 return nil 11777 } 11778 11779 shape, ok := value.(map[string]interface{}) 11780 if !ok { 11781 return fmt.Errorf("unexpected JSON type %v", value) 11782 } 11783 11784 var sv *ModifyWorkspaceStateOutput 11785 if *v == nil { 11786 sv = &ModifyWorkspaceStateOutput{} 11787 } else { 11788 sv = *v 11789 } 11790 11791 for key, value := range shape { 11792 switch key { 11793 default: 11794 _, _ = key, value 11795 11796 } 11797 } 11798 *v = sv 11799 return nil 11800} 11801 11802func awsAwsjson11_deserializeOpDocumentRebootWorkspacesOutput(v **RebootWorkspacesOutput, value interface{}) error { 11803 if v == nil { 11804 return fmt.Errorf("unexpected nil of type %T", v) 11805 } 11806 if value == nil { 11807 return nil 11808 } 11809 11810 shape, ok := value.(map[string]interface{}) 11811 if !ok { 11812 return fmt.Errorf("unexpected JSON type %v", value) 11813 } 11814 11815 var sv *RebootWorkspacesOutput 11816 if *v == nil { 11817 sv = &RebootWorkspacesOutput{} 11818 } else { 11819 sv = *v 11820 } 11821 11822 for key, value := range shape { 11823 switch key { 11824 case "FailedRequests": 11825 if err := awsAwsjson11_deserializeDocumentFailedRebootWorkspaceRequests(&sv.FailedRequests, value); err != nil { 11826 return err 11827 } 11828 11829 default: 11830 _, _ = key, value 11831 11832 } 11833 } 11834 *v = sv 11835 return nil 11836} 11837 11838func awsAwsjson11_deserializeOpDocumentRebuildWorkspacesOutput(v **RebuildWorkspacesOutput, value interface{}) error { 11839 if v == nil { 11840 return fmt.Errorf("unexpected nil of type %T", v) 11841 } 11842 if value == nil { 11843 return nil 11844 } 11845 11846 shape, ok := value.(map[string]interface{}) 11847 if !ok { 11848 return fmt.Errorf("unexpected JSON type %v", value) 11849 } 11850 11851 var sv *RebuildWorkspacesOutput 11852 if *v == nil { 11853 sv = &RebuildWorkspacesOutput{} 11854 } else { 11855 sv = *v 11856 } 11857 11858 for key, value := range shape { 11859 switch key { 11860 case "FailedRequests": 11861 if err := awsAwsjson11_deserializeDocumentFailedRebuildWorkspaceRequests(&sv.FailedRequests, value); err != nil { 11862 return err 11863 } 11864 11865 default: 11866 _, _ = key, value 11867 11868 } 11869 } 11870 *v = sv 11871 return nil 11872} 11873 11874func awsAwsjson11_deserializeOpDocumentRegisterWorkspaceDirectoryOutput(v **RegisterWorkspaceDirectoryOutput, value interface{}) error { 11875 if v == nil { 11876 return fmt.Errorf("unexpected nil of type %T", v) 11877 } 11878 if value == nil { 11879 return nil 11880 } 11881 11882 shape, ok := value.(map[string]interface{}) 11883 if !ok { 11884 return fmt.Errorf("unexpected JSON type %v", value) 11885 } 11886 11887 var sv *RegisterWorkspaceDirectoryOutput 11888 if *v == nil { 11889 sv = &RegisterWorkspaceDirectoryOutput{} 11890 } else { 11891 sv = *v 11892 } 11893 11894 for key, value := range shape { 11895 switch key { 11896 default: 11897 _, _ = key, value 11898 11899 } 11900 } 11901 *v = sv 11902 return nil 11903} 11904 11905func awsAwsjson11_deserializeOpDocumentRestoreWorkspaceOutput(v **RestoreWorkspaceOutput, value interface{}) error { 11906 if v == nil { 11907 return fmt.Errorf("unexpected nil of type %T", v) 11908 } 11909 if value == nil { 11910 return nil 11911 } 11912 11913 shape, ok := value.(map[string]interface{}) 11914 if !ok { 11915 return fmt.Errorf("unexpected JSON type %v", value) 11916 } 11917 11918 var sv *RestoreWorkspaceOutput 11919 if *v == nil { 11920 sv = &RestoreWorkspaceOutput{} 11921 } else { 11922 sv = *v 11923 } 11924 11925 for key, value := range shape { 11926 switch key { 11927 default: 11928 _, _ = key, value 11929 11930 } 11931 } 11932 *v = sv 11933 return nil 11934} 11935 11936func awsAwsjson11_deserializeOpDocumentRevokeIpRulesOutput(v **RevokeIpRulesOutput, value interface{}) error { 11937 if v == nil { 11938 return fmt.Errorf("unexpected nil of type %T", v) 11939 } 11940 if value == nil { 11941 return nil 11942 } 11943 11944 shape, ok := value.(map[string]interface{}) 11945 if !ok { 11946 return fmt.Errorf("unexpected JSON type %v", value) 11947 } 11948 11949 var sv *RevokeIpRulesOutput 11950 if *v == nil { 11951 sv = &RevokeIpRulesOutput{} 11952 } else { 11953 sv = *v 11954 } 11955 11956 for key, value := range shape { 11957 switch key { 11958 default: 11959 _, _ = key, value 11960 11961 } 11962 } 11963 *v = sv 11964 return nil 11965} 11966 11967func awsAwsjson11_deserializeOpDocumentStartWorkspacesOutput(v **StartWorkspacesOutput, value interface{}) error { 11968 if v == nil { 11969 return fmt.Errorf("unexpected nil of type %T", v) 11970 } 11971 if value == nil { 11972 return nil 11973 } 11974 11975 shape, ok := value.(map[string]interface{}) 11976 if !ok { 11977 return fmt.Errorf("unexpected JSON type %v", value) 11978 } 11979 11980 var sv *StartWorkspacesOutput 11981 if *v == nil { 11982 sv = &StartWorkspacesOutput{} 11983 } else { 11984 sv = *v 11985 } 11986 11987 for key, value := range shape { 11988 switch key { 11989 case "FailedRequests": 11990 if err := awsAwsjson11_deserializeDocumentFailedStartWorkspaceRequests(&sv.FailedRequests, value); err != nil { 11991 return err 11992 } 11993 11994 default: 11995 _, _ = key, value 11996 11997 } 11998 } 11999 *v = sv 12000 return nil 12001} 12002 12003func awsAwsjson11_deserializeOpDocumentStopWorkspacesOutput(v **StopWorkspacesOutput, value interface{}) error { 12004 if v == nil { 12005 return fmt.Errorf("unexpected nil of type %T", v) 12006 } 12007 if value == nil { 12008 return nil 12009 } 12010 12011 shape, ok := value.(map[string]interface{}) 12012 if !ok { 12013 return fmt.Errorf("unexpected JSON type %v", value) 12014 } 12015 12016 var sv *StopWorkspacesOutput 12017 if *v == nil { 12018 sv = &StopWorkspacesOutput{} 12019 } else { 12020 sv = *v 12021 } 12022 12023 for key, value := range shape { 12024 switch key { 12025 case "FailedRequests": 12026 if err := awsAwsjson11_deserializeDocumentFailedStopWorkspaceRequests(&sv.FailedRequests, value); err != nil { 12027 return err 12028 } 12029 12030 default: 12031 _, _ = key, value 12032 12033 } 12034 } 12035 *v = sv 12036 return nil 12037} 12038 12039func awsAwsjson11_deserializeOpDocumentTerminateWorkspacesOutput(v **TerminateWorkspacesOutput, value interface{}) error { 12040 if v == nil { 12041 return fmt.Errorf("unexpected nil of type %T", v) 12042 } 12043 if value == nil { 12044 return nil 12045 } 12046 12047 shape, ok := value.(map[string]interface{}) 12048 if !ok { 12049 return fmt.Errorf("unexpected JSON type %v", value) 12050 } 12051 12052 var sv *TerminateWorkspacesOutput 12053 if *v == nil { 12054 sv = &TerminateWorkspacesOutput{} 12055 } else { 12056 sv = *v 12057 } 12058 12059 for key, value := range shape { 12060 switch key { 12061 case "FailedRequests": 12062 if err := awsAwsjson11_deserializeDocumentFailedTerminateWorkspaceRequests(&sv.FailedRequests, value); err != nil { 12063 return err 12064 } 12065 12066 default: 12067 _, _ = key, value 12068 12069 } 12070 } 12071 *v = sv 12072 return nil 12073} 12074 12075func awsAwsjson11_deserializeOpDocumentUpdateConnectionAliasPermissionOutput(v **UpdateConnectionAliasPermissionOutput, value interface{}) error { 12076 if v == nil { 12077 return fmt.Errorf("unexpected nil of type %T", v) 12078 } 12079 if value == nil { 12080 return nil 12081 } 12082 12083 shape, ok := value.(map[string]interface{}) 12084 if !ok { 12085 return fmt.Errorf("unexpected JSON type %v", value) 12086 } 12087 12088 var sv *UpdateConnectionAliasPermissionOutput 12089 if *v == nil { 12090 sv = &UpdateConnectionAliasPermissionOutput{} 12091 } else { 12092 sv = *v 12093 } 12094 12095 for key, value := range shape { 12096 switch key { 12097 default: 12098 _, _ = key, value 12099 12100 } 12101 } 12102 *v = sv 12103 return nil 12104} 12105 12106func awsAwsjson11_deserializeOpDocumentUpdateRulesOfIpGroupOutput(v **UpdateRulesOfIpGroupOutput, value interface{}) error { 12107 if v == nil { 12108 return fmt.Errorf("unexpected nil of type %T", v) 12109 } 12110 if value == nil { 12111 return nil 12112 } 12113 12114 shape, ok := value.(map[string]interface{}) 12115 if !ok { 12116 return fmt.Errorf("unexpected JSON type %v", value) 12117 } 12118 12119 var sv *UpdateRulesOfIpGroupOutput 12120 if *v == nil { 12121 sv = &UpdateRulesOfIpGroupOutput{} 12122 } else { 12123 sv = *v 12124 } 12125 12126 for key, value := range shape { 12127 switch key { 12128 default: 12129 _, _ = key, value 12130 12131 } 12132 } 12133 *v = sv 12134 return nil 12135} 12136 12137func awsAwsjson11_deserializeOpDocumentUpdateWorkspaceBundleOutput(v **UpdateWorkspaceBundleOutput, value interface{}) error { 12138 if v == nil { 12139 return fmt.Errorf("unexpected nil of type %T", v) 12140 } 12141 if value == nil { 12142 return nil 12143 } 12144 12145 shape, ok := value.(map[string]interface{}) 12146 if !ok { 12147 return fmt.Errorf("unexpected JSON type %v", value) 12148 } 12149 12150 var sv *UpdateWorkspaceBundleOutput 12151 if *v == nil { 12152 sv = &UpdateWorkspaceBundleOutput{} 12153 } else { 12154 sv = *v 12155 } 12156 12157 for key, value := range shape { 12158 switch key { 12159 default: 12160 _, _ = key, value 12161 12162 } 12163 } 12164 *v = sv 12165 return nil 12166} 12167 12168func awsAwsjson11_deserializeOpDocumentUpdateWorkspaceImagePermissionOutput(v **UpdateWorkspaceImagePermissionOutput, value interface{}) error { 12169 if v == nil { 12170 return fmt.Errorf("unexpected nil of type %T", v) 12171 } 12172 if value == nil { 12173 return nil 12174 } 12175 12176 shape, ok := value.(map[string]interface{}) 12177 if !ok { 12178 return fmt.Errorf("unexpected JSON type %v", value) 12179 } 12180 12181 var sv *UpdateWorkspaceImagePermissionOutput 12182 if *v == nil { 12183 sv = &UpdateWorkspaceImagePermissionOutput{} 12184 } else { 12185 sv = *v 12186 } 12187 12188 for key, value := range shape { 12189 switch key { 12190 default: 12191 _, _ = key, value 12192 12193 } 12194 } 12195 *v = sv 12196 return nil 12197} 12198