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