1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package connect 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/connect/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithytime "github.com/aws/smithy-go/time" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16) 17 18type awsRestjson1_serializeOpAssociateApprovedOrigin struct { 19} 20 21func (*awsRestjson1_serializeOpAssociateApprovedOrigin) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpAssociateApprovedOrigin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27) { 28 request, ok := in.Request.(*smithyhttp.Request) 29 if !ok { 30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 31 } 32 33 input, ok := in.Parameters.(*AssociateApprovedOriginInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/approved-origin") 40 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 41 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 42 request.Method = "PUT" 43 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 44 if err != nil { 45 return out, metadata, &smithy.SerializationError{Err: err} 46 } 47 48 if err := awsRestjson1_serializeOpHttpBindingsAssociateApprovedOriginInput(input, restEncoder); err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 restEncoder.SetHeader("Content-Type").String("application/json") 53 54 jsonEncoder := smithyjson.NewEncoder() 55 if err := awsRestjson1_serializeOpDocumentAssociateApprovedOriginInput(input, jsonEncoder.Value); err != nil { 56 return out, metadata, &smithy.SerializationError{Err: err} 57 } 58 59 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 in.Request = request 67 68 return next.HandleSerialize(ctx, in) 69} 70func awsRestjson1_serializeOpHttpBindingsAssociateApprovedOriginInput(v *AssociateApprovedOriginInput, encoder *httpbinding.Encoder) error { 71 if v == nil { 72 return fmt.Errorf("unsupported serialization of nil %T", v) 73 } 74 75 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 76 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 77 } 78 if v.InstanceId != nil { 79 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 80 return err 81 } 82 } 83 84 return nil 85} 86 87func awsRestjson1_serializeOpDocumentAssociateApprovedOriginInput(v *AssociateApprovedOriginInput, value smithyjson.Value) error { 88 object := value.Object() 89 defer object.Close() 90 91 if v.Origin != nil { 92 ok := object.Key("Origin") 93 ok.String(*v.Origin) 94 } 95 96 return nil 97} 98 99type awsRestjson1_serializeOpAssociateInstanceStorageConfig struct { 100} 101 102func (*awsRestjson1_serializeOpAssociateInstanceStorageConfig) ID() string { 103 return "OperationSerializer" 104} 105 106func (m *awsRestjson1_serializeOpAssociateInstanceStorageConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 107 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 108) { 109 request, ok := in.Request.(*smithyhttp.Request) 110 if !ok { 111 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 112 } 113 114 input, ok := in.Parameters.(*AssociateInstanceStorageConfigInput) 115 _ = input 116 if !ok { 117 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 118 } 119 120 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/storage-config") 121 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 122 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 123 request.Method = "PUT" 124 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 125 if err != nil { 126 return out, metadata, &smithy.SerializationError{Err: err} 127 } 128 129 if err := awsRestjson1_serializeOpHttpBindingsAssociateInstanceStorageConfigInput(input, restEncoder); err != nil { 130 return out, metadata, &smithy.SerializationError{Err: err} 131 } 132 133 restEncoder.SetHeader("Content-Type").String("application/json") 134 135 jsonEncoder := smithyjson.NewEncoder() 136 if err := awsRestjson1_serializeOpDocumentAssociateInstanceStorageConfigInput(input, jsonEncoder.Value); err != nil { 137 return out, metadata, &smithy.SerializationError{Err: err} 138 } 139 140 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 141 return out, metadata, &smithy.SerializationError{Err: err} 142 } 143 144 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 145 return out, metadata, &smithy.SerializationError{Err: err} 146 } 147 in.Request = request 148 149 return next.HandleSerialize(ctx, in) 150} 151func awsRestjson1_serializeOpHttpBindingsAssociateInstanceStorageConfigInput(v *AssociateInstanceStorageConfigInput, encoder *httpbinding.Encoder) error { 152 if v == nil { 153 return fmt.Errorf("unsupported serialization of nil %T", v) 154 } 155 156 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 157 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 158 } 159 if v.InstanceId != nil { 160 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 161 return err 162 } 163 } 164 165 return nil 166} 167 168func awsRestjson1_serializeOpDocumentAssociateInstanceStorageConfigInput(v *AssociateInstanceStorageConfigInput, value smithyjson.Value) error { 169 object := value.Object() 170 defer object.Close() 171 172 if len(v.ResourceType) > 0 { 173 ok := object.Key("ResourceType") 174 ok.String(string(v.ResourceType)) 175 } 176 177 if v.StorageConfig != nil { 178 ok := object.Key("StorageConfig") 179 if err := awsRestjson1_serializeDocumentInstanceStorageConfig(v.StorageConfig, ok); err != nil { 180 return err 181 } 182 } 183 184 return nil 185} 186 187type awsRestjson1_serializeOpAssociateLambdaFunction struct { 188} 189 190func (*awsRestjson1_serializeOpAssociateLambdaFunction) ID() string { 191 return "OperationSerializer" 192} 193 194func (m *awsRestjson1_serializeOpAssociateLambdaFunction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 195 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 196) { 197 request, ok := in.Request.(*smithyhttp.Request) 198 if !ok { 199 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 200 } 201 202 input, ok := in.Parameters.(*AssociateLambdaFunctionInput) 203 _ = input 204 if !ok { 205 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 206 } 207 208 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/lambda-function") 209 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 210 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 211 request.Method = "PUT" 212 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 213 if err != nil { 214 return out, metadata, &smithy.SerializationError{Err: err} 215 } 216 217 if err := awsRestjson1_serializeOpHttpBindingsAssociateLambdaFunctionInput(input, restEncoder); err != nil { 218 return out, metadata, &smithy.SerializationError{Err: err} 219 } 220 221 restEncoder.SetHeader("Content-Type").String("application/json") 222 223 jsonEncoder := smithyjson.NewEncoder() 224 if err := awsRestjson1_serializeOpDocumentAssociateLambdaFunctionInput(input, jsonEncoder.Value); err != nil { 225 return out, metadata, &smithy.SerializationError{Err: err} 226 } 227 228 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 229 return out, metadata, &smithy.SerializationError{Err: err} 230 } 231 232 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 233 return out, metadata, &smithy.SerializationError{Err: err} 234 } 235 in.Request = request 236 237 return next.HandleSerialize(ctx, in) 238} 239func awsRestjson1_serializeOpHttpBindingsAssociateLambdaFunctionInput(v *AssociateLambdaFunctionInput, encoder *httpbinding.Encoder) error { 240 if v == nil { 241 return fmt.Errorf("unsupported serialization of nil %T", v) 242 } 243 244 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 245 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 246 } 247 if v.InstanceId != nil { 248 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 249 return err 250 } 251 } 252 253 return nil 254} 255 256func awsRestjson1_serializeOpDocumentAssociateLambdaFunctionInput(v *AssociateLambdaFunctionInput, value smithyjson.Value) error { 257 object := value.Object() 258 defer object.Close() 259 260 if v.FunctionArn != nil { 261 ok := object.Key("FunctionArn") 262 ok.String(*v.FunctionArn) 263 } 264 265 return nil 266} 267 268type awsRestjson1_serializeOpAssociateLexBot struct { 269} 270 271func (*awsRestjson1_serializeOpAssociateLexBot) ID() string { 272 return "OperationSerializer" 273} 274 275func (m *awsRestjson1_serializeOpAssociateLexBot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 276 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 277) { 278 request, ok := in.Request.(*smithyhttp.Request) 279 if !ok { 280 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 281 } 282 283 input, ok := in.Parameters.(*AssociateLexBotInput) 284 _ = input 285 if !ok { 286 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 287 } 288 289 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/lex-bot") 290 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 291 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 292 request.Method = "PUT" 293 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 294 if err != nil { 295 return out, metadata, &smithy.SerializationError{Err: err} 296 } 297 298 if err := awsRestjson1_serializeOpHttpBindingsAssociateLexBotInput(input, restEncoder); err != nil { 299 return out, metadata, &smithy.SerializationError{Err: err} 300 } 301 302 restEncoder.SetHeader("Content-Type").String("application/json") 303 304 jsonEncoder := smithyjson.NewEncoder() 305 if err := awsRestjson1_serializeOpDocumentAssociateLexBotInput(input, jsonEncoder.Value); err != nil { 306 return out, metadata, &smithy.SerializationError{Err: err} 307 } 308 309 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 310 return out, metadata, &smithy.SerializationError{Err: err} 311 } 312 313 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 314 return out, metadata, &smithy.SerializationError{Err: err} 315 } 316 in.Request = request 317 318 return next.HandleSerialize(ctx, in) 319} 320func awsRestjson1_serializeOpHttpBindingsAssociateLexBotInput(v *AssociateLexBotInput, encoder *httpbinding.Encoder) error { 321 if v == nil { 322 return fmt.Errorf("unsupported serialization of nil %T", v) 323 } 324 325 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 326 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 327 } 328 if v.InstanceId != nil { 329 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 330 return err 331 } 332 } 333 334 return nil 335} 336 337func awsRestjson1_serializeOpDocumentAssociateLexBotInput(v *AssociateLexBotInput, value smithyjson.Value) error { 338 object := value.Object() 339 defer object.Close() 340 341 if v.LexBot != nil { 342 ok := object.Key("LexBot") 343 if err := awsRestjson1_serializeDocumentLexBot(v.LexBot, ok); err != nil { 344 return err 345 } 346 } 347 348 return nil 349} 350 351type awsRestjson1_serializeOpAssociateQueueQuickConnects struct { 352} 353 354func (*awsRestjson1_serializeOpAssociateQueueQuickConnects) ID() string { 355 return "OperationSerializer" 356} 357 358func (m *awsRestjson1_serializeOpAssociateQueueQuickConnects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 359 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 360) { 361 request, ok := in.Request.(*smithyhttp.Request) 362 if !ok { 363 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 364 } 365 366 input, ok := in.Parameters.(*AssociateQueueQuickConnectsInput) 367 _ = input 368 if !ok { 369 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 370 } 371 372 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/associate-quick-connects") 373 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 374 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 375 request.Method = "POST" 376 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 377 if err != nil { 378 return out, metadata, &smithy.SerializationError{Err: err} 379 } 380 381 if err := awsRestjson1_serializeOpHttpBindingsAssociateQueueQuickConnectsInput(input, restEncoder); err != nil { 382 return out, metadata, &smithy.SerializationError{Err: err} 383 } 384 385 restEncoder.SetHeader("Content-Type").String("application/json") 386 387 jsonEncoder := smithyjson.NewEncoder() 388 if err := awsRestjson1_serializeOpDocumentAssociateQueueQuickConnectsInput(input, jsonEncoder.Value); err != nil { 389 return out, metadata, &smithy.SerializationError{Err: err} 390 } 391 392 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 393 return out, metadata, &smithy.SerializationError{Err: err} 394 } 395 396 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 397 return out, metadata, &smithy.SerializationError{Err: err} 398 } 399 in.Request = request 400 401 return next.HandleSerialize(ctx, in) 402} 403func awsRestjson1_serializeOpHttpBindingsAssociateQueueQuickConnectsInput(v *AssociateQueueQuickConnectsInput, encoder *httpbinding.Encoder) error { 404 if v == nil { 405 return fmt.Errorf("unsupported serialization of nil %T", v) 406 } 407 408 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 409 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 410 } 411 if v.InstanceId != nil { 412 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 413 return err 414 } 415 } 416 417 if v.QueueId == nil || len(*v.QueueId) == 0 { 418 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 419 } 420 if v.QueueId != nil { 421 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 422 return err 423 } 424 } 425 426 return nil 427} 428 429func awsRestjson1_serializeOpDocumentAssociateQueueQuickConnectsInput(v *AssociateQueueQuickConnectsInput, value smithyjson.Value) error { 430 object := value.Object() 431 defer object.Close() 432 433 if v.QuickConnectIds != nil { 434 ok := object.Key("QuickConnectIds") 435 if err := awsRestjson1_serializeDocumentQuickConnectsList(v.QuickConnectIds, ok); err != nil { 436 return err 437 } 438 } 439 440 return nil 441} 442 443type awsRestjson1_serializeOpAssociateRoutingProfileQueues struct { 444} 445 446func (*awsRestjson1_serializeOpAssociateRoutingProfileQueues) ID() string { 447 return "OperationSerializer" 448} 449 450func (m *awsRestjson1_serializeOpAssociateRoutingProfileQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 451 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 452) { 453 request, ok := in.Request.(*smithyhttp.Request) 454 if !ok { 455 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 456 } 457 458 input, ok := in.Parameters.(*AssociateRoutingProfileQueuesInput) 459 _ = input 460 if !ok { 461 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 462 } 463 464 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}/associate-queues") 465 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 466 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 467 request.Method = "POST" 468 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 469 if err != nil { 470 return out, metadata, &smithy.SerializationError{Err: err} 471 } 472 473 if err := awsRestjson1_serializeOpHttpBindingsAssociateRoutingProfileQueuesInput(input, restEncoder); err != nil { 474 return out, metadata, &smithy.SerializationError{Err: err} 475 } 476 477 restEncoder.SetHeader("Content-Type").String("application/json") 478 479 jsonEncoder := smithyjson.NewEncoder() 480 if err := awsRestjson1_serializeOpDocumentAssociateRoutingProfileQueuesInput(input, jsonEncoder.Value); err != nil { 481 return out, metadata, &smithy.SerializationError{Err: err} 482 } 483 484 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 485 return out, metadata, &smithy.SerializationError{Err: err} 486 } 487 488 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 489 return out, metadata, &smithy.SerializationError{Err: err} 490 } 491 in.Request = request 492 493 return next.HandleSerialize(ctx, in) 494} 495func awsRestjson1_serializeOpHttpBindingsAssociateRoutingProfileQueuesInput(v *AssociateRoutingProfileQueuesInput, encoder *httpbinding.Encoder) error { 496 if v == nil { 497 return fmt.Errorf("unsupported serialization of nil %T", v) 498 } 499 500 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 501 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 502 } 503 if v.InstanceId != nil { 504 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 505 return err 506 } 507 } 508 509 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 510 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 511 } 512 if v.RoutingProfileId != nil { 513 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 514 return err 515 } 516 } 517 518 return nil 519} 520 521func awsRestjson1_serializeOpDocumentAssociateRoutingProfileQueuesInput(v *AssociateRoutingProfileQueuesInput, value smithyjson.Value) error { 522 object := value.Object() 523 defer object.Close() 524 525 if v.QueueConfigs != nil { 526 ok := object.Key("QueueConfigs") 527 if err := awsRestjson1_serializeDocumentRoutingProfileQueueConfigList(v.QueueConfigs, ok); err != nil { 528 return err 529 } 530 } 531 532 return nil 533} 534 535type awsRestjson1_serializeOpAssociateSecurityKey struct { 536} 537 538func (*awsRestjson1_serializeOpAssociateSecurityKey) ID() string { 539 return "OperationSerializer" 540} 541 542func (m *awsRestjson1_serializeOpAssociateSecurityKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 543 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 544) { 545 request, ok := in.Request.(*smithyhttp.Request) 546 if !ok { 547 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 548 } 549 550 input, ok := in.Parameters.(*AssociateSecurityKeyInput) 551 _ = input 552 if !ok { 553 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 554 } 555 556 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/security-key") 557 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 558 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 559 request.Method = "PUT" 560 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 561 if err != nil { 562 return out, metadata, &smithy.SerializationError{Err: err} 563 } 564 565 if err := awsRestjson1_serializeOpHttpBindingsAssociateSecurityKeyInput(input, restEncoder); err != nil { 566 return out, metadata, &smithy.SerializationError{Err: err} 567 } 568 569 restEncoder.SetHeader("Content-Type").String("application/json") 570 571 jsonEncoder := smithyjson.NewEncoder() 572 if err := awsRestjson1_serializeOpDocumentAssociateSecurityKeyInput(input, jsonEncoder.Value); err != nil { 573 return out, metadata, &smithy.SerializationError{Err: err} 574 } 575 576 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 577 return out, metadata, &smithy.SerializationError{Err: err} 578 } 579 580 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 581 return out, metadata, &smithy.SerializationError{Err: err} 582 } 583 in.Request = request 584 585 return next.HandleSerialize(ctx, in) 586} 587func awsRestjson1_serializeOpHttpBindingsAssociateSecurityKeyInput(v *AssociateSecurityKeyInput, encoder *httpbinding.Encoder) error { 588 if v == nil { 589 return fmt.Errorf("unsupported serialization of nil %T", v) 590 } 591 592 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 593 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 594 } 595 if v.InstanceId != nil { 596 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 597 return err 598 } 599 } 600 601 return nil 602} 603 604func awsRestjson1_serializeOpDocumentAssociateSecurityKeyInput(v *AssociateSecurityKeyInput, value smithyjson.Value) error { 605 object := value.Object() 606 defer object.Close() 607 608 if v.Key != nil { 609 ok := object.Key("Key") 610 ok.String(*v.Key) 611 } 612 613 return nil 614} 615 616type awsRestjson1_serializeOpCreateContactFlow struct { 617} 618 619func (*awsRestjson1_serializeOpCreateContactFlow) ID() string { 620 return "OperationSerializer" 621} 622 623func (m *awsRestjson1_serializeOpCreateContactFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 624 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 625) { 626 request, ok := in.Request.(*smithyhttp.Request) 627 if !ok { 628 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 629 } 630 631 input, ok := in.Parameters.(*CreateContactFlowInput) 632 _ = input 633 if !ok { 634 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 635 } 636 637 opPath, opQuery := httpbinding.SplitURI("/contact-flows/{InstanceId}") 638 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 639 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 640 request.Method = "PUT" 641 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 642 if err != nil { 643 return out, metadata, &smithy.SerializationError{Err: err} 644 } 645 646 if err := awsRestjson1_serializeOpHttpBindingsCreateContactFlowInput(input, restEncoder); err != nil { 647 return out, metadata, &smithy.SerializationError{Err: err} 648 } 649 650 restEncoder.SetHeader("Content-Type").String("application/json") 651 652 jsonEncoder := smithyjson.NewEncoder() 653 if err := awsRestjson1_serializeOpDocumentCreateContactFlowInput(input, jsonEncoder.Value); err != nil { 654 return out, metadata, &smithy.SerializationError{Err: err} 655 } 656 657 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 658 return out, metadata, &smithy.SerializationError{Err: err} 659 } 660 661 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 662 return out, metadata, &smithy.SerializationError{Err: err} 663 } 664 in.Request = request 665 666 return next.HandleSerialize(ctx, in) 667} 668func awsRestjson1_serializeOpHttpBindingsCreateContactFlowInput(v *CreateContactFlowInput, encoder *httpbinding.Encoder) error { 669 if v == nil { 670 return fmt.Errorf("unsupported serialization of nil %T", v) 671 } 672 673 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 674 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 675 } 676 if v.InstanceId != nil { 677 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 678 return err 679 } 680 } 681 682 return nil 683} 684 685func awsRestjson1_serializeOpDocumentCreateContactFlowInput(v *CreateContactFlowInput, value smithyjson.Value) error { 686 object := value.Object() 687 defer object.Close() 688 689 if v.Content != nil { 690 ok := object.Key("Content") 691 ok.String(*v.Content) 692 } 693 694 if v.Description != nil { 695 ok := object.Key("Description") 696 ok.String(*v.Description) 697 } 698 699 if v.Name != nil { 700 ok := object.Key("Name") 701 ok.String(*v.Name) 702 } 703 704 if v.Tags != nil { 705 ok := object.Key("Tags") 706 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 707 return err 708 } 709 } 710 711 if len(v.Type) > 0 { 712 ok := object.Key("Type") 713 ok.String(string(v.Type)) 714 } 715 716 return nil 717} 718 719type awsRestjson1_serializeOpCreateInstance struct { 720} 721 722func (*awsRestjson1_serializeOpCreateInstance) ID() string { 723 return "OperationSerializer" 724} 725 726func (m *awsRestjson1_serializeOpCreateInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 727 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 728) { 729 request, ok := in.Request.(*smithyhttp.Request) 730 if !ok { 731 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 732 } 733 734 input, ok := in.Parameters.(*CreateInstanceInput) 735 _ = input 736 if !ok { 737 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 738 } 739 740 opPath, opQuery := httpbinding.SplitURI("/instance") 741 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 742 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 743 request.Method = "PUT" 744 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 745 if err != nil { 746 return out, metadata, &smithy.SerializationError{Err: err} 747 } 748 749 restEncoder.SetHeader("Content-Type").String("application/json") 750 751 jsonEncoder := smithyjson.NewEncoder() 752 if err := awsRestjson1_serializeOpDocumentCreateInstanceInput(input, jsonEncoder.Value); err != nil { 753 return out, metadata, &smithy.SerializationError{Err: err} 754 } 755 756 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 757 return out, metadata, &smithy.SerializationError{Err: err} 758 } 759 760 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 761 return out, metadata, &smithy.SerializationError{Err: err} 762 } 763 in.Request = request 764 765 return next.HandleSerialize(ctx, in) 766} 767func awsRestjson1_serializeOpHttpBindingsCreateInstanceInput(v *CreateInstanceInput, encoder *httpbinding.Encoder) error { 768 if v == nil { 769 return fmt.Errorf("unsupported serialization of nil %T", v) 770 } 771 772 return nil 773} 774 775func awsRestjson1_serializeOpDocumentCreateInstanceInput(v *CreateInstanceInput, value smithyjson.Value) error { 776 object := value.Object() 777 defer object.Close() 778 779 if v.ClientToken != nil { 780 ok := object.Key("ClientToken") 781 ok.String(*v.ClientToken) 782 } 783 784 if v.DirectoryId != nil { 785 ok := object.Key("DirectoryId") 786 ok.String(*v.DirectoryId) 787 } 788 789 if len(v.IdentityManagementType) > 0 { 790 ok := object.Key("IdentityManagementType") 791 ok.String(string(v.IdentityManagementType)) 792 } 793 794 if v.InboundCallsEnabled != nil { 795 ok := object.Key("InboundCallsEnabled") 796 ok.Boolean(*v.InboundCallsEnabled) 797 } 798 799 if v.InstanceAlias != nil { 800 ok := object.Key("InstanceAlias") 801 ok.String(*v.InstanceAlias) 802 } 803 804 if v.OutboundCallsEnabled != nil { 805 ok := object.Key("OutboundCallsEnabled") 806 ok.Boolean(*v.OutboundCallsEnabled) 807 } 808 809 return nil 810} 811 812type awsRestjson1_serializeOpCreateIntegrationAssociation struct { 813} 814 815func (*awsRestjson1_serializeOpCreateIntegrationAssociation) ID() string { 816 return "OperationSerializer" 817} 818 819func (m *awsRestjson1_serializeOpCreateIntegrationAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 820 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 821) { 822 request, ok := in.Request.(*smithyhttp.Request) 823 if !ok { 824 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 825 } 826 827 input, ok := in.Parameters.(*CreateIntegrationAssociationInput) 828 _ = input 829 if !ok { 830 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 831 } 832 833 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/integration-associations") 834 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 835 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 836 request.Method = "PUT" 837 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 838 if err != nil { 839 return out, metadata, &smithy.SerializationError{Err: err} 840 } 841 842 if err := awsRestjson1_serializeOpHttpBindingsCreateIntegrationAssociationInput(input, restEncoder); err != nil { 843 return out, metadata, &smithy.SerializationError{Err: err} 844 } 845 846 restEncoder.SetHeader("Content-Type").String("application/json") 847 848 jsonEncoder := smithyjson.NewEncoder() 849 if err := awsRestjson1_serializeOpDocumentCreateIntegrationAssociationInput(input, jsonEncoder.Value); err != nil { 850 return out, metadata, &smithy.SerializationError{Err: err} 851 } 852 853 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 854 return out, metadata, &smithy.SerializationError{Err: err} 855 } 856 857 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 858 return out, metadata, &smithy.SerializationError{Err: err} 859 } 860 in.Request = request 861 862 return next.HandleSerialize(ctx, in) 863} 864func awsRestjson1_serializeOpHttpBindingsCreateIntegrationAssociationInput(v *CreateIntegrationAssociationInput, encoder *httpbinding.Encoder) error { 865 if v == nil { 866 return fmt.Errorf("unsupported serialization of nil %T", v) 867 } 868 869 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 870 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 871 } 872 if v.InstanceId != nil { 873 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 874 return err 875 } 876 } 877 878 return nil 879} 880 881func awsRestjson1_serializeOpDocumentCreateIntegrationAssociationInput(v *CreateIntegrationAssociationInput, value smithyjson.Value) error { 882 object := value.Object() 883 defer object.Close() 884 885 if v.IntegrationArn != nil { 886 ok := object.Key("IntegrationArn") 887 ok.String(*v.IntegrationArn) 888 } 889 890 if len(v.IntegrationType) > 0 { 891 ok := object.Key("IntegrationType") 892 ok.String(string(v.IntegrationType)) 893 } 894 895 if v.SourceApplicationName != nil { 896 ok := object.Key("SourceApplicationName") 897 ok.String(*v.SourceApplicationName) 898 } 899 900 if v.SourceApplicationUrl != nil { 901 ok := object.Key("SourceApplicationUrl") 902 ok.String(*v.SourceApplicationUrl) 903 } 904 905 if len(v.SourceType) > 0 { 906 ok := object.Key("SourceType") 907 ok.String(string(v.SourceType)) 908 } 909 910 return nil 911} 912 913type awsRestjson1_serializeOpCreateQueue struct { 914} 915 916func (*awsRestjson1_serializeOpCreateQueue) ID() string { 917 return "OperationSerializer" 918} 919 920func (m *awsRestjson1_serializeOpCreateQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 921 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 922) { 923 request, ok := in.Request.(*smithyhttp.Request) 924 if !ok { 925 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 926 } 927 928 input, ok := in.Parameters.(*CreateQueueInput) 929 _ = input 930 if !ok { 931 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 932 } 933 934 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}") 935 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 936 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 937 request.Method = "PUT" 938 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 939 if err != nil { 940 return out, metadata, &smithy.SerializationError{Err: err} 941 } 942 943 if err := awsRestjson1_serializeOpHttpBindingsCreateQueueInput(input, restEncoder); err != nil { 944 return out, metadata, &smithy.SerializationError{Err: err} 945 } 946 947 restEncoder.SetHeader("Content-Type").String("application/json") 948 949 jsonEncoder := smithyjson.NewEncoder() 950 if err := awsRestjson1_serializeOpDocumentCreateQueueInput(input, jsonEncoder.Value); err != nil { 951 return out, metadata, &smithy.SerializationError{Err: err} 952 } 953 954 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 955 return out, metadata, &smithy.SerializationError{Err: err} 956 } 957 958 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 959 return out, metadata, &smithy.SerializationError{Err: err} 960 } 961 in.Request = request 962 963 return next.HandleSerialize(ctx, in) 964} 965func awsRestjson1_serializeOpHttpBindingsCreateQueueInput(v *CreateQueueInput, encoder *httpbinding.Encoder) error { 966 if v == nil { 967 return fmt.Errorf("unsupported serialization of nil %T", v) 968 } 969 970 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 971 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 972 } 973 if v.InstanceId != nil { 974 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 975 return err 976 } 977 } 978 979 return nil 980} 981 982func awsRestjson1_serializeOpDocumentCreateQueueInput(v *CreateQueueInput, value smithyjson.Value) error { 983 object := value.Object() 984 defer object.Close() 985 986 if v.Description != nil { 987 ok := object.Key("Description") 988 ok.String(*v.Description) 989 } 990 991 if v.HoursOfOperationId != nil { 992 ok := object.Key("HoursOfOperationId") 993 ok.String(*v.HoursOfOperationId) 994 } 995 996 if v.MaxContacts != 0 { 997 ok := object.Key("MaxContacts") 998 ok.Integer(v.MaxContacts) 999 } 1000 1001 if v.Name != nil { 1002 ok := object.Key("Name") 1003 ok.String(*v.Name) 1004 } 1005 1006 if v.OutboundCallerConfig != nil { 1007 ok := object.Key("OutboundCallerConfig") 1008 if err := awsRestjson1_serializeDocumentOutboundCallerConfig(v.OutboundCallerConfig, ok); err != nil { 1009 return err 1010 } 1011 } 1012 1013 if v.QuickConnectIds != nil { 1014 ok := object.Key("QuickConnectIds") 1015 if err := awsRestjson1_serializeDocumentQuickConnectsList(v.QuickConnectIds, ok); err != nil { 1016 return err 1017 } 1018 } 1019 1020 if v.Tags != nil { 1021 ok := object.Key("Tags") 1022 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1023 return err 1024 } 1025 } 1026 1027 return nil 1028} 1029 1030type awsRestjson1_serializeOpCreateQuickConnect struct { 1031} 1032 1033func (*awsRestjson1_serializeOpCreateQuickConnect) ID() string { 1034 return "OperationSerializer" 1035} 1036 1037func (m *awsRestjson1_serializeOpCreateQuickConnect) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1038 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1039) { 1040 request, ok := in.Request.(*smithyhttp.Request) 1041 if !ok { 1042 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1043 } 1044 1045 input, ok := in.Parameters.(*CreateQuickConnectInput) 1046 _ = input 1047 if !ok { 1048 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1049 } 1050 1051 opPath, opQuery := httpbinding.SplitURI("/quick-connects/{InstanceId}") 1052 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1053 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1054 request.Method = "PUT" 1055 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1056 if err != nil { 1057 return out, metadata, &smithy.SerializationError{Err: err} 1058 } 1059 1060 if err := awsRestjson1_serializeOpHttpBindingsCreateQuickConnectInput(input, restEncoder); err != nil { 1061 return out, metadata, &smithy.SerializationError{Err: err} 1062 } 1063 1064 restEncoder.SetHeader("Content-Type").String("application/json") 1065 1066 jsonEncoder := smithyjson.NewEncoder() 1067 if err := awsRestjson1_serializeOpDocumentCreateQuickConnectInput(input, jsonEncoder.Value); err != nil { 1068 return out, metadata, &smithy.SerializationError{Err: err} 1069 } 1070 1071 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1072 return out, metadata, &smithy.SerializationError{Err: err} 1073 } 1074 1075 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1076 return out, metadata, &smithy.SerializationError{Err: err} 1077 } 1078 in.Request = request 1079 1080 return next.HandleSerialize(ctx, in) 1081} 1082func awsRestjson1_serializeOpHttpBindingsCreateQuickConnectInput(v *CreateQuickConnectInput, encoder *httpbinding.Encoder) error { 1083 if v == nil { 1084 return fmt.Errorf("unsupported serialization of nil %T", v) 1085 } 1086 1087 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1088 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1089 } 1090 if v.InstanceId != nil { 1091 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1092 return err 1093 } 1094 } 1095 1096 return nil 1097} 1098 1099func awsRestjson1_serializeOpDocumentCreateQuickConnectInput(v *CreateQuickConnectInput, value smithyjson.Value) error { 1100 object := value.Object() 1101 defer object.Close() 1102 1103 if v.Description != nil { 1104 ok := object.Key("Description") 1105 ok.String(*v.Description) 1106 } 1107 1108 if v.Name != nil { 1109 ok := object.Key("Name") 1110 ok.String(*v.Name) 1111 } 1112 1113 if v.QuickConnectConfig != nil { 1114 ok := object.Key("QuickConnectConfig") 1115 if err := awsRestjson1_serializeDocumentQuickConnectConfig(v.QuickConnectConfig, ok); err != nil { 1116 return err 1117 } 1118 } 1119 1120 if v.Tags != nil { 1121 ok := object.Key("Tags") 1122 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1123 return err 1124 } 1125 } 1126 1127 return nil 1128} 1129 1130type awsRestjson1_serializeOpCreateRoutingProfile struct { 1131} 1132 1133func (*awsRestjson1_serializeOpCreateRoutingProfile) ID() string { 1134 return "OperationSerializer" 1135} 1136 1137func (m *awsRestjson1_serializeOpCreateRoutingProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1138 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1139) { 1140 request, ok := in.Request.(*smithyhttp.Request) 1141 if !ok { 1142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1143 } 1144 1145 input, ok := in.Parameters.(*CreateRoutingProfileInput) 1146 _ = input 1147 if !ok { 1148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1149 } 1150 1151 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}") 1152 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1153 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1154 request.Method = "PUT" 1155 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1156 if err != nil { 1157 return out, metadata, &smithy.SerializationError{Err: err} 1158 } 1159 1160 if err := awsRestjson1_serializeOpHttpBindingsCreateRoutingProfileInput(input, restEncoder); err != nil { 1161 return out, metadata, &smithy.SerializationError{Err: err} 1162 } 1163 1164 restEncoder.SetHeader("Content-Type").String("application/json") 1165 1166 jsonEncoder := smithyjson.NewEncoder() 1167 if err := awsRestjson1_serializeOpDocumentCreateRoutingProfileInput(input, jsonEncoder.Value); err != nil { 1168 return out, metadata, &smithy.SerializationError{Err: err} 1169 } 1170 1171 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1172 return out, metadata, &smithy.SerializationError{Err: err} 1173 } 1174 1175 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1176 return out, metadata, &smithy.SerializationError{Err: err} 1177 } 1178 in.Request = request 1179 1180 return next.HandleSerialize(ctx, in) 1181} 1182func awsRestjson1_serializeOpHttpBindingsCreateRoutingProfileInput(v *CreateRoutingProfileInput, encoder *httpbinding.Encoder) error { 1183 if v == nil { 1184 return fmt.Errorf("unsupported serialization of nil %T", v) 1185 } 1186 1187 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1188 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1189 } 1190 if v.InstanceId != nil { 1191 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1192 return err 1193 } 1194 } 1195 1196 return nil 1197} 1198 1199func awsRestjson1_serializeOpDocumentCreateRoutingProfileInput(v *CreateRoutingProfileInput, value smithyjson.Value) error { 1200 object := value.Object() 1201 defer object.Close() 1202 1203 if v.DefaultOutboundQueueId != nil { 1204 ok := object.Key("DefaultOutboundQueueId") 1205 ok.String(*v.DefaultOutboundQueueId) 1206 } 1207 1208 if v.Description != nil { 1209 ok := object.Key("Description") 1210 ok.String(*v.Description) 1211 } 1212 1213 if v.MediaConcurrencies != nil { 1214 ok := object.Key("MediaConcurrencies") 1215 if err := awsRestjson1_serializeDocumentMediaConcurrencies(v.MediaConcurrencies, ok); err != nil { 1216 return err 1217 } 1218 } 1219 1220 if v.Name != nil { 1221 ok := object.Key("Name") 1222 ok.String(*v.Name) 1223 } 1224 1225 if v.QueueConfigs != nil { 1226 ok := object.Key("QueueConfigs") 1227 if err := awsRestjson1_serializeDocumentRoutingProfileQueueConfigList(v.QueueConfigs, ok); err != nil { 1228 return err 1229 } 1230 } 1231 1232 if v.Tags != nil { 1233 ok := object.Key("Tags") 1234 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1235 return err 1236 } 1237 } 1238 1239 return nil 1240} 1241 1242type awsRestjson1_serializeOpCreateUseCase struct { 1243} 1244 1245func (*awsRestjson1_serializeOpCreateUseCase) ID() string { 1246 return "OperationSerializer" 1247} 1248 1249func (m *awsRestjson1_serializeOpCreateUseCase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1250 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1251) { 1252 request, ok := in.Request.(*smithyhttp.Request) 1253 if !ok { 1254 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1255 } 1256 1257 input, ok := in.Parameters.(*CreateUseCaseInput) 1258 _ = input 1259 if !ok { 1260 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1261 } 1262 1263 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}/use-cases") 1264 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1265 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1266 request.Method = "PUT" 1267 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1268 if err != nil { 1269 return out, metadata, &smithy.SerializationError{Err: err} 1270 } 1271 1272 if err := awsRestjson1_serializeOpHttpBindingsCreateUseCaseInput(input, restEncoder); err != nil { 1273 return out, metadata, &smithy.SerializationError{Err: err} 1274 } 1275 1276 restEncoder.SetHeader("Content-Type").String("application/json") 1277 1278 jsonEncoder := smithyjson.NewEncoder() 1279 if err := awsRestjson1_serializeOpDocumentCreateUseCaseInput(input, jsonEncoder.Value); err != nil { 1280 return out, metadata, &smithy.SerializationError{Err: err} 1281 } 1282 1283 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1284 return out, metadata, &smithy.SerializationError{Err: err} 1285 } 1286 1287 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1288 return out, metadata, &smithy.SerializationError{Err: err} 1289 } 1290 in.Request = request 1291 1292 return next.HandleSerialize(ctx, in) 1293} 1294func awsRestjson1_serializeOpHttpBindingsCreateUseCaseInput(v *CreateUseCaseInput, encoder *httpbinding.Encoder) error { 1295 if v == nil { 1296 return fmt.Errorf("unsupported serialization of nil %T", v) 1297 } 1298 1299 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1300 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1301 } 1302 if v.InstanceId != nil { 1303 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1304 return err 1305 } 1306 } 1307 1308 if v.IntegrationAssociationId == nil || len(*v.IntegrationAssociationId) == 0 { 1309 return &smithy.SerializationError{Err: fmt.Errorf("input member IntegrationAssociationId must not be empty")} 1310 } 1311 if v.IntegrationAssociationId != nil { 1312 if err := encoder.SetURI("IntegrationAssociationId").String(*v.IntegrationAssociationId); err != nil { 1313 return err 1314 } 1315 } 1316 1317 return nil 1318} 1319 1320func awsRestjson1_serializeOpDocumentCreateUseCaseInput(v *CreateUseCaseInput, value smithyjson.Value) error { 1321 object := value.Object() 1322 defer object.Close() 1323 1324 if len(v.UseCaseType) > 0 { 1325 ok := object.Key("UseCaseType") 1326 ok.String(string(v.UseCaseType)) 1327 } 1328 1329 return nil 1330} 1331 1332type awsRestjson1_serializeOpCreateUser struct { 1333} 1334 1335func (*awsRestjson1_serializeOpCreateUser) ID() string { 1336 return "OperationSerializer" 1337} 1338 1339func (m *awsRestjson1_serializeOpCreateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1340 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1341) { 1342 request, ok := in.Request.(*smithyhttp.Request) 1343 if !ok { 1344 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1345 } 1346 1347 input, ok := in.Parameters.(*CreateUserInput) 1348 _ = input 1349 if !ok { 1350 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1351 } 1352 1353 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}") 1354 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1355 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1356 request.Method = "PUT" 1357 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1358 if err != nil { 1359 return out, metadata, &smithy.SerializationError{Err: err} 1360 } 1361 1362 if err := awsRestjson1_serializeOpHttpBindingsCreateUserInput(input, restEncoder); err != nil { 1363 return out, metadata, &smithy.SerializationError{Err: err} 1364 } 1365 1366 restEncoder.SetHeader("Content-Type").String("application/json") 1367 1368 jsonEncoder := smithyjson.NewEncoder() 1369 if err := awsRestjson1_serializeOpDocumentCreateUserInput(input, jsonEncoder.Value); err != nil { 1370 return out, metadata, &smithy.SerializationError{Err: err} 1371 } 1372 1373 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1374 return out, metadata, &smithy.SerializationError{Err: err} 1375 } 1376 1377 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1378 return out, metadata, &smithy.SerializationError{Err: err} 1379 } 1380 in.Request = request 1381 1382 return next.HandleSerialize(ctx, in) 1383} 1384func awsRestjson1_serializeOpHttpBindingsCreateUserInput(v *CreateUserInput, encoder *httpbinding.Encoder) error { 1385 if v == nil { 1386 return fmt.Errorf("unsupported serialization of nil %T", v) 1387 } 1388 1389 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1390 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1391 } 1392 if v.InstanceId != nil { 1393 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1394 return err 1395 } 1396 } 1397 1398 return nil 1399} 1400 1401func awsRestjson1_serializeOpDocumentCreateUserInput(v *CreateUserInput, value smithyjson.Value) error { 1402 object := value.Object() 1403 defer object.Close() 1404 1405 if v.DirectoryUserId != nil { 1406 ok := object.Key("DirectoryUserId") 1407 ok.String(*v.DirectoryUserId) 1408 } 1409 1410 if v.HierarchyGroupId != nil { 1411 ok := object.Key("HierarchyGroupId") 1412 ok.String(*v.HierarchyGroupId) 1413 } 1414 1415 if v.IdentityInfo != nil { 1416 ok := object.Key("IdentityInfo") 1417 if err := awsRestjson1_serializeDocumentUserIdentityInfo(v.IdentityInfo, ok); err != nil { 1418 return err 1419 } 1420 } 1421 1422 if v.Password != nil { 1423 ok := object.Key("Password") 1424 ok.String(*v.Password) 1425 } 1426 1427 if v.PhoneConfig != nil { 1428 ok := object.Key("PhoneConfig") 1429 if err := awsRestjson1_serializeDocumentUserPhoneConfig(v.PhoneConfig, ok); err != nil { 1430 return err 1431 } 1432 } 1433 1434 if v.RoutingProfileId != nil { 1435 ok := object.Key("RoutingProfileId") 1436 ok.String(*v.RoutingProfileId) 1437 } 1438 1439 if v.SecurityProfileIds != nil { 1440 ok := object.Key("SecurityProfileIds") 1441 if err := awsRestjson1_serializeDocumentSecurityProfileIds(v.SecurityProfileIds, ok); err != nil { 1442 return err 1443 } 1444 } 1445 1446 if v.Tags != nil { 1447 ok := object.Key("Tags") 1448 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1449 return err 1450 } 1451 } 1452 1453 if v.Username != nil { 1454 ok := object.Key("Username") 1455 ok.String(*v.Username) 1456 } 1457 1458 return nil 1459} 1460 1461type awsRestjson1_serializeOpCreateUserHierarchyGroup struct { 1462} 1463 1464func (*awsRestjson1_serializeOpCreateUserHierarchyGroup) ID() string { 1465 return "OperationSerializer" 1466} 1467 1468func (m *awsRestjson1_serializeOpCreateUserHierarchyGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1469 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1470) { 1471 request, ok := in.Request.(*smithyhttp.Request) 1472 if !ok { 1473 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1474 } 1475 1476 input, ok := in.Parameters.(*CreateUserHierarchyGroupInput) 1477 _ = input 1478 if !ok { 1479 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1480 } 1481 1482 opPath, opQuery := httpbinding.SplitURI("/user-hierarchy-groups/{InstanceId}") 1483 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1484 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1485 request.Method = "PUT" 1486 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1487 if err != nil { 1488 return out, metadata, &smithy.SerializationError{Err: err} 1489 } 1490 1491 if err := awsRestjson1_serializeOpHttpBindingsCreateUserHierarchyGroupInput(input, restEncoder); err != nil { 1492 return out, metadata, &smithy.SerializationError{Err: err} 1493 } 1494 1495 restEncoder.SetHeader("Content-Type").String("application/json") 1496 1497 jsonEncoder := smithyjson.NewEncoder() 1498 if err := awsRestjson1_serializeOpDocumentCreateUserHierarchyGroupInput(input, jsonEncoder.Value); err != nil { 1499 return out, metadata, &smithy.SerializationError{Err: err} 1500 } 1501 1502 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1503 return out, metadata, &smithy.SerializationError{Err: err} 1504 } 1505 1506 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1507 return out, metadata, &smithy.SerializationError{Err: err} 1508 } 1509 in.Request = request 1510 1511 return next.HandleSerialize(ctx, in) 1512} 1513func awsRestjson1_serializeOpHttpBindingsCreateUserHierarchyGroupInput(v *CreateUserHierarchyGroupInput, encoder *httpbinding.Encoder) error { 1514 if v == nil { 1515 return fmt.Errorf("unsupported serialization of nil %T", v) 1516 } 1517 1518 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1519 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1520 } 1521 if v.InstanceId != nil { 1522 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1523 return err 1524 } 1525 } 1526 1527 return nil 1528} 1529 1530func awsRestjson1_serializeOpDocumentCreateUserHierarchyGroupInput(v *CreateUserHierarchyGroupInput, value smithyjson.Value) error { 1531 object := value.Object() 1532 defer object.Close() 1533 1534 if v.Name != nil { 1535 ok := object.Key("Name") 1536 ok.String(*v.Name) 1537 } 1538 1539 if v.ParentGroupId != nil { 1540 ok := object.Key("ParentGroupId") 1541 ok.String(*v.ParentGroupId) 1542 } 1543 1544 return nil 1545} 1546 1547type awsRestjson1_serializeOpDeleteInstance struct { 1548} 1549 1550func (*awsRestjson1_serializeOpDeleteInstance) ID() string { 1551 return "OperationSerializer" 1552} 1553 1554func (m *awsRestjson1_serializeOpDeleteInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1555 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1556) { 1557 request, ok := in.Request.(*smithyhttp.Request) 1558 if !ok { 1559 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1560 } 1561 1562 input, ok := in.Parameters.(*DeleteInstanceInput) 1563 _ = input 1564 if !ok { 1565 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1566 } 1567 1568 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}") 1569 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1570 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1571 request.Method = "DELETE" 1572 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1573 if err != nil { 1574 return out, metadata, &smithy.SerializationError{Err: err} 1575 } 1576 1577 if err := awsRestjson1_serializeOpHttpBindingsDeleteInstanceInput(input, restEncoder); err != nil { 1578 return out, metadata, &smithy.SerializationError{Err: err} 1579 } 1580 1581 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1582 return out, metadata, &smithy.SerializationError{Err: err} 1583 } 1584 in.Request = request 1585 1586 return next.HandleSerialize(ctx, in) 1587} 1588func awsRestjson1_serializeOpHttpBindingsDeleteInstanceInput(v *DeleteInstanceInput, encoder *httpbinding.Encoder) error { 1589 if v == nil { 1590 return fmt.Errorf("unsupported serialization of nil %T", v) 1591 } 1592 1593 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1594 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1595 } 1596 if v.InstanceId != nil { 1597 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1598 return err 1599 } 1600 } 1601 1602 return nil 1603} 1604 1605type awsRestjson1_serializeOpDeleteIntegrationAssociation struct { 1606} 1607 1608func (*awsRestjson1_serializeOpDeleteIntegrationAssociation) ID() string { 1609 return "OperationSerializer" 1610} 1611 1612func (m *awsRestjson1_serializeOpDeleteIntegrationAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1613 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1614) { 1615 request, ok := in.Request.(*smithyhttp.Request) 1616 if !ok { 1617 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1618 } 1619 1620 input, ok := in.Parameters.(*DeleteIntegrationAssociationInput) 1621 _ = input 1622 if !ok { 1623 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1624 } 1625 1626 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}") 1627 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1628 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1629 request.Method = "DELETE" 1630 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1631 if err != nil { 1632 return out, metadata, &smithy.SerializationError{Err: err} 1633 } 1634 1635 if err := awsRestjson1_serializeOpHttpBindingsDeleteIntegrationAssociationInput(input, restEncoder); err != nil { 1636 return out, metadata, &smithy.SerializationError{Err: err} 1637 } 1638 1639 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1640 return out, metadata, &smithy.SerializationError{Err: err} 1641 } 1642 in.Request = request 1643 1644 return next.HandleSerialize(ctx, in) 1645} 1646func awsRestjson1_serializeOpHttpBindingsDeleteIntegrationAssociationInput(v *DeleteIntegrationAssociationInput, encoder *httpbinding.Encoder) error { 1647 if v == nil { 1648 return fmt.Errorf("unsupported serialization of nil %T", v) 1649 } 1650 1651 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1652 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1653 } 1654 if v.InstanceId != nil { 1655 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1656 return err 1657 } 1658 } 1659 1660 if v.IntegrationAssociationId == nil || len(*v.IntegrationAssociationId) == 0 { 1661 return &smithy.SerializationError{Err: fmt.Errorf("input member IntegrationAssociationId must not be empty")} 1662 } 1663 if v.IntegrationAssociationId != nil { 1664 if err := encoder.SetURI("IntegrationAssociationId").String(*v.IntegrationAssociationId); err != nil { 1665 return err 1666 } 1667 } 1668 1669 return nil 1670} 1671 1672type awsRestjson1_serializeOpDeleteQuickConnect struct { 1673} 1674 1675func (*awsRestjson1_serializeOpDeleteQuickConnect) ID() string { 1676 return "OperationSerializer" 1677} 1678 1679func (m *awsRestjson1_serializeOpDeleteQuickConnect) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1680 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1681) { 1682 request, ok := in.Request.(*smithyhttp.Request) 1683 if !ok { 1684 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1685 } 1686 1687 input, ok := in.Parameters.(*DeleteQuickConnectInput) 1688 _ = input 1689 if !ok { 1690 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1691 } 1692 1693 opPath, opQuery := httpbinding.SplitURI("/quick-connects/{InstanceId}/{QuickConnectId}") 1694 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1695 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1696 request.Method = "DELETE" 1697 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1698 if err != nil { 1699 return out, metadata, &smithy.SerializationError{Err: err} 1700 } 1701 1702 if err := awsRestjson1_serializeOpHttpBindingsDeleteQuickConnectInput(input, restEncoder); err != nil { 1703 return out, metadata, &smithy.SerializationError{Err: err} 1704 } 1705 1706 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1707 return out, metadata, &smithy.SerializationError{Err: err} 1708 } 1709 in.Request = request 1710 1711 return next.HandleSerialize(ctx, in) 1712} 1713func awsRestjson1_serializeOpHttpBindingsDeleteQuickConnectInput(v *DeleteQuickConnectInput, encoder *httpbinding.Encoder) error { 1714 if v == nil { 1715 return fmt.Errorf("unsupported serialization of nil %T", v) 1716 } 1717 1718 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1719 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1720 } 1721 if v.InstanceId != nil { 1722 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1723 return err 1724 } 1725 } 1726 1727 if v.QuickConnectId == nil || len(*v.QuickConnectId) == 0 { 1728 return &smithy.SerializationError{Err: fmt.Errorf("input member QuickConnectId must not be empty")} 1729 } 1730 if v.QuickConnectId != nil { 1731 if err := encoder.SetURI("QuickConnectId").String(*v.QuickConnectId); err != nil { 1732 return err 1733 } 1734 } 1735 1736 return nil 1737} 1738 1739type awsRestjson1_serializeOpDeleteUseCase struct { 1740} 1741 1742func (*awsRestjson1_serializeOpDeleteUseCase) ID() string { 1743 return "OperationSerializer" 1744} 1745 1746func (m *awsRestjson1_serializeOpDeleteUseCase) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1747 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1748) { 1749 request, ok := in.Request.(*smithyhttp.Request) 1750 if !ok { 1751 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1752 } 1753 1754 input, ok := in.Parameters.(*DeleteUseCaseInput) 1755 _ = input 1756 if !ok { 1757 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1758 } 1759 1760 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}/use-cases/{UseCaseId}") 1761 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1762 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1763 request.Method = "DELETE" 1764 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1765 if err != nil { 1766 return out, metadata, &smithy.SerializationError{Err: err} 1767 } 1768 1769 if err := awsRestjson1_serializeOpHttpBindingsDeleteUseCaseInput(input, restEncoder); err != nil { 1770 return out, metadata, &smithy.SerializationError{Err: err} 1771 } 1772 1773 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1774 return out, metadata, &smithy.SerializationError{Err: err} 1775 } 1776 in.Request = request 1777 1778 return next.HandleSerialize(ctx, in) 1779} 1780func awsRestjson1_serializeOpHttpBindingsDeleteUseCaseInput(v *DeleteUseCaseInput, encoder *httpbinding.Encoder) error { 1781 if v == nil { 1782 return fmt.Errorf("unsupported serialization of nil %T", v) 1783 } 1784 1785 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1786 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1787 } 1788 if v.InstanceId != nil { 1789 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1790 return err 1791 } 1792 } 1793 1794 if v.IntegrationAssociationId == nil || len(*v.IntegrationAssociationId) == 0 { 1795 return &smithy.SerializationError{Err: fmt.Errorf("input member IntegrationAssociationId must not be empty")} 1796 } 1797 if v.IntegrationAssociationId != nil { 1798 if err := encoder.SetURI("IntegrationAssociationId").String(*v.IntegrationAssociationId); err != nil { 1799 return err 1800 } 1801 } 1802 1803 if v.UseCaseId == nil || len(*v.UseCaseId) == 0 { 1804 return &smithy.SerializationError{Err: fmt.Errorf("input member UseCaseId must not be empty")} 1805 } 1806 if v.UseCaseId != nil { 1807 if err := encoder.SetURI("UseCaseId").String(*v.UseCaseId); err != nil { 1808 return err 1809 } 1810 } 1811 1812 return nil 1813} 1814 1815type awsRestjson1_serializeOpDeleteUser struct { 1816} 1817 1818func (*awsRestjson1_serializeOpDeleteUser) ID() string { 1819 return "OperationSerializer" 1820} 1821 1822func (m *awsRestjson1_serializeOpDeleteUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1823 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1824) { 1825 request, ok := in.Request.(*smithyhttp.Request) 1826 if !ok { 1827 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1828 } 1829 1830 input, ok := in.Parameters.(*DeleteUserInput) 1831 _ = input 1832 if !ok { 1833 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1834 } 1835 1836 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}/{UserId}") 1837 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1838 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1839 request.Method = "DELETE" 1840 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1841 if err != nil { 1842 return out, metadata, &smithy.SerializationError{Err: err} 1843 } 1844 1845 if err := awsRestjson1_serializeOpHttpBindingsDeleteUserInput(input, restEncoder); err != nil { 1846 return out, metadata, &smithy.SerializationError{Err: err} 1847 } 1848 1849 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1850 return out, metadata, &smithy.SerializationError{Err: err} 1851 } 1852 in.Request = request 1853 1854 return next.HandleSerialize(ctx, in) 1855} 1856func awsRestjson1_serializeOpHttpBindingsDeleteUserInput(v *DeleteUserInput, encoder *httpbinding.Encoder) error { 1857 if v == nil { 1858 return fmt.Errorf("unsupported serialization of nil %T", v) 1859 } 1860 1861 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1862 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1863 } 1864 if v.InstanceId != nil { 1865 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1866 return err 1867 } 1868 } 1869 1870 if v.UserId == nil || len(*v.UserId) == 0 { 1871 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 1872 } 1873 if v.UserId != nil { 1874 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 1875 return err 1876 } 1877 } 1878 1879 return nil 1880} 1881 1882type awsRestjson1_serializeOpDeleteUserHierarchyGroup struct { 1883} 1884 1885func (*awsRestjson1_serializeOpDeleteUserHierarchyGroup) ID() string { 1886 return "OperationSerializer" 1887} 1888 1889func (m *awsRestjson1_serializeOpDeleteUserHierarchyGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1890 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1891) { 1892 request, ok := in.Request.(*smithyhttp.Request) 1893 if !ok { 1894 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1895 } 1896 1897 input, ok := in.Parameters.(*DeleteUserHierarchyGroupInput) 1898 _ = input 1899 if !ok { 1900 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1901 } 1902 1903 opPath, opQuery := httpbinding.SplitURI("/user-hierarchy-groups/{InstanceId}/{HierarchyGroupId}") 1904 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1905 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1906 request.Method = "DELETE" 1907 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1908 if err != nil { 1909 return out, metadata, &smithy.SerializationError{Err: err} 1910 } 1911 1912 if err := awsRestjson1_serializeOpHttpBindingsDeleteUserHierarchyGroupInput(input, restEncoder); err != nil { 1913 return out, metadata, &smithy.SerializationError{Err: err} 1914 } 1915 1916 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1917 return out, metadata, &smithy.SerializationError{Err: err} 1918 } 1919 in.Request = request 1920 1921 return next.HandleSerialize(ctx, in) 1922} 1923func awsRestjson1_serializeOpHttpBindingsDeleteUserHierarchyGroupInput(v *DeleteUserHierarchyGroupInput, encoder *httpbinding.Encoder) error { 1924 if v == nil { 1925 return fmt.Errorf("unsupported serialization of nil %T", v) 1926 } 1927 1928 if v.HierarchyGroupId == nil || len(*v.HierarchyGroupId) == 0 { 1929 return &smithy.SerializationError{Err: fmt.Errorf("input member HierarchyGroupId must not be empty")} 1930 } 1931 if v.HierarchyGroupId != nil { 1932 if err := encoder.SetURI("HierarchyGroupId").String(*v.HierarchyGroupId); err != nil { 1933 return err 1934 } 1935 } 1936 1937 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 1938 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 1939 } 1940 if v.InstanceId != nil { 1941 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 1942 return err 1943 } 1944 } 1945 1946 return nil 1947} 1948 1949type awsRestjson1_serializeOpDescribeContactFlow struct { 1950} 1951 1952func (*awsRestjson1_serializeOpDescribeContactFlow) ID() string { 1953 return "OperationSerializer" 1954} 1955 1956func (m *awsRestjson1_serializeOpDescribeContactFlow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1957 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1958) { 1959 request, ok := in.Request.(*smithyhttp.Request) 1960 if !ok { 1961 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1962 } 1963 1964 input, ok := in.Parameters.(*DescribeContactFlowInput) 1965 _ = input 1966 if !ok { 1967 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1968 } 1969 1970 opPath, opQuery := httpbinding.SplitURI("/contact-flows/{InstanceId}/{ContactFlowId}") 1971 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1972 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1973 request.Method = "GET" 1974 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1975 if err != nil { 1976 return out, metadata, &smithy.SerializationError{Err: err} 1977 } 1978 1979 if err := awsRestjson1_serializeOpHttpBindingsDescribeContactFlowInput(input, restEncoder); err != nil { 1980 return out, metadata, &smithy.SerializationError{Err: err} 1981 } 1982 1983 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1984 return out, metadata, &smithy.SerializationError{Err: err} 1985 } 1986 in.Request = request 1987 1988 return next.HandleSerialize(ctx, in) 1989} 1990func awsRestjson1_serializeOpHttpBindingsDescribeContactFlowInput(v *DescribeContactFlowInput, encoder *httpbinding.Encoder) error { 1991 if v == nil { 1992 return fmt.Errorf("unsupported serialization of nil %T", v) 1993 } 1994 1995 if v.ContactFlowId == nil || len(*v.ContactFlowId) == 0 { 1996 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactFlowId must not be empty")} 1997 } 1998 if v.ContactFlowId != nil { 1999 if err := encoder.SetURI("ContactFlowId").String(*v.ContactFlowId); err != nil { 2000 return err 2001 } 2002 } 2003 2004 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2005 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2006 } 2007 if v.InstanceId != nil { 2008 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2009 return err 2010 } 2011 } 2012 2013 return nil 2014} 2015 2016type awsRestjson1_serializeOpDescribeHoursOfOperation struct { 2017} 2018 2019func (*awsRestjson1_serializeOpDescribeHoursOfOperation) ID() string { 2020 return "OperationSerializer" 2021} 2022 2023func (m *awsRestjson1_serializeOpDescribeHoursOfOperation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2024 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2025) { 2026 request, ok := in.Request.(*smithyhttp.Request) 2027 if !ok { 2028 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2029 } 2030 2031 input, ok := in.Parameters.(*DescribeHoursOfOperationInput) 2032 _ = input 2033 if !ok { 2034 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2035 } 2036 2037 opPath, opQuery := httpbinding.SplitURI("/hours-of-operations/{InstanceId}/{HoursOfOperationId}") 2038 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2039 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2040 request.Method = "GET" 2041 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2042 if err != nil { 2043 return out, metadata, &smithy.SerializationError{Err: err} 2044 } 2045 2046 if err := awsRestjson1_serializeOpHttpBindingsDescribeHoursOfOperationInput(input, restEncoder); err != nil { 2047 return out, metadata, &smithy.SerializationError{Err: err} 2048 } 2049 2050 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2051 return out, metadata, &smithy.SerializationError{Err: err} 2052 } 2053 in.Request = request 2054 2055 return next.HandleSerialize(ctx, in) 2056} 2057func awsRestjson1_serializeOpHttpBindingsDescribeHoursOfOperationInput(v *DescribeHoursOfOperationInput, encoder *httpbinding.Encoder) error { 2058 if v == nil { 2059 return fmt.Errorf("unsupported serialization of nil %T", v) 2060 } 2061 2062 if v.HoursOfOperationId == nil || len(*v.HoursOfOperationId) == 0 { 2063 return &smithy.SerializationError{Err: fmt.Errorf("input member HoursOfOperationId must not be empty")} 2064 } 2065 if v.HoursOfOperationId != nil { 2066 if err := encoder.SetURI("HoursOfOperationId").String(*v.HoursOfOperationId); err != nil { 2067 return err 2068 } 2069 } 2070 2071 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2072 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2073 } 2074 if v.InstanceId != nil { 2075 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2076 return err 2077 } 2078 } 2079 2080 return nil 2081} 2082 2083type awsRestjson1_serializeOpDescribeInstance struct { 2084} 2085 2086func (*awsRestjson1_serializeOpDescribeInstance) ID() string { 2087 return "OperationSerializer" 2088} 2089 2090func (m *awsRestjson1_serializeOpDescribeInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2091 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2092) { 2093 request, ok := in.Request.(*smithyhttp.Request) 2094 if !ok { 2095 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2096 } 2097 2098 input, ok := in.Parameters.(*DescribeInstanceInput) 2099 _ = input 2100 if !ok { 2101 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2102 } 2103 2104 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}") 2105 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2106 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2107 request.Method = "GET" 2108 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2109 if err != nil { 2110 return out, metadata, &smithy.SerializationError{Err: err} 2111 } 2112 2113 if err := awsRestjson1_serializeOpHttpBindingsDescribeInstanceInput(input, restEncoder); err != nil { 2114 return out, metadata, &smithy.SerializationError{Err: err} 2115 } 2116 2117 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2118 return out, metadata, &smithy.SerializationError{Err: err} 2119 } 2120 in.Request = request 2121 2122 return next.HandleSerialize(ctx, in) 2123} 2124func awsRestjson1_serializeOpHttpBindingsDescribeInstanceInput(v *DescribeInstanceInput, encoder *httpbinding.Encoder) error { 2125 if v == nil { 2126 return fmt.Errorf("unsupported serialization of nil %T", v) 2127 } 2128 2129 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2130 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2131 } 2132 if v.InstanceId != nil { 2133 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2134 return err 2135 } 2136 } 2137 2138 return nil 2139} 2140 2141type awsRestjson1_serializeOpDescribeInstanceAttribute struct { 2142} 2143 2144func (*awsRestjson1_serializeOpDescribeInstanceAttribute) ID() string { 2145 return "OperationSerializer" 2146} 2147 2148func (m *awsRestjson1_serializeOpDescribeInstanceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2149 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2150) { 2151 request, ok := in.Request.(*smithyhttp.Request) 2152 if !ok { 2153 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2154 } 2155 2156 input, ok := in.Parameters.(*DescribeInstanceAttributeInput) 2157 _ = input 2158 if !ok { 2159 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2160 } 2161 2162 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/attribute/{AttributeType}") 2163 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2164 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2165 request.Method = "GET" 2166 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2167 if err != nil { 2168 return out, metadata, &smithy.SerializationError{Err: err} 2169 } 2170 2171 if err := awsRestjson1_serializeOpHttpBindingsDescribeInstanceAttributeInput(input, restEncoder); err != nil { 2172 return out, metadata, &smithy.SerializationError{Err: err} 2173 } 2174 2175 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2176 return out, metadata, &smithy.SerializationError{Err: err} 2177 } 2178 in.Request = request 2179 2180 return next.HandleSerialize(ctx, in) 2181} 2182func awsRestjson1_serializeOpHttpBindingsDescribeInstanceAttributeInput(v *DescribeInstanceAttributeInput, encoder *httpbinding.Encoder) error { 2183 if v == nil { 2184 return fmt.Errorf("unsupported serialization of nil %T", v) 2185 } 2186 2187 if len(v.AttributeType) == 0 { 2188 return &smithy.SerializationError{Err: fmt.Errorf("input member AttributeType must not be empty")} 2189 } 2190 if len(v.AttributeType) > 0 { 2191 if err := encoder.SetURI("AttributeType").String(string(v.AttributeType)); err != nil { 2192 return err 2193 } 2194 } 2195 2196 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2197 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2198 } 2199 if v.InstanceId != nil { 2200 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2201 return err 2202 } 2203 } 2204 2205 return nil 2206} 2207 2208type awsRestjson1_serializeOpDescribeInstanceStorageConfig struct { 2209} 2210 2211func (*awsRestjson1_serializeOpDescribeInstanceStorageConfig) ID() string { 2212 return "OperationSerializer" 2213} 2214 2215func (m *awsRestjson1_serializeOpDescribeInstanceStorageConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2216 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2217) { 2218 request, ok := in.Request.(*smithyhttp.Request) 2219 if !ok { 2220 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2221 } 2222 2223 input, ok := in.Parameters.(*DescribeInstanceStorageConfigInput) 2224 _ = input 2225 if !ok { 2226 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2227 } 2228 2229 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/storage-config/{AssociationId}") 2230 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2231 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2232 request.Method = "GET" 2233 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2234 if err != nil { 2235 return out, metadata, &smithy.SerializationError{Err: err} 2236 } 2237 2238 if err := awsRestjson1_serializeOpHttpBindingsDescribeInstanceStorageConfigInput(input, restEncoder); err != nil { 2239 return out, metadata, &smithy.SerializationError{Err: err} 2240 } 2241 2242 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2243 return out, metadata, &smithy.SerializationError{Err: err} 2244 } 2245 in.Request = request 2246 2247 return next.HandleSerialize(ctx, in) 2248} 2249func awsRestjson1_serializeOpHttpBindingsDescribeInstanceStorageConfigInput(v *DescribeInstanceStorageConfigInput, encoder *httpbinding.Encoder) error { 2250 if v == nil { 2251 return fmt.Errorf("unsupported serialization of nil %T", v) 2252 } 2253 2254 if v.AssociationId == nil || len(*v.AssociationId) == 0 { 2255 return &smithy.SerializationError{Err: fmt.Errorf("input member AssociationId must not be empty")} 2256 } 2257 if v.AssociationId != nil { 2258 if err := encoder.SetURI("AssociationId").String(*v.AssociationId); err != nil { 2259 return err 2260 } 2261 } 2262 2263 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2264 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2265 } 2266 if v.InstanceId != nil { 2267 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2268 return err 2269 } 2270 } 2271 2272 if len(v.ResourceType) > 0 { 2273 encoder.SetQuery("resourceType").String(string(v.ResourceType)) 2274 } 2275 2276 return nil 2277} 2278 2279type awsRestjson1_serializeOpDescribeQueue struct { 2280} 2281 2282func (*awsRestjson1_serializeOpDescribeQueue) ID() string { 2283 return "OperationSerializer" 2284} 2285 2286func (m *awsRestjson1_serializeOpDescribeQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2287 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2288) { 2289 request, ok := in.Request.(*smithyhttp.Request) 2290 if !ok { 2291 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2292 } 2293 2294 input, ok := in.Parameters.(*DescribeQueueInput) 2295 _ = input 2296 if !ok { 2297 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2298 } 2299 2300 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}") 2301 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2302 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2303 request.Method = "GET" 2304 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2305 if err != nil { 2306 return out, metadata, &smithy.SerializationError{Err: err} 2307 } 2308 2309 if err := awsRestjson1_serializeOpHttpBindingsDescribeQueueInput(input, restEncoder); err != nil { 2310 return out, metadata, &smithy.SerializationError{Err: err} 2311 } 2312 2313 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2314 return out, metadata, &smithy.SerializationError{Err: err} 2315 } 2316 in.Request = request 2317 2318 return next.HandleSerialize(ctx, in) 2319} 2320func awsRestjson1_serializeOpHttpBindingsDescribeQueueInput(v *DescribeQueueInput, encoder *httpbinding.Encoder) error { 2321 if v == nil { 2322 return fmt.Errorf("unsupported serialization of nil %T", v) 2323 } 2324 2325 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2326 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2327 } 2328 if v.InstanceId != nil { 2329 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2330 return err 2331 } 2332 } 2333 2334 if v.QueueId == nil || len(*v.QueueId) == 0 { 2335 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 2336 } 2337 if v.QueueId != nil { 2338 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 2339 return err 2340 } 2341 } 2342 2343 return nil 2344} 2345 2346type awsRestjson1_serializeOpDescribeQuickConnect struct { 2347} 2348 2349func (*awsRestjson1_serializeOpDescribeQuickConnect) ID() string { 2350 return "OperationSerializer" 2351} 2352 2353func (m *awsRestjson1_serializeOpDescribeQuickConnect) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2354 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2355) { 2356 request, ok := in.Request.(*smithyhttp.Request) 2357 if !ok { 2358 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2359 } 2360 2361 input, ok := in.Parameters.(*DescribeQuickConnectInput) 2362 _ = input 2363 if !ok { 2364 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2365 } 2366 2367 opPath, opQuery := httpbinding.SplitURI("/quick-connects/{InstanceId}/{QuickConnectId}") 2368 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2369 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2370 request.Method = "GET" 2371 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2372 if err != nil { 2373 return out, metadata, &smithy.SerializationError{Err: err} 2374 } 2375 2376 if err := awsRestjson1_serializeOpHttpBindingsDescribeQuickConnectInput(input, restEncoder); err != nil { 2377 return out, metadata, &smithy.SerializationError{Err: err} 2378 } 2379 2380 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2381 return out, metadata, &smithy.SerializationError{Err: err} 2382 } 2383 in.Request = request 2384 2385 return next.HandleSerialize(ctx, in) 2386} 2387func awsRestjson1_serializeOpHttpBindingsDescribeQuickConnectInput(v *DescribeQuickConnectInput, encoder *httpbinding.Encoder) error { 2388 if v == nil { 2389 return fmt.Errorf("unsupported serialization of nil %T", v) 2390 } 2391 2392 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2393 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2394 } 2395 if v.InstanceId != nil { 2396 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2397 return err 2398 } 2399 } 2400 2401 if v.QuickConnectId == nil || len(*v.QuickConnectId) == 0 { 2402 return &smithy.SerializationError{Err: fmt.Errorf("input member QuickConnectId must not be empty")} 2403 } 2404 if v.QuickConnectId != nil { 2405 if err := encoder.SetURI("QuickConnectId").String(*v.QuickConnectId); err != nil { 2406 return err 2407 } 2408 } 2409 2410 return nil 2411} 2412 2413type awsRestjson1_serializeOpDescribeRoutingProfile struct { 2414} 2415 2416func (*awsRestjson1_serializeOpDescribeRoutingProfile) ID() string { 2417 return "OperationSerializer" 2418} 2419 2420func (m *awsRestjson1_serializeOpDescribeRoutingProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2421 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2422) { 2423 request, ok := in.Request.(*smithyhttp.Request) 2424 if !ok { 2425 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2426 } 2427 2428 input, ok := in.Parameters.(*DescribeRoutingProfileInput) 2429 _ = input 2430 if !ok { 2431 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2432 } 2433 2434 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}") 2435 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2436 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2437 request.Method = "GET" 2438 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2439 if err != nil { 2440 return out, metadata, &smithy.SerializationError{Err: err} 2441 } 2442 2443 if err := awsRestjson1_serializeOpHttpBindingsDescribeRoutingProfileInput(input, restEncoder); err != nil { 2444 return out, metadata, &smithy.SerializationError{Err: err} 2445 } 2446 2447 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2448 return out, metadata, &smithy.SerializationError{Err: err} 2449 } 2450 in.Request = request 2451 2452 return next.HandleSerialize(ctx, in) 2453} 2454func awsRestjson1_serializeOpHttpBindingsDescribeRoutingProfileInput(v *DescribeRoutingProfileInput, encoder *httpbinding.Encoder) error { 2455 if v == nil { 2456 return fmt.Errorf("unsupported serialization of nil %T", v) 2457 } 2458 2459 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2460 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2461 } 2462 if v.InstanceId != nil { 2463 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2464 return err 2465 } 2466 } 2467 2468 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 2469 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 2470 } 2471 if v.RoutingProfileId != nil { 2472 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 2473 return err 2474 } 2475 } 2476 2477 return nil 2478} 2479 2480type awsRestjson1_serializeOpDescribeUser struct { 2481} 2482 2483func (*awsRestjson1_serializeOpDescribeUser) ID() string { 2484 return "OperationSerializer" 2485} 2486 2487func (m *awsRestjson1_serializeOpDescribeUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2488 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2489) { 2490 request, ok := in.Request.(*smithyhttp.Request) 2491 if !ok { 2492 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2493 } 2494 2495 input, ok := in.Parameters.(*DescribeUserInput) 2496 _ = input 2497 if !ok { 2498 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2499 } 2500 2501 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}/{UserId}") 2502 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2503 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2504 request.Method = "GET" 2505 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2506 if err != nil { 2507 return out, metadata, &smithy.SerializationError{Err: err} 2508 } 2509 2510 if err := awsRestjson1_serializeOpHttpBindingsDescribeUserInput(input, restEncoder); err != nil { 2511 return out, metadata, &smithy.SerializationError{Err: err} 2512 } 2513 2514 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2515 return out, metadata, &smithy.SerializationError{Err: err} 2516 } 2517 in.Request = request 2518 2519 return next.HandleSerialize(ctx, in) 2520} 2521func awsRestjson1_serializeOpHttpBindingsDescribeUserInput(v *DescribeUserInput, encoder *httpbinding.Encoder) error { 2522 if v == nil { 2523 return fmt.Errorf("unsupported serialization of nil %T", v) 2524 } 2525 2526 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2527 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2528 } 2529 if v.InstanceId != nil { 2530 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2531 return err 2532 } 2533 } 2534 2535 if v.UserId == nil || len(*v.UserId) == 0 { 2536 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 2537 } 2538 if v.UserId != nil { 2539 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 2540 return err 2541 } 2542 } 2543 2544 return nil 2545} 2546 2547type awsRestjson1_serializeOpDescribeUserHierarchyGroup struct { 2548} 2549 2550func (*awsRestjson1_serializeOpDescribeUserHierarchyGroup) ID() string { 2551 return "OperationSerializer" 2552} 2553 2554func (m *awsRestjson1_serializeOpDescribeUserHierarchyGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2555 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2556) { 2557 request, ok := in.Request.(*smithyhttp.Request) 2558 if !ok { 2559 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2560 } 2561 2562 input, ok := in.Parameters.(*DescribeUserHierarchyGroupInput) 2563 _ = input 2564 if !ok { 2565 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2566 } 2567 2568 opPath, opQuery := httpbinding.SplitURI("/user-hierarchy-groups/{InstanceId}/{HierarchyGroupId}") 2569 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2570 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2571 request.Method = "GET" 2572 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2573 if err != nil { 2574 return out, metadata, &smithy.SerializationError{Err: err} 2575 } 2576 2577 if err := awsRestjson1_serializeOpHttpBindingsDescribeUserHierarchyGroupInput(input, restEncoder); err != nil { 2578 return out, metadata, &smithy.SerializationError{Err: err} 2579 } 2580 2581 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2582 return out, metadata, &smithy.SerializationError{Err: err} 2583 } 2584 in.Request = request 2585 2586 return next.HandleSerialize(ctx, in) 2587} 2588func awsRestjson1_serializeOpHttpBindingsDescribeUserHierarchyGroupInput(v *DescribeUserHierarchyGroupInput, encoder *httpbinding.Encoder) error { 2589 if v == nil { 2590 return fmt.Errorf("unsupported serialization of nil %T", v) 2591 } 2592 2593 if v.HierarchyGroupId == nil || len(*v.HierarchyGroupId) == 0 { 2594 return &smithy.SerializationError{Err: fmt.Errorf("input member HierarchyGroupId must not be empty")} 2595 } 2596 if v.HierarchyGroupId != nil { 2597 if err := encoder.SetURI("HierarchyGroupId").String(*v.HierarchyGroupId); err != nil { 2598 return err 2599 } 2600 } 2601 2602 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2603 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2604 } 2605 if v.InstanceId != nil { 2606 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2607 return err 2608 } 2609 } 2610 2611 return nil 2612} 2613 2614type awsRestjson1_serializeOpDescribeUserHierarchyStructure struct { 2615} 2616 2617func (*awsRestjson1_serializeOpDescribeUserHierarchyStructure) ID() string { 2618 return "OperationSerializer" 2619} 2620 2621func (m *awsRestjson1_serializeOpDescribeUserHierarchyStructure) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2622 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2623) { 2624 request, ok := in.Request.(*smithyhttp.Request) 2625 if !ok { 2626 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2627 } 2628 2629 input, ok := in.Parameters.(*DescribeUserHierarchyStructureInput) 2630 _ = input 2631 if !ok { 2632 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2633 } 2634 2635 opPath, opQuery := httpbinding.SplitURI("/user-hierarchy-structure/{InstanceId}") 2636 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2637 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2638 request.Method = "GET" 2639 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2640 if err != nil { 2641 return out, metadata, &smithy.SerializationError{Err: err} 2642 } 2643 2644 if err := awsRestjson1_serializeOpHttpBindingsDescribeUserHierarchyStructureInput(input, restEncoder); err != nil { 2645 return out, metadata, &smithy.SerializationError{Err: err} 2646 } 2647 2648 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2649 return out, metadata, &smithy.SerializationError{Err: err} 2650 } 2651 in.Request = request 2652 2653 return next.HandleSerialize(ctx, in) 2654} 2655func awsRestjson1_serializeOpHttpBindingsDescribeUserHierarchyStructureInput(v *DescribeUserHierarchyStructureInput, encoder *httpbinding.Encoder) error { 2656 if v == nil { 2657 return fmt.Errorf("unsupported serialization of nil %T", v) 2658 } 2659 2660 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2661 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2662 } 2663 if v.InstanceId != nil { 2664 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2665 return err 2666 } 2667 } 2668 2669 return nil 2670} 2671 2672type awsRestjson1_serializeOpDisassociateApprovedOrigin struct { 2673} 2674 2675func (*awsRestjson1_serializeOpDisassociateApprovedOrigin) ID() string { 2676 return "OperationSerializer" 2677} 2678 2679func (m *awsRestjson1_serializeOpDisassociateApprovedOrigin) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2680 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2681) { 2682 request, ok := in.Request.(*smithyhttp.Request) 2683 if !ok { 2684 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2685 } 2686 2687 input, ok := in.Parameters.(*DisassociateApprovedOriginInput) 2688 _ = input 2689 if !ok { 2690 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2691 } 2692 2693 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/approved-origin") 2694 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2695 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2696 request.Method = "DELETE" 2697 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2698 if err != nil { 2699 return out, metadata, &smithy.SerializationError{Err: err} 2700 } 2701 2702 if err := awsRestjson1_serializeOpHttpBindingsDisassociateApprovedOriginInput(input, restEncoder); err != nil { 2703 return out, metadata, &smithy.SerializationError{Err: err} 2704 } 2705 2706 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2707 return out, metadata, &smithy.SerializationError{Err: err} 2708 } 2709 in.Request = request 2710 2711 return next.HandleSerialize(ctx, in) 2712} 2713func awsRestjson1_serializeOpHttpBindingsDisassociateApprovedOriginInput(v *DisassociateApprovedOriginInput, encoder *httpbinding.Encoder) error { 2714 if v == nil { 2715 return fmt.Errorf("unsupported serialization of nil %T", v) 2716 } 2717 2718 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2719 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2720 } 2721 if v.InstanceId != nil { 2722 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2723 return err 2724 } 2725 } 2726 2727 if v.Origin != nil { 2728 encoder.SetQuery("origin").String(*v.Origin) 2729 } 2730 2731 return nil 2732} 2733 2734type awsRestjson1_serializeOpDisassociateInstanceStorageConfig struct { 2735} 2736 2737func (*awsRestjson1_serializeOpDisassociateInstanceStorageConfig) ID() string { 2738 return "OperationSerializer" 2739} 2740 2741func (m *awsRestjson1_serializeOpDisassociateInstanceStorageConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2742 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2743) { 2744 request, ok := in.Request.(*smithyhttp.Request) 2745 if !ok { 2746 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2747 } 2748 2749 input, ok := in.Parameters.(*DisassociateInstanceStorageConfigInput) 2750 _ = input 2751 if !ok { 2752 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2753 } 2754 2755 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/storage-config/{AssociationId}") 2756 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2757 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2758 request.Method = "DELETE" 2759 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2760 if err != nil { 2761 return out, metadata, &smithy.SerializationError{Err: err} 2762 } 2763 2764 if err := awsRestjson1_serializeOpHttpBindingsDisassociateInstanceStorageConfigInput(input, restEncoder); err != nil { 2765 return out, metadata, &smithy.SerializationError{Err: err} 2766 } 2767 2768 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2769 return out, metadata, &smithy.SerializationError{Err: err} 2770 } 2771 in.Request = request 2772 2773 return next.HandleSerialize(ctx, in) 2774} 2775func awsRestjson1_serializeOpHttpBindingsDisassociateInstanceStorageConfigInput(v *DisassociateInstanceStorageConfigInput, encoder *httpbinding.Encoder) error { 2776 if v == nil { 2777 return fmt.Errorf("unsupported serialization of nil %T", v) 2778 } 2779 2780 if v.AssociationId == nil || len(*v.AssociationId) == 0 { 2781 return &smithy.SerializationError{Err: fmt.Errorf("input member AssociationId must not be empty")} 2782 } 2783 if v.AssociationId != nil { 2784 if err := encoder.SetURI("AssociationId").String(*v.AssociationId); err != nil { 2785 return err 2786 } 2787 } 2788 2789 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2790 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2791 } 2792 if v.InstanceId != nil { 2793 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2794 return err 2795 } 2796 } 2797 2798 if len(v.ResourceType) > 0 { 2799 encoder.SetQuery("resourceType").String(string(v.ResourceType)) 2800 } 2801 2802 return nil 2803} 2804 2805type awsRestjson1_serializeOpDisassociateLambdaFunction struct { 2806} 2807 2808func (*awsRestjson1_serializeOpDisassociateLambdaFunction) ID() string { 2809 return "OperationSerializer" 2810} 2811 2812func (m *awsRestjson1_serializeOpDisassociateLambdaFunction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2813 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2814) { 2815 request, ok := in.Request.(*smithyhttp.Request) 2816 if !ok { 2817 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2818 } 2819 2820 input, ok := in.Parameters.(*DisassociateLambdaFunctionInput) 2821 _ = input 2822 if !ok { 2823 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2824 } 2825 2826 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/lambda-function") 2827 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2828 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2829 request.Method = "DELETE" 2830 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2831 if err != nil { 2832 return out, metadata, &smithy.SerializationError{Err: err} 2833 } 2834 2835 if err := awsRestjson1_serializeOpHttpBindingsDisassociateLambdaFunctionInput(input, restEncoder); err != nil { 2836 return out, metadata, &smithy.SerializationError{Err: err} 2837 } 2838 2839 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2840 return out, metadata, &smithy.SerializationError{Err: err} 2841 } 2842 in.Request = request 2843 2844 return next.HandleSerialize(ctx, in) 2845} 2846func awsRestjson1_serializeOpHttpBindingsDisassociateLambdaFunctionInput(v *DisassociateLambdaFunctionInput, encoder *httpbinding.Encoder) error { 2847 if v == nil { 2848 return fmt.Errorf("unsupported serialization of nil %T", v) 2849 } 2850 2851 if v.FunctionArn != nil { 2852 encoder.SetQuery("functionArn").String(*v.FunctionArn) 2853 } 2854 2855 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2856 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2857 } 2858 if v.InstanceId != nil { 2859 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2860 return err 2861 } 2862 } 2863 2864 return nil 2865} 2866 2867type awsRestjson1_serializeOpDisassociateLexBot struct { 2868} 2869 2870func (*awsRestjson1_serializeOpDisassociateLexBot) ID() string { 2871 return "OperationSerializer" 2872} 2873 2874func (m *awsRestjson1_serializeOpDisassociateLexBot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2875 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2876) { 2877 request, ok := in.Request.(*smithyhttp.Request) 2878 if !ok { 2879 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2880 } 2881 2882 input, ok := in.Parameters.(*DisassociateLexBotInput) 2883 _ = input 2884 if !ok { 2885 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2886 } 2887 2888 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/lex-bot") 2889 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2890 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2891 request.Method = "DELETE" 2892 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2893 if err != nil { 2894 return out, metadata, &smithy.SerializationError{Err: err} 2895 } 2896 2897 if err := awsRestjson1_serializeOpHttpBindingsDisassociateLexBotInput(input, restEncoder); err != nil { 2898 return out, metadata, &smithy.SerializationError{Err: err} 2899 } 2900 2901 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2902 return out, metadata, &smithy.SerializationError{Err: err} 2903 } 2904 in.Request = request 2905 2906 return next.HandleSerialize(ctx, in) 2907} 2908func awsRestjson1_serializeOpHttpBindingsDisassociateLexBotInput(v *DisassociateLexBotInput, encoder *httpbinding.Encoder) error { 2909 if v == nil { 2910 return fmt.Errorf("unsupported serialization of nil %T", v) 2911 } 2912 2913 if v.BotName != nil { 2914 encoder.SetQuery("botName").String(*v.BotName) 2915 } 2916 2917 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2918 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2919 } 2920 if v.InstanceId != nil { 2921 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2922 return err 2923 } 2924 } 2925 2926 if v.LexRegion != nil { 2927 encoder.SetQuery("lexRegion").String(*v.LexRegion) 2928 } 2929 2930 return nil 2931} 2932 2933type awsRestjson1_serializeOpDisassociateQueueQuickConnects struct { 2934} 2935 2936func (*awsRestjson1_serializeOpDisassociateQueueQuickConnects) ID() string { 2937 return "OperationSerializer" 2938} 2939 2940func (m *awsRestjson1_serializeOpDisassociateQueueQuickConnects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2941 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2942) { 2943 request, ok := in.Request.(*smithyhttp.Request) 2944 if !ok { 2945 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2946 } 2947 2948 input, ok := in.Parameters.(*DisassociateQueueQuickConnectsInput) 2949 _ = input 2950 if !ok { 2951 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2952 } 2953 2954 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/disassociate-quick-connects") 2955 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2956 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2957 request.Method = "POST" 2958 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2959 if err != nil { 2960 return out, metadata, &smithy.SerializationError{Err: err} 2961 } 2962 2963 if err := awsRestjson1_serializeOpHttpBindingsDisassociateQueueQuickConnectsInput(input, restEncoder); err != nil { 2964 return out, metadata, &smithy.SerializationError{Err: err} 2965 } 2966 2967 restEncoder.SetHeader("Content-Type").String("application/json") 2968 2969 jsonEncoder := smithyjson.NewEncoder() 2970 if err := awsRestjson1_serializeOpDocumentDisassociateQueueQuickConnectsInput(input, jsonEncoder.Value); err != nil { 2971 return out, metadata, &smithy.SerializationError{Err: err} 2972 } 2973 2974 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2975 return out, metadata, &smithy.SerializationError{Err: err} 2976 } 2977 2978 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2979 return out, metadata, &smithy.SerializationError{Err: err} 2980 } 2981 in.Request = request 2982 2983 return next.HandleSerialize(ctx, in) 2984} 2985func awsRestjson1_serializeOpHttpBindingsDisassociateQueueQuickConnectsInput(v *DisassociateQueueQuickConnectsInput, encoder *httpbinding.Encoder) error { 2986 if v == nil { 2987 return fmt.Errorf("unsupported serialization of nil %T", v) 2988 } 2989 2990 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 2991 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 2992 } 2993 if v.InstanceId != nil { 2994 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 2995 return err 2996 } 2997 } 2998 2999 if v.QueueId == nil || len(*v.QueueId) == 0 { 3000 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 3001 } 3002 if v.QueueId != nil { 3003 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 3004 return err 3005 } 3006 } 3007 3008 return nil 3009} 3010 3011func awsRestjson1_serializeOpDocumentDisassociateQueueQuickConnectsInput(v *DisassociateQueueQuickConnectsInput, value smithyjson.Value) error { 3012 object := value.Object() 3013 defer object.Close() 3014 3015 if v.QuickConnectIds != nil { 3016 ok := object.Key("QuickConnectIds") 3017 if err := awsRestjson1_serializeDocumentQuickConnectsList(v.QuickConnectIds, ok); err != nil { 3018 return err 3019 } 3020 } 3021 3022 return nil 3023} 3024 3025type awsRestjson1_serializeOpDisassociateRoutingProfileQueues struct { 3026} 3027 3028func (*awsRestjson1_serializeOpDisassociateRoutingProfileQueues) ID() string { 3029 return "OperationSerializer" 3030} 3031 3032func (m *awsRestjson1_serializeOpDisassociateRoutingProfileQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3033 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3034) { 3035 request, ok := in.Request.(*smithyhttp.Request) 3036 if !ok { 3037 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3038 } 3039 3040 input, ok := in.Parameters.(*DisassociateRoutingProfileQueuesInput) 3041 _ = input 3042 if !ok { 3043 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3044 } 3045 3046 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}/disassociate-queues") 3047 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3048 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3049 request.Method = "POST" 3050 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3051 if err != nil { 3052 return out, metadata, &smithy.SerializationError{Err: err} 3053 } 3054 3055 if err := awsRestjson1_serializeOpHttpBindingsDisassociateRoutingProfileQueuesInput(input, restEncoder); err != nil { 3056 return out, metadata, &smithy.SerializationError{Err: err} 3057 } 3058 3059 restEncoder.SetHeader("Content-Type").String("application/json") 3060 3061 jsonEncoder := smithyjson.NewEncoder() 3062 if err := awsRestjson1_serializeOpDocumentDisassociateRoutingProfileQueuesInput(input, jsonEncoder.Value); err != nil { 3063 return out, metadata, &smithy.SerializationError{Err: err} 3064 } 3065 3066 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3067 return out, metadata, &smithy.SerializationError{Err: err} 3068 } 3069 3070 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3071 return out, metadata, &smithy.SerializationError{Err: err} 3072 } 3073 in.Request = request 3074 3075 return next.HandleSerialize(ctx, in) 3076} 3077func awsRestjson1_serializeOpHttpBindingsDisassociateRoutingProfileQueuesInput(v *DisassociateRoutingProfileQueuesInput, encoder *httpbinding.Encoder) error { 3078 if v == nil { 3079 return fmt.Errorf("unsupported serialization of nil %T", v) 3080 } 3081 3082 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3083 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3084 } 3085 if v.InstanceId != nil { 3086 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3087 return err 3088 } 3089 } 3090 3091 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 3092 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 3093 } 3094 if v.RoutingProfileId != nil { 3095 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 3096 return err 3097 } 3098 } 3099 3100 return nil 3101} 3102 3103func awsRestjson1_serializeOpDocumentDisassociateRoutingProfileQueuesInput(v *DisassociateRoutingProfileQueuesInput, value smithyjson.Value) error { 3104 object := value.Object() 3105 defer object.Close() 3106 3107 if v.QueueReferences != nil { 3108 ok := object.Key("QueueReferences") 3109 if err := awsRestjson1_serializeDocumentRoutingProfileQueueReferenceList(v.QueueReferences, ok); err != nil { 3110 return err 3111 } 3112 } 3113 3114 return nil 3115} 3116 3117type awsRestjson1_serializeOpDisassociateSecurityKey struct { 3118} 3119 3120func (*awsRestjson1_serializeOpDisassociateSecurityKey) ID() string { 3121 return "OperationSerializer" 3122} 3123 3124func (m *awsRestjson1_serializeOpDisassociateSecurityKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3125 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3126) { 3127 request, ok := in.Request.(*smithyhttp.Request) 3128 if !ok { 3129 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3130 } 3131 3132 input, ok := in.Parameters.(*DisassociateSecurityKeyInput) 3133 _ = input 3134 if !ok { 3135 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3136 } 3137 3138 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/security-key/{AssociationId}") 3139 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3140 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3141 request.Method = "DELETE" 3142 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3143 if err != nil { 3144 return out, metadata, &smithy.SerializationError{Err: err} 3145 } 3146 3147 if err := awsRestjson1_serializeOpHttpBindingsDisassociateSecurityKeyInput(input, restEncoder); err != nil { 3148 return out, metadata, &smithy.SerializationError{Err: err} 3149 } 3150 3151 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3152 return out, metadata, &smithy.SerializationError{Err: err} 3153 } 3154 in.Request = request 3155 3156 return next.HandleSerialize(ctx, in) 3157} 3158func awsRestjson1_serializeOpHttpBindingsDisassociateSecurityKeyInput(v *DisassociateSecurityKeyInput, encoder *httpbinding.Encoder) error { 3159 if v == nil { 3160 return fmt.Errorf("unsupported serialization of nil %T", v) 3161 } 3162 3163 if v.AssociationId == nil || len(*v.AssociationId) == 0 { 3164 return &smithy.SerializationError{Err: fmt.Errorf("input member AssociationId must not be empty")} 3165 } 3166 if v.AssociationId != nil { 3167 if err := encoder.SetURI("AssociationId").String(*v.AssociationId); err != nil { 3168 return err 3169 } 3170 } 3171 3172 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3173 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3174 } 3175 if v.InstanceId != nil { 3176 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3177 return err 3178 } 3179 } 3180 3181 return nil 3182} 3183 3184type awsRestjson1_serializeOpGetContactAttributes struct { 3185} 3186 3187func (*awsRestjson1_serializeOpGetContactAttributes) ID() string { 3188 return "OperationSerializer" 3189} 3190 3191func (m *awsRestjson1_serializeOpGetContactAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3192 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3193) { 3194 request, ok := in.Request.(*smithyhttp.Request) 3195 if !ok { 3196 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3197 } 3198 3199 input, ok := in.Parameters.(*GetContactAttributesInput) 3200 _ = input 3201 if !ok { 3202 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3203 } 3204 3205 opPath, opQuery := httpbinding.SplitURI("/contact/attributes/{InstanceId}/{InitialContactId}") 3206 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3207 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3208 request.Method = "GET" 3209 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3210 if err != nil { 3211 return out, metadata, &smithy.SerializationError{Err: err} 3212 } 3213 3214 if err := awsRestjson1_serializeOpHttpBindingsGetContactAttributesInput(input, restEncoder); err != nil { 3215 return out, metadata, &smithy.SerializationError{Err: err} 3216 } 3217 3218 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3219 return out, metadata, &smithy.SerializationError{Err: err} 3220 } 3221 in.Request = request 3222 3223 return next.HandleSerialize(ctx, in) 3224} 3225func awsRestjson1_serializeOpHttpBindingsGetContactAttributesInput(v *GetContactAttributesInput, encoder *httpbinding.Encoder) error { 3226 if v == nil { 3227 return fmt.Errorf("unsupported serialization of nil %T", v) 3228 } 3229 3230 if v.InitialContactId == nil || len(*v.InitialContactId) == 0 { 3231 return &smithy.SerializationError{Err: fmt.Errorf("input member InitialContactId must not be empty")} 3232 } 3233 if v.InitialContactId != nil { 3234 if err := encoder.SetURI("InitialContactId").String(*v.InitialContactId); err != nil { 3235 return err 3236 } 3237 } 3238 3239 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3240 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3241 } 3242 if v.InstanceId != nil { 3243 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3244 return err 3245 } 3246 } 3247 3248 return nil 3249} 3250 3251type awsRestjson1_serializeOpGetCurrentMetricData struct { 3252} 3253 3254func (*awsRestjson1_serializeOpGetCurrentMetricData) ID() string { 3255 return "OperationSerializer" 3256} 3257 3258func (m *awsRestjson1_serializeOpGetCurrentMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3259 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3260) { 3261 request, ok := in.Request.(*smithyhttp.Request) 3262 if !ok { 3263 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3264 } 3265 3266 input, ok := in.Parameters.(*GetCurrentMetricDataInput) 3267 _ = input 3268 if !ok { 3269 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3270 } 3271 3272 opPath, opQuery := httpbinding.SplitURI("/metrics/current/{InstanceId}") 3273 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3274 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3275 request.Method = "POST" 3276 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3277 if err != nil { 3278 return out, metadata, &smithy.SerializationError{Err: err} 3279 } 3280 3281 if err := awsRestjson1_serializeOpHttpBindingsGetCurrentMetricDataInput(input, restEncoder); err != nil { 3282 return out, metadata, &smithy.SerializationError{Err: err} 3283 } 3284 3285 restEncoder.SetHeader("Content-Type").String("application/json") 3286 3287 jsonEncoder := smithyjson.NewEncoder() 3288 if err := awsRestjson1_serializeOpDocumentGetCurrentMetricDataInput(input, jsonEncoder.Value); err != nil { 3289 return out, metadata, &smithy.SerializationError{Err: err} 3290 } 3291 3292 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3293 return out, metadata, &smithy.SerializationError{Err: err} 3294 } 3295 3296 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3297 return out, metadata, &smithy.SerializationError{Err: err} 3298 } 3299 in.Request = request 3300 3301 return next.HandleSerialize(ctx, in) 3302} 3303func awsRestjson1_serializeOpHttpBindingsGetCurrentMetricDataInput(v *GetCurrentMetricDataInput, encoder *httpbinding.Encoder) error { 3304 if v == nil { 3305 return fmt.Errorf("unsupported serialization of nil %T", v) 3306 } 3307 3308 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3309 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3310 } 3311 if v.InstanceId != nil { 3312 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3313 return err 3314 } 3315 } 3316 3317 return nil 3318} 3319 3320func awsRestjson1_serializeOpDocumentGetCurrentMetricDataInput(v *GetCurrentMetricDataInput, value smithyjson.Value) error { 3321 object := value.Object() 3322 defer object.Close() 3323 3324 if v.CurrentMetrics != nil { 3325 ok := object.Key("CurrentMetrics") 3326 if err := awsRestjson1_serializeDocumentCurrentMetrics(v.CurrentMetrics, ok); err != nil { 3327 return err 3328 } 3329 } 3330 3331 if v.Filters != nil { 3332 ok := object.Key("Filters") 3333 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3334 return err 3335 } 3336 } 3337 3338 if v.Groupings != nil { 3339 ok := object.Key("Groupings") 3340 if err := awsRestjson1_serializeDocumentGroupings(v.Groupings, ok); err != nil { 3341 return err 3342 } 3343 } 3344 3345 if v.MaxResults != 0 { 3346 ok := object.Key("MaxResults") 3347 ok.Integer(v.MaxResults) 3348 } 3349 3350 if v.NextToken != nil { 3351 ok := object.Key("NextToken") 3352 ok.String(*v.NextToken) 3353 } 3354 3355 return nil 3356} 3357 3358type awsRestjson1_serializeOpGetFederationToken struct { 3359} 3360 3361func (*awsRestjson1_serializeOpGetFederationToken) ID() string { 3362 return "OperationSerializer" 3363} 3364 3365func (m *awsRestjson1_serializeOpGetFederationToken) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3366 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3367) { 3368 request, ok := in.Request.(*smithyhttp.Request) 3369 if !ok { 3370 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3371 } 3372 3373 input, ok := in.Parameters.(*GetFederationTokenInput) 3374 _ = input 3375 if !ok { 3376 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3377 } 3378 3379 opPath, opQuery := httpbinding.SplitURI("/user/federate/{InstanceId}") 3380 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3381 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3382 request.Method = "GET" 3383 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3384 if err != nil { 3385 return out, metadata, &smithy.SerializationError{Err: err} 3386 } 3387 3388 if err := awsRestjson1_serializeOpHttpBindingsGetFederationTokenInput(input, restEncoder); err != nil { 3389 return out, metadata, &smithy.SerializationError{Err: err} 3390 } 3391 3392 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3393 return out, metadata, &smithy.SerializationError{Err: err} 3394 } 3395 in.Request = request 3396 3397 return next.HandleSerialize(ctx, in) 3398} 3399func awsRestjson1_serializeOpHttpBindingsGetFederationTokenInput(v *GetFederationTokenInput, encoder *httpbinding.Encoder) error { 3400 if v == nil { 3401 return fmt.Errorf("unsupported serialization of nil %T", v) 3402 } 3403 3404 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3405 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3406 } 3407 if v.InstanceId != nil { 3408 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3409 return err 3410 } 3411 } 3412 3413 return nil 3414} 3415 3416type awsRestjson1_serializeOpGetMetricData struct { 3417} 3418 3419func (*awsRestjson1_serializeOpGetMetricData) ID() string { 3420 return "OperationSerializer" 3421} 3422 3423func (m *awsRestjson1_serializeOpGetMetricData) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3424 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3425) { 3426 request, ok := in.Request.(*smithyhttp.Request) 3427 if !ok { 3428 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3429 } 3430 3431 input, ok := in.Parameters.(*GetMetricDataInput) 3432 _ = input 3433 if !ok { 3434 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3435 } 3436 3437 opPath, opQuery := httpbinding.SplitURI("/metrics/historical/{InstanceId}") 3438 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3439 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3440 request.Method = "POST" 3441 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3442 if err != nil { 3443 return out, metadata, &smithy.SerializationError{Err: err} 3444 } 3445 3446 if err := awsRestjson1_serializeOpHttpBindingsGetMetricDataInput(input, restEncoder); err != nil { 3447 return out, metadata, &smithy.SerializationError{Err: err} 3448 } 3449 3450 restEncoder.SetHeader("Content-Type").String("application/json") 3451 3452 jsonEncoder := smithyjson.NewEncoder() 3453 if err := awsRestjson1_serializeOpDocumentGetMetricDataInput(input, jsonEncoder.Value); err != nil { 3454 return out, metadata, &smithy.SerializationError{Err: err} 3455 } 3456 3457 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3458 return out, metadata, &smithy.SerializationError{Err: err} 3459 } 3460 3461 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3462 return out, metadata, &smithy.SerializationError{Err: err} 3463 } 3464 in.Request = request 3465 3466 return next.HandleSerialize(ctx, in) 3467} 3468func awsRestjson1_serializeOpHttpBindingsGetMetricDataInput(v *GetMetricDataInput, encoder *httpbinding.Encoder) error { 3469 if v == nil { 3470 return fmt.Errorf("unsupported serialization of nil %T", v) 3471 } 3472 3473 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3474 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3475 } 3476 if v.InstanceId != nil { 3477 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3478 return err 3479 } 3480 } 3481 3482 return nil 3483} 3484 3485func awsRestjson1_serializeOpDocumentGetMetricDataInput(v *GetMetricDataInput, value smithyjson.Value) error { 3486 object := value.Object() 3487 defer object.Close() 3488 3489 if v.EndTime != nil { 3490 ok := object.Key("EndTime") 3491 ok.Double(smithytime.FormatEpochSeconds(*v.EndTime)) 3492 } 3493 3494 if v.Filters != nil { 3495 ok := object.Key("Filters") 3496 if err := awsRestjson1_serializeDocumentFilters(v.Filters, ok); err != nil { 3497 return err 3498 } 3499 } 3500 3501 if v.Groupings != nil { 3502 ok := object.Key("Groupings") 3503 if err := awsRestjson1_serializeDocumentGroupings(v.Groupings, ok); err != nil { 3504 return err 3505 } 3506 } 3507 3508 if v.HistoricalMetrics != nil { 3509 ok := object.Key("HistoricalMetrics") 3510 if err := awsRestjson1_serializeDocumentHistoricalMetrics(v.HistoricalMetrics, ok); err != nil { 3511 return err 3512 } 3513 } 3514 3515 if v.MaxResults != 0 { 3516 ok := object.Key("MaxResults") 3517 ok.Integer(v.MaxResults) 3518 } 3519 3520 if v.NextToken != nil { 3521 ok := object.Key("NextToken") 3522 ok.String(*v.NextToken) 3523 } 3524 3525 if v.StartTime != nil { 3526 ok := object.Key("StartTime") 3527 ok.Double(smithytime.FormatEpochSeconds(*v.StartTime)) 3528 } 3529 3530 return nil 3531} 3532 3533type awsRestjson1_serializeOpListApprovedOrigins struct { 3534} 3535 3536func (*awsRestjson1_serializeOpListApprovedOrigins) ID() string { 3537 return "OperationSerializer" 3538} 3539 3540func (m *awsRestjson1_serializeOpListApprovedOrigins) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3541 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3542) { 3543 request, ok := in.Request.(*smithyhttp.Request) 3544 if !ok { 3545 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3546 } 3547 3548 input, ok := in.Parameters.(*ListApprovedOriginsInput) 3549 _ = input 3550 if !ok { 3551 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3552 } 3553 3554 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/approved-origins") 3555 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3556 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3557 request.Method = "GET" 3558 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3559 if err != nil { 3560 return out, metadata, &smithy.SerializationError{Err: err} 3561 } 3562 3563 if err := awsRestjson1_serializeOpHttpBindingsListApprovedOriginsInput(input, restEncoder); err != nil { 3564 return out, metadata, &smithy.SerializationError{Err: err} 3565 } 3566 3567 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3568 return out, metadata, &smithy.SerializationError{Err: err} 3569 } 3570 in.Request = request 3571 3572 return next.HandleSerialize(ctx, in) 3573} 3574func awsRestjson1_serializeOpHttpBindingsListApprovedOriginsInput(v *ListApprovedOriginsInput, encoder *httpbinding.Encoder) error { 3575 if v == nil { 3576 return fmt.Errorf("unsupported serialization of nil %T", v) 3577 } 3578 3579 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3580 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3581 } 3582 if v.InstanceId != nil { 3583 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3584 return err 3585 } 3586 } 3587 3588 if v.MaxResults != 0 { 3589 encoder.SetQuery("maxResults").Integer(v.MaxResults) 3590 } 3591 3592 if v.NextToken != nil { 3593 encoder.SetQuery("nextToken").String(*v.NextToken) 3594 } 3595 3596 return nil 3597} 3598 3599type awsRestjson1_serializeOpListContactFlows struct { 3600} 3601 3602func (*awsRestjson1_serializeOpListContactFlows) ID() string { 3603 return "OperationSerializer" 3604} 3605 3606func (m *awsRestjson1_serializeOpListContactFlows) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3607 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3608) { 3609 request, ok := in.Request.(*smithyhttp.Request) 3610 if !ok { 3611 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3612 } 3613 3614 input, ok := in.Parameters.(*ListContactFlowsInput) 3615 _ = input 3616 if !ok { 3617 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3618 } 3619 3620 opPath, opQuery := httpbinding.SplitURI("/contact-flows-summary/{InstanceId}") 3621 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3622 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3623 request.Method = "GET" 3624 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3625 if err != nil { 3626 return out, metadata, &smithy.SerializationError{Err: err} 3627 } 3628 3629 if err := awsRestjson1_serializeOpHttpBindingsListContactFlowsInput(input, restEncoder); err != nil { 3630 return out, metadata, &smithy.SerializationError{Err: err} 3631 } 3632 3633 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3634 return out, metadata, &smithy.SerializationError{Err: err} 3635 } 3636 in.Request = request 3637 3638 return next.HandleSerialize(ctx, in) 3639} 3640func awsRestjson1_serializeOpHttpBindingsListContactFlowsInput(v *ListContactFlowsInput, encoder *httpbinding.Encoder) error { 3641 if v == nil { 3642 return fmt.Errorf("unsupported serialization of nil %T", v) 3643 } 3644 3645 if v.ContactFlowTypes != nil { 3646 for i := range v.ContactFlowTypes { 3647 encoder.AddQuery("contactFlowTypes").String(string(v.ContactFlowTypes[i])) 3648 } 3649 } 3650 3651 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3652 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3653 } 3654 if v.InstanceId != nil { 3655 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3656 return err 3657 } 3658 } 3659 3660 if v.MaxResults != 0 { 3661 encoder.SetQuery("maxResults").Integer(v.MaxResults) 3662 } 3663 3664 if v.NextToken != nil { 3665 encoder.SetQuery("nextToken").String(*v.NextToken) 3666 } 3667 3668 return nil 3669} 3670 3671type awsRestjson1_serializeOpListHoursOfOperations struct { 3672} 3673 3674func (*awsRestjson1_serializeOpListHoursOfOperations) ID() string { 3675 return "OperationSerializer" 3676} 3677 3678func (m *awsRestjson1_serializeOpListHoursOfOperations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3679 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3680) { 3681 request, ok := in.Request.(*smithyhttp.Request) 3682 if !ok { 3683 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3684 } 3685 3686 input, ok := in.Parameters.(*ListHoursOfOperationsInput) 3687 _ = input 3688 if !ok { 3689 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3690 } 3691 3692 opPath, opQuery := httpbinding.SplitURI("/hours-of-operations-summary/{InstanceId}") 3693 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3694 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3695 request.Method = "GET" 3696 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3697 if err != nil { 3698 return out, metadata, &smithy.SerializationError{Err: err} 3699 } 3700 3701 if err := awsRestjson1_serializeOpHttpBindingsListHoursOfOperationsInput(input, restEncoder); err != nil { 3702 return out, metadata, &smithy.SerializationError{Err: err} 3703 } 3704 3705 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3706 return out, metadata, &smithy.SerializationError{Err: err} 3707 } 3708 in.Request = request 3709 3710 return next.HandleSerialize(ctx, in) 3711} 3712func awsRestjson1_serializeOpHttpBindingsListHoursOfOperationsInput(v *ListHoursOfOperationsInput, encoder *httpbinding.Encoder) error { 3713 if v == nil { 3714 return fmt.Errorf("unsupported serialization of nil %T", v) 3715 } 3716 3717 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3718 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3719 } 3720 if v.InstanceId != nil { 3721 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3722 return err 3723 } 3724 } 3725 3726 if v.MaxResults != 0 { 3727 encoder.SetQuery("maxResults").Integer(v.MaxResults) 3728 } 3729 3730 if v.NextToken != nil { 3731 encoder.SetQuery("nextToken").String(*v.NextToken) 3732 } 3733 3734 return nil 3735} 3736 3737type awsRestjson1_serializeOpListInstanceAttributes struct { 3738} 3739 3740func (*awsRestjson1_serializeOpListInstanceAttributes) ID() string { 3741 return "OperationSerializer" 3742} 3743 3744func (m *awsRestjson1_serializeOpListInstanceAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3745 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3746) { 3747 request, ok := in.Request.(*smithyhttp.Request) 3748 if !ok { 3749 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3750 } 3751 3752 input, ok := in.Parameters.(*ListInstanceAttributesInput) 3753 _ = input 3754 if !ok { 3755 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3756 } 3757 3758 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/attributes") 3759 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3760 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3761 request.Method = "GET" 3762 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3763 if err != nil { 3764 return out, metadata, &smithy.SerializationError{Err: err} 3765 } 3766 3767 if err := awsRestjson1_serializeOpHttpBindingsListInstanceAttributesInput(input, restEncoder); err != nil { 3768 return out, metadata, &smithy.SerializationError{Err: err} 3769 } 3770 3771 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3772 return out, metadata, &smithy.SerializationError{Err: err} 3773 } 3774 in.Request = request 3775 3776 return next.HandleSerialize(ctx, in) 3777} 3778func awsRestjson1_serializeOpHttpBindingsListInstanceAttributesInput(v *ListInstanceAttributesInput, encoder *httpbinding.Encoder) error { 3779 if v == nil { 3780 return fmt.Errorf("unsupported serialization of nil %T", v) 3781 } 3782 3783 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3784 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3785 } 3786 if v.InstanceId != nil { 3787 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3788 return err 3789 } 3790 } 3791 3792 if v.MaxResults != 0 { 3793 encoder.SetQuery("maxResults").Integer(v.MaxResults) 3794 } 3795 3796 if v.NextToken != nil { 3797 encoder.SetQuery("nextToken").String(*v.NextToken) 3798 } 3799 3800 return nil 3801} 3802 3803type awsRestjson1_serializeOpListInstances struct { 3804} 3805 3806func (*awsRestjson1_serializeOpListInstances) ID() string { 3807 return "OperationSerializer" 3808} 3809 3810func (m *awsRestjson1_serializeOpListInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3811 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3812) { 3813 request, ok := in.Request.(*smithyhttp.Request) 3814 if !ok { 3815 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3816 } 3817 3818 input, ok := in.Parameters.(*ListInstancesInput) 3819 _ = input 3820 if !ok { 3821 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3822 } 3823 3824 opPath, opQuery := httpbinding.SplitURI("/instance") 3825 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3826 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3827 request.Method = "GET" 3828 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3829 if err != nil { 3830 return out, metadata, &smithy.SerializationError{Err: err} 3831 } 3832 3833 if err := awsRestjson1_serializeOpHttpBindingsListInstancesInput(input, restEncoder); err != nil { 3834 return out, metadata, &smithy.SerializationError{Err: err} 3835 } 3836 3837 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3838 return out, metadata, &smithy.SerializationError{Err: err} 3839 } 3840 in.Request = request 3841 3842 return next.HandleSerialize(ctx, in) 3843} 3844func awsRestjson1_serializeOpHttpBindingsListInstancesInput(v *ListInstancesInput, encoder *httpbinding.Encoder) error { 3845 if v == nil { 3846 return fmt.Errorf("unsupported serialization of nil %T", v) 3847 } 3848 3849 if v.MaxResults != 0 { 3850 encoder.SetQuery("maxResults").Integer(v.MaxResults) 3851 } 3852 3853 if v.NextToken != nil { 3854 encoder.SetQuery("nextToken").String(*v.NextToken) 3855 } 3856 3857 return nil 3858} 3859 3860type awsRestjson1_serializeOpListInstanceStorageConfigs struct { 3861} 3862 3863func (*awsRestjson1_serializeOpListInstanceStorageConfigs) ID() string { 3864 return "OperationSerializer" 3865} 3866 3867func (m *awsRestjson1_serializeOpListInstanceStorageConfigs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3868 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3869) { 3870 request, ok := in.Request.(*smithyhttp.Request) 3871 if !ok { 3872 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3873 } 3874 3875 input, ok := in.Parameters.(*ListInstanceStorageConfigsInput) 3876 _ = input 3877 if !ok { 3878 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3879 } 3880 3881 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/storage-configs") 3882 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3883 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3884 request.Method = "GET" 3885 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3886 if err != nil { 3887 return out, metadata, &smithy.SerializationError{Err: err} 3888 } 3889 3890 if err := awsRestjson1_serializeOpHttpBindingsListInstanceStorageConfigsInput(input, restEncoder); err != nil { 3891 return out, metadata, &smithy.SerializationError{Err: err} 3892 } 3893 3894 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3895 return out, metadata, &smithy.SerializationError{Err: err} 3896 } 3897 in.Request = request 3898 3899 return next.HandleSerialize(ctx, in) 3900} 3901func awsRestjson1_serializeOpHttpBindingsListInstanceStorageConfigsInput(v *ListInstanceStorageConfigsInput, encoder *httpbinding.Encoder) error { 3902 if v == nil { 3903 return fmt.Errorf("unsupported serialization of nil %T", v) 3904 } 3905 3906 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3907 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3908 } 3909 if v.InstanceId != nil { 3910 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3911 return err 3912 } 3913 } 3914 3915 if v.MaxResults != 0 { 3916 encoder.SetQuery("maxResults").Integer(v.MaxResults) 3917 } 3918 3919 if v.NextToken != nil { 3920 encoder.SetQuery("nextToken").String(*v.NextToken) 3921 } 3922 3923 if len(v.ResourceType) > 0 { 3924 encoder.SetQuery("resourceType").String(string(v.ResourceType)) 3925 } 3926 3927 return nil 3928} 3929 3930type awsRestjson1_serializeOpListIntegrationAssociations struct { 3931} 3932 3933func (*awsRestjson1_serializeOpListIntegrationAssociations) ID() string { 3934 return "OperationSerializer" 3935} 3936 3937func (m *awsRestjson1_serializeOpListIntegrationAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3938 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3939) { 3940 request, ok := in.Request.(*smithyhttp.Request) 3941 if !ok { 3942 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3943 } 3944 3945 input, ok := in.Parameters.(*ListIntegrationAssociationsInput) 3946 _ = input 3947 if !ok { 3948 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3949 } 3950 3951 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/integration-associations") 3952 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3953 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3954 request.Method = "GET" 3955 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3956 if err != nil { 3957 return out, metadata, &smithy.SerializationError{Err: err} 3958 } 3959 3960 if err := awsRestjson1_serializeOpHttpBindingsListIntegrationAssociationsInput(input, restEncoder); err != nil { 3961 return out, metadata, &smithy.SerializationError{Err: err} 3962 } 3963 3964 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3965 return out, metadata, &smithy.SerializationError{Err: err} 3966 } 3967 in.Request = request 3968 3969 return next.HandleSerialize(ctx, in) 3970} 3971func awsRestjson1_serializeOpHttpBindingsListIntegrationAssociationsInput(v *ListIntegrationAssociationsInput, encoder *httpbinding.Encoder) error { 3972 if v == nil { 3973 return fmt.Errorf("unsupported serialization of nil %T", v) 3974 } 3975 3976 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 3977 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 3978 } 3979 if v.InstanceId != nil { 3980 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 3981 return err 3982 } 3983 } 3984 3985 if v.MaxResults != 0 { 3986 encoder.SetQuery("maxResults").Integer(v.MaxResults) 3987 } 3988 3989 if v.NextToken != nil { 3990 encoder.SetQuery("nextToken").String(*v.NextToken) 3991 } 3992 3993 return nil 3994} 3995 3996type awsRestjson1_serializeOpListLambdaFunctions struct { 3997} 3998 3999func (*awsRestjson1_serializeOpListLambdaFunctions) ID() string { 4000 return "OperationSerializer" 4001} 4002 4003func (m *awsRestjson1_serializeOpListLambdaFunctions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4004 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4005) { 4006 request, ok := in.Request.(*smithyhttp.Request) 4007 if !ok { 4008 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4009 } 4010 4011 input, ok := in.Parameters.(*ListLambdaFunctionsInput) 4012 _ = input 4013 if !ok { 4014 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4015 } 4016 4017 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/lambda-functions") 4018 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4019 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4020 request.Method = "GET" 4021 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4022 if err != nil { 4023 return out, metadata, &smithy.SerializationError{Err: err} 4024 } 4025 4026 if err := awsRestjson1_serializeOpHttpBindingsListLambdaFunctionsInput(input, restEncoder); err != nil { 4027 return out, metadata, &smithy.SerializationError{Err: err} 4028 } 4029 4030 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4031 return out, metadata, &smithy.SerializationError{Err: err} 4032 } 4033 in.Request = request 4034 4035 return next.HandleSerialize(ctx, in) 4036} 4037func awsRestjson1_serializeOpHttpBindingsListLambdaFunctionsInput(v *ListLambdaFunctionsInput, encoder *httpbinding.Encoder) error { 4038 if v == nil { 4039 return fmt.Errorf("unsupported serialization of nil %T", v) 4040 } 4041 4042 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4043 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4044 } 4045 if v.InstanceId != nil { 4046 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4047 return err 4048 } 4049 } 4050 4051 if v.MaxResults != 0 { 4052 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4053 } 4054 4055 if v.NextToken != nil { 4056 encoder.SetQuery("nextToken").String(*v.NextToken) 4057 } 4058 4059 return nil 4060} 4061 4062type awsRestjson1_serializeOpListLexBots struct { 4063} 4064 4065func (*awsRestjson1_serializeOpListLexBots) ID() string { 4066 return "OperationSerializer" 4067} 4068 4069func (m *awsRestjson1_serializeOpListLexBots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4070 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4071) { 4072 request, ok := in.Request.(*smithyhttp.Request) 4073 if !ok { 4074 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4075 } 4076 4077 input, ok := in.Parameters.(*ListLexBotsInput) 4078 _ = input 4079 if !ok { 4080 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4081 } 4082 4083 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/lex-bots") 4084 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4085 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4086 request.Method = "GET" 4087 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4088 if err != nil { 4089 return out, metadata, &smithy.SerializationError{Err: err} 4090 } 4091 4092 if err := awsRestjson1_serializeOpHttpBindingsListLexBotsInput(input, restEncoder); err != nil { 4093 return out, metadata, &smithy.SerializationError{Err: err} 4094 } 4095 4096 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4097 return out, metadata, &smithy.SerializationError{Err: err} 4098 } 4099 in.Request = request 4100 4101 return next.HandleSerialize(ctx, in) 4102} 4103func awsRestjson1_serializeOpHttpBindingsListLexBotsInput(v *ListLexBotsInput, encoder *httpbinding.Encoder) error { 4104 if v == nil { 4105 return fmt.Errorf("unsupported serialization of nil %T", v) 4106 } 4107 4108 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4109 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4110 } 4111 if v.InstanceId != nil { 4112 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4113 return err 4114 } 4115 } 4116 4117 if v.MaxResults != 0 { 4118 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4119 } 4120 4121 if v.NextToken != nil { 4122 encoder.SetQuery("nextToken").String(*v.NextToken) 4123 } 4124 4125 return nil 4126} 4127 4128type awsRestjson1_serializeOpListPhoneNumbers struct { 4129} 4130 4131func (*awsRestjson1_serializeOpListPhoneNumbers) ID() string { 4132 return "OperationSerializer" 4133} 4134 4135func (m *awsRestjson1_serializeOpListPhoneNumbers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4136 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4137) { 4138 request, ok := in.Request.(*smithyhttp.Request) 4139 if !ok { 4140 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4141 } 4142 4143 input, ok := in.Parameters.(*ListPhoneNumbersInput) 4144 _ = input 4145 if !ok { 4146 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4147 } 4148 4149 opPath, opQuery := httpbinding.SplitURI("/phone-numbers-summary/{InstanceId}") 4150 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4151 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4152 request.Method = "GET" 4153 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4154 if err != nil { 4155 return out, metadata, &smithy.SerializationError{Err: err} 4156 } 4157 4158 if err := awsRestjson1_serializeOpHttpBindingsListPhoneNumbersInput(input, restEncoder); err != nil { 4159 return out, metadata, &smithy.SerializationError{Err: err} 4160 } 4161 4162 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4163 return out, metadata, &smithy.SerializationError{Err: err} 4164 } 4165 in.Request = request 4166 4167 return next.HandleSerialize(ctx, in) 4168} 4169func awsRestjson1_serializeOpHttpBindingsListPhoneNumbersInput(v *ListPhoneNumbersInput, encoder *httpbinding.Encoder) error { 4170 if v == nil { 4171 return fmt.Errorf("unsupported serialization of nil %T", v) 4172 } 4173 4174 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4175 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4176 } 4177 if v.InstanceId != nil { 4178 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4179 return err 4180 } 4181 } 4182 4183 if v.MaxResults != 0 { 4184 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4185 } 4186 4187 if v.NextToken != nil { 4188 encoder.SetQuery("nextToken").String(*v.NextToken) 4189 } 4190 4191 if v.PhoneNumberCountryCodes != nil { 4192 for i := range v.PhoneNumberCountryCodes { 4193 encoder.AddQuery("phoneNumberCountryCodes").String(string(v.PhoneNumberCountryCodes[i])) 4194 } 4195 } 4196 4197 if v.PhoneNumberTypes != nil { 4198 for i := range v.PhoneNumberTypes { 4199 encoder.AddQuery("phoneNumberTypes").String(string(v.PhoneNumberTypes[i])) 4200 } 4201 } 4202 4203 return nil 4204} 4205 4206type awsRestjson1_serializeOpListPrompts struct { 4207} 4208 4209func (*awsRestjson1_serializeOpListPrompts) ID() string { 4210 return "OperationSerializer" 4211} 4212 4213func (m *awsRestjson1_serializeOpListPrompts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4214 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4215) { 4216 request, ok := in.Request.(*smithyhttp.Request) 4217 if !ok { 4218 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4219 } 4220 4221 input, ok := in.Parameters.(*ListPromptsInput) 4222 _ = input 4223 if !ok { 4224 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4225 } 4226 4227 opPath, opQuery := httpbinding.SplitURI("/prompts-summary/{InstanceId}") 4228 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4229 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4230 request.Method = "GET" 4231 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4232 if err != nil { 4233 return out, metadata, &smithy.SerializationError{Err: err} 4234 } 4235 4236 if err := awsRestjson1_serializeOpHttpBindingsListPromptsInput(input, restEncoder); err != nil { 4237 return out, metadata, &smithy.SerializationError{Err: err} 4238 } 4239 4240 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4241 return out, metadata, &smithy.SerializationError{Err: err} 4242 } 4243 in.Request = request 4244 4245 return next.HandleSerialize(ctx, in) 4246} 4247func awsRestjson1_serializeOpHttpBindingsListPromptsInput(v *ListPromptsInput, encoder *httpbinding.Encoder) error { 4248 if v == nil { 4249 return fmt.Errorf("unsupported serialization of nil %T", v) 4250 } 4251 4252 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4253 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4254 } 4255 if v.InstanceId != nil { 4256 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4257 return err 4258 } 4259 } 4260 4261 if v.MaxResults != 0 { 4262 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4263 } 4264 4265 if v.NextToken != nil { 4266 encoder.SetQuery("nextToken").String(*v.NextToken) 4267 } 4268 4269 return nil 4270} 4271 4272type awsRestjson1_serializeOpListQueueQuickConnects struct { 4273} 4274 4275func (*awsRestjson1_serializeOpListQueueQuickConnects) ID() string { 4276 return "OperationSerializer" 4277} 4278 4279func (m *awsRestjson1_serializeOpListQueueQuickConnects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4280 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4281) { 4282 request, ok := in.Request.(*smithyhttp.Request) 4283 if !ok { 4284 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4285 } 4286 4287 input, ok := in.Parameters.(*ListQueueQuickConnectsInput) 4288 _ = input 4289 if !ok { 4290 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4291 } 4292 4293 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/quick-connects") 4294 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4295 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4296 request.Method = "GET" 4297 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4298 if err != nil { 4299 return out, metadata, &smithy.SerializationError{Err: err} 4300 } 4301 4302 if err := awsRestjson1_serializeOpHttpBindingsListQueueQuickConnectsInput(input, restEncoder); err != nil { 4303 return out, metadata, &smithy.SerializationError{Err: err} 4304 } 4305 4306 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4307 return out, metadata, &smithy.SerializationError{Err: err} 4308 } 4309 in.Request = request 4310 4311 return next.HandleSerialize(ctx, in) 4312} 4313func awsRestjson1_serializeOpHttpBindingsListQueueQuickConnectsInput(v *ListQueueQuickConnectsInput, encoder *httpbinding.Encoder) error { 4314 if v == nil { 4315 return fmt.Errorf("unsupported serialization of nil %T", v) 4316 } 4317 4318 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4319 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4320 } 4321 if v.InstanceId != nil { 4322 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4323 return err 4324 } 4325 } 4326 4327 if v.MaxResults != 0 { 4328 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4329 } 4330 4331 if v.NextToken != nil { 4332 encoder.SetQuery("nextToken").String(*v.NextToken) 4333 } 4334 4335 if v.QueueId == nil || len(*v.QueueId) == 0 { 4336 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 4337 } 4338 if v.QueueId != nil { 4339 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 4340 return err 4341 } 4342 } 4343 4344 return nil 4345} 4346 4347type awsRestjson1_serializeOpListQueues struct { 4348} 4349 4350func (*awsRestjson1_serializeOpListQueues) ID() string { 4351 return "OperationSerializer" 4352} 4353 4354func (m *awsRestjson1_serializeOpListQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4355 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4356) { 4357 request, ok := in.Request.(*smithyhttp.Request) 4358 if !ok { 4359 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4360 } 4361 4362 input, ok := in.Parameters.(*ListQueuesInput) 4363 _ = input 4364 if !ok { 4365 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4366 } 4367 4368 opPath, opQuery := httpbinding.SplitURI("/queues-summary/{InstanceId}") 4369 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4370 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4371 request.Method = "GET" 4372 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4373 if err != nil { 4374 return out, metadata, &smithy.SerializationError{Err: err} 4375 } 4376 4377 if err := awsRestjson1_serializeOpHttpBindingsListQueuesInput(input, restEncoder); err != nil { 4378 return out, metadata, &smithy.SerializationError{Err: err} 4379 } 4380 4381 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4382 return out, metadata, &smithy.SerializationError{Err: err} 4383 } 4384 in.Request = request 4385 4386 return next.HandleSerialize(ctx, in) 4387} 4388func awsRestjson1_serializeOpHttpBindingsListQueuesInput(v *ListQueuesInput, encoder *httpbinding.Encoder) error { 4389 if v == nil { 4390 return fmt.Errorf("unsupported serialization of nil %T", v) 4391 } 4392 4393 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4394 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4395 } 4396 if v.InstanceId != nil { 4397 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4398 return err 4399 } 4400 } 4401 4402 if v.MaxResults != 0 { 4403 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4404 } 4405 4406 if v.NextToken != nil { 4407 encoder.SetQuery("nextToken").String(*v.NextToken) 4408 } 4409 4410 if v.QueueTypes != nil { 4411 for i := range v.QueueTypes { 4412 encoder.AddQuery("queueTypes").String(string(v.QueueTypes[i])) 4413 } 4414 } 4415 4416 return nil 4417} 4418 4419type awsRestjson1_serializeOpListQuickConnects struct { 4420} 4421 4422func (*awsRestjson1_serializeOpListQuickConnects) ID() string { 4423 return "OperationSerializer" 4424} 4425 4426func (m *awsRestjson1_serializeOpListQuickConnects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4427 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4428) { 4429 request, ok := in.Request.(*smithyhttp.Request) 4430 if !ok { 4431 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4432 } 4433 4434 input, ok := in.Parameters.(*ListQuickConnectsInput) 4435 _ = input 4436 if !ok { 4437 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4438 } 4439 4440 opPath, opQuery := httpbinding.SplitURI("/quick-connects/{InstanceId}") 4441 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4442 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4443 request.Method = "GET" 4444 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4445 if err != nil { 4446 return out, metadata, &smithy.SerializationError{Err: err} 4447 } 4448 4449 if err := awsRestjson1_serializeOpHttpBindingsListQuickConnectsInput(input, restEncoder); err != nil { 4450 return out, metadata, &smithy.SerializationError{Err: err} 4451 } 4452 4453 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4454 return out, metadata, &smithy.SerializationError{Err: err} 4455 } 4456 in.Request = request 4457 4458 return next.HandleSerialize(ctx, in) 4459} 4460func awsRestjson1_serializeOpHttpBindingsListQuickConnectsInput(v *ListQuickConnectsInput, encoder *httpbinding.Encoder) error { 4461 if v == nil { 4462 return fmt.Errorf("unsupported serialization of nil %T", v) 4463 } 4464 4465 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4466 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4467 } 4468 if v.InstanceId != nil { 4469 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4470 return err 4471 } 4472 } 4473 4474 if v.MaxResults != 0 { 4475 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4476 } 4477 4478 if v.NextToken != nil { 4479 encoder.SetQuery("nextToken").String(*v.NextToken) 4480 } 4481 4482 if v.QuickConnectTypes != nil { 4483 for i := range v.QuickConnectTypes { 4484 encoder.AddQuery("QuickConnectTypes").String(string(v.QuickConnectTypes[i])) 4485 } 4486 } 4487 4488 return nil 4489} 4490 4491type awsRestjson1_serializeOpListRoutingProfileQueues struct { 4492} 4493 4494func (*awsRestjson1_serializeOpListRoutingProfileQueues) ID() string { 4495 return "OperationSerializer" 4496} 4497 4498func (m *awsRestjson1_serializeOpListRoutingProfileQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4499 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4500) { 4501 request, ok := in.Request.(*smithyhttp.Request) 4502 if !ok { 4503 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4504 } 4505 4506 input, ok := in.Parameters.(*ListRoutingProfileQueuesInput) 4507 _ = input 4508 if !ok { 4509 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4510 } 4511 4512 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}/queues") 4513 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4514 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4515 request.Method = "GET" 4516 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4517 if err != nil { 4518 return out, metadata, &smithy.SerializationError{Err: err} 4519 } 4520 4521 if err := awsRestjson1_serializeOpHttpBindingsListRoutingProfileQueuesInput(input, restEncoder); err != nil { 4522 return out, metadata, &smithy.SerializationError{Err: err} 4523 } 4524 4525 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4526 return out, metadata, &smithy.SerializationError{Err: err} 4527 } 4528 in.Request = request 4529 4530 return next.HandleSerialize(ctx, in) 4531} 4532func awsRestjson1_serializeOpHttpBindingsListRoutingProfileQueuesInput(v *ListRoutingProfileQueuesInput, encoder *httpbinding.Encoder) error { 4533 if v == nil { 4534 return fmt.Errorf("unsupported serialization of nil %T", v) 4535 } 4536 4537 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4538 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4539 } 4540 if v.InstanceId != nil { 4541 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4542 return err 4543 } 4544 } 4545 4546 if v.MaxResults != 0 { 4547 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4548 } 4549 4550 if v.NextToken != nil { 4551 encoder.SetQuery("nextToken").String(*v.NextToken) 4552 } 4553 4554 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 4555 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 4556 } 4557 if v.RoutingProfileId != nil { 4558 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 4559 return err 4560 } 4561 } 4562 4563 return nil 4564} 4565 4566type awsRestjson1_serializeOpListRoutingProfiles struct { 4567} 4568 4569func (*awsRestjson1_serializeOpListRoutingProfiles) ID() string { 4570 return "OperationSerializer" 4571} 4572 4573func (m *awsRestjson1_serializeOpListRoutingProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4574 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4575) { 4576 request, ok := in.Request.(*smithyhttp.Request) 4577 if !ok { 4578 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4579 } 4580 4581 input, ok := in.Parameters.(*ListRoutingProfilesInput) 4582 _ = input 4583 if !ok { 4584 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4585 } 4586 4587 opPath, opQuery := httpbinding.SplitURI("/routing-profiles-summary/{InstanceId}") 4588 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4589 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4590 request.Method = "GET" 4591 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4592 if err != nil { 4593 return out, metadata, &smithy.SerializationError{Err: err} 4594 } 4595 4596 if err := awsRestjson1_serializeOpHttpBindingsListRoutingProfilesInput(input, restEncoder); err != nil { 4597 return out, metadata, &smithy.SerializationError{Err: err} 4598 } 4599 4600 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4601 return out, metadata, &smithy.SerializationError{Err: err} 4602 } 4603 in.Request = request 4604 4605 return next.HandleSerialize(ctx, in) 4606} 4607func awsRestjson1_serializeOpHttpBindingsListRoutingProfilesInput(v *ListRoutingProfilesInput, encoder *httpbinding.Encoder) error { 4608 if v == nil { 4609 return fmt.Errorf("unsupported serialization of nil %T", v) 4610 } 4611 4612 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4613 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4614 } 4615 if v.InstanceId != nil { 4616 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4617 return err 4618 } 4619 } 4620 4621 if v.MaxResults != 0 { 4622 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4623 } 4624 4625 if v.NextToken != nil { 4626 encoder.SetQuery("nextToken").String(*v.NextToken) 4627 } 4628 4629 return nil 4630} 4631 4632type awsRestjson1_serializeOpListSecurityKeys struct { 4633} 4634 4635func (*awsRestjson1_serializeOpListSecurityKeys) ID() string { 4636 return "OperationSerializer" 4637} 4638 4639func (m *awsRestjson1_serializeOpListSecurityKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4640 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4641) { 4642 request, ok := in.Request.(*smithyhttp.Request) 4643 if !ok { 4644 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4645 } 4646 4647 input, ok := in.Parameters.(*ListSecurityKeysInput) 4648 _ = input 4649 if !ok { 4650 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4651 } 4652 4653 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/security-keys") 4654 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4655 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4656 request.Method = "GET" 4657 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4658 if err != nil { 4659 return out, metadata, &smithy.SerializationError{Err: err} 4660 } 4661 4662 if err := awsRestjson1_serializeOpHttpBindingsListSecurityKeysInput(input, restEncoder); err != nil { 4663 return out, metadata, &smithy.SerializationError{Err: err} 4664 } 4665 4666 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4667 return out, metadata, &smithy.SerializationError{Err: err} 4668 } 4669 in.Request = request 4670 4671 return next.HandleSerialize(ctx, in) 4672} 4673func awsRestjson1_serializeOpHttpBindingsListSecurityKeysInput(v *ListSecurityKeysInput, encoder *httpbinding.Encoder) error { 4674 if v == nil { 4675 return fmt.Errorf("unsupported serialization of nil %T", v) 4676 } 4677 4678 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4679 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4680 } 4681 if v.InstanceId != nil { 4682 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4683 return err 4684 } 4685 } 4686 4687 if v.MaxResults != 0 { 4688 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4689 } 4690 4691 if v.NextToken != nil { 4692 encoder.SetQuery("nextToken").String(*v.NextToken) 4693 } 4694 4695 return nil 4696} 4697 4698type awsRestjson1_serializeOpListSecurityProfiles struct { 4699} 4700 4701func (*awsRestjson1_serializeOpListSecurityProfiles) ID() string { 4702 return "OperationSerializer" 4703} 4704 4705func (m *awsRestjson1_serializeOpListSecurityProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4706 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4707) { 4708 request, ok := in.Request.(*smithyhttp.Request) 4709 if !ok { 4710 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4711 } 4712 4713 input, ok := in.Parameters.(*ListSecurityProfilesInput) 4714 _ = input 4715 if !ok { 4716 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4717 } 4718 4719 opPath, opQuery := httpbinding.SplitURI("/security-profiles-summary/{InstanceId}") 4720 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4721 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4722 request.Method = "GET" 4723 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4724 if err != nil { 4725 return out, metadata, &smithy.SerializationError{Err: err} 4726 } 4727 4728 if err := awsRestjson1_serializeOpHttpBindingsListSecurityProfilesInput(input, restEncoder); err != nil { 4729 return out, metadata, &smithy.SerializationError{Err: err} 4730 } 4731 4732 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4733 return out, metadata, &smithy.SerializationError{Err: err} 4734 } 4735 in.Request = request 4736 4737 return next.HandleSerialize(ctx, in) 4738} 4739func awsRestjson1_serializeOpHttpBindingsListSecurityProfilesInput(v *ListSecurityProfilesInput, encoder *httpbinding.Encoder) error { 4740 if v == nil { 4741 return fmt.Errorf("unsupported serialization of nil %T", v) 4742 } 4743 4744 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4745 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4746 } 4747 if v.InstanceId != nil { 4748 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4749 return err 4750 } 4751 } 4752 4753 if v.MaxResults != 0 { 4754 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4755 } 4756 4757 if v.NextToken != nil { 4758 encoder.SetQuery("nextToken").String(*v.NextToken) 4759 } 4760 4761 return nil 4762} 4763 4764type awsRestjson1_serializeOpListTagsForResource struct { 4765} 4766 4767func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 4768 return "OperationSerializer" 4769} 4770 4771func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4772 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4773) { 4774 request, ok := in.Request.(*smithyhttp.Request) 4775 if !ok { 4776 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4777 } 4778 4779 input, ok := in.Parameters.(*ListTagsForResourceInput) 4780 _ = input 4781 if !ok { 4782 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4783 } 4784 4785 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 4786 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4787 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4788 request.Method = "GET" 4789 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4790 if err != nil { 4791 return out, metadata, &smithy.SerializationError{Err: err} 4792 } 4793 4794 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 4795 return out, metadata, &smithy.SerializationError{Err: err} 4796 } 4797 4798 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4799 return out, metadata, &smithy.SerializationError{Err: err} 4800 } 4801 in.Request = request 4802 4803 return next.HandleSerialize(ctx, in) 4804} 4805func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 4806 if v == nil { 4807 return fmt.Errorf("unsupported serialization of nil %T", v) 4808 } 4809 4810 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 4811 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 4812 } 4813 if v.ResourceArn != nil { 4814 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 4815 return err 4816 } 4817 } 4818 4819 return nil 4820} 4821 4822type awsRestjson1_serializeOpListUseCases struct { 4823} 4824 4825func (*awsRestjson1_serializeOpListUseCases) ID() string { 4826 return "OperationSerializer" 4827} 4828 4829func (m *awsRestjson1_serializeOpListUseCases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4830 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4831) { 4832 request, ok := in.Request.(*smithyhttp.Request) 4833 if !ok { 4834 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4835 } 4836 4837 input, ok := in.Parameters.(*ListUseCasesInput) 4838 _ = input 4839 if !ok { 4840 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4841 } 4842 4843 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}/use-cases") 4844 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4845 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4846 request.Method = "GET" 4847 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4848 if err != nil { 4849 return out, metadata, &smithy.SerializationError{Err: err} 4850 } 4851 4852 if err := awsRestjson1_serializeOpHttpBindingsListUseCasesInput(input, restEncoder); err != nil { 4853 return out, metadata, &smithy.SerializationError{Err: err} 4854 } 4855 4856 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4857 return out, metadata, &smithy.SerializationError{Err: err} 4858 } 4859 in.Request = request 4860 4861 return next.HandleSerialize(ctx, in) 4862} 4863func awsRestjson1_serializeOpHttpBindingsListUseCasesInput(v *ListUseCasesInput, encoder *httpbinding.Encoder) error { 4864 if v == nil { 4865 return fmt.Errorf("unsupported serialization of nil %T", v) 4866 } 4867 4868 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4869 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4870 } 4871 if v.InstanceId != nil { 4872 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4873 return err 4874 } 4875 } 4876 4877 if v.IntegrationAssociationId == nil || len(*v.IntegrationAssociationId) == 0 { 4878 return &smithy.SerializationError{Err: fmt.Errorf("input member IntegrationAssociationId must not be empty")} 4879 } 4880 if v.IntegrationAssociationId != nil { 4881 if err := encoder.SetURI("IntegrationAssociationId").String(*v.IntegrationAssociationId); err != nil { 4882 return err 4883 } 4884 } 4885 4886 if v.MaxResults != 0 { 4887 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4888 } 4889 4890 if v.NextToken != nil { 4891 encoder.SetQuery("nextToken").String(*v.NextToken) 4892 } 4893 4894 return nil 4895} 4896 4897type awsRestjson1_serializeOpListUserHierarchyGroups struct { 4898} 4899 4900func (*awsRestjson1_serializeOpListUserHierarchyGroups) ID() string { 4901 return "OperationSerializer" 4902} 4903 4904func (m *awsRestjson1_serializeOpListUserHierarchyGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4905 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4906) { 4907 request, ok := in.Request.(*smithyhttp.Request) 4908 if !ok { 4909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4910 } 4911 4912 input, ok := in.Parameters.(*ListUserHierarchyGroupsInput) 4913 _ = input 4914 if !ok { 4915 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4916 } 4917 4918 opPath, opQuery := httpbinding.SplitURI("/user-hierarchy-groups-summary/{InstanceId}") 4919 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4920 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4921 request.Method = "GET" 4922 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4923 if err != nil { 4924 return out, metadata, &smithy.SerializationError{Err: err} 4925 } 4926 4927 if err := awsRestjson1_serializeOpHttpBindingsListUserHierarchyGroupsInput(input, restEncoder); err != nil { 4928 return out, metadata, &smithy.SerializationError{Err: err} 4929 } 4930 4931 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4932 return out, metadata, &smithy.SerializationError{Err: err} 4933 } 4934 in.Request = request 4935 4936 return next.HandleSerialize(ctx, in) 4937} 4938func awsRestjson1_serializeOpHttpBindingsListUserHierarchyGroupsInput(v *ListUserHierarchyGroupsInput, encoder *httpbinding.Encoder) error { 4939 if v == nil { 4940 return fmt.Errorf("unsupported serialization of nil %T", v) 4941 } 4942 4943 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 4944 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 4945 } 4946 if v.InstanceId != nil { 4947 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 4948 return err 4949 } 4950 } 4951 4952 if v.MaxResults != 0 { 4953 encoder.SetQuery("maxResults").Integer(v.MaxResults) 4954 } 4955 4956 if v.NextToken != nil { 4957 encoder.SetQuery("nextToken").String(*v.NextToken) 4958 } 4959 4960 return nil 4961} 4962 4963type awsRestjson1_serializeOpListUsers struct { 4964} 4965 4966func (*awsRestjson1_serializeOpListUsers) ID() string { 4967 return "OperationSerializer" 4968} 4969 4970func (m *awsRestjson1_serializeOpListUsers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4971 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4972) { 4973 request, ok := in.Request.(*smithyhttp.Request) 4974 if !ok { 4975 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4976 } 4977 4978 input, ok := in.Parameters.(*ListUsersInput) 4979 _ = input 4980 if !ok { 4981 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4982 } 4983 4984 opPath, opQuery := httpbinding.SplitURI("/users-summary/{InstanceId}") 4985 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4986 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4987 request.Method = "GET" 4988 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4989 if err != nil { 4990 return out, metadata, &smithy.SerializationError{Err: err} 4991 } 4992 4993 if err := awsRestjson1_serializeOpHttpBindingsListUsersInput(input, restEncoder); err != nil { 4994 return out, metadata, &smithy.SerializationError{Err: err} 4995 } 4996 4997 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4998 return out, metadata, &smithy.SerializationError{Err: err} 4999 } 5000 in.Request = request 5001 5002 return next.HandleSerialize(ctx, in) 5003} 5004func awsRestjson1_serializeOpHttpBindingsListUsersInput(v *ListUsersInput, encoder *httpbinding.Encoder) error { 5005 if v == nil { 5006 return fmt.Errorf("unsupported serialization of nil %T", v) 5007 } 5008 5009 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 5010 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 5011 } 5012 if v.InstanceId != nil { 5013 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 5014 return err 5015 } 5016 } 5017 5018 if v.MaxResults != 0 { 5019 encoder.SetQuery("maxResults").Integer(v.MaxResults) 5020 } 5021 5022 if v.NextToken != nil { 5023 encoder.SetQuery("nextToken").String(*v.NextToken) 5024 } 5025 5026 return nil 5027} 5028 5029type awsRestjson1_serializeOpResumeContactRecording struct { 5030} 5031 5032func (*awsRestjson1_serializeOpResumeContactRecording) ID() string { 5033 return "OperationSerializer" 5034} 5035 5036func (m *awsRestjson1_serializeOpResumeContactRecording) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5037 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5038) { 5039 request, ok := in.Request.(*smithyhttp.Request) 5040 if !ok { 5041 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5042 } 5043 5044 input, ok := in.Parameters.(*ResumeContactRecordingInput) 5045 _ = input 5046 if !ok { 5047 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5048 } 5049 5050 opPath, opQuery := httpbinding.SplitURI("/contact/resume-recording") 5051 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5052 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5053 request.Method = "POST" 5054 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5055 if err != nil { 5056 return out, metadata, &smithy.SerializationError{Err: err} 5057 } 5058 5059 restEncoder.SetHeader("Content-Type").String("application/json") 5060 5061 jsonEncoder := smithyjson.NewEncoder() 5062 if err := awsRestjson1_serializeOpDocumentResumeContactRecordingInput(input, jsonEncoder.Value); err != nil { 5063 return out, metadata, &smithy.SerializationError{Err: err} 5064 } 5065 5066 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5067 return out, metadata, &smithy.SerializationError{Err: err} 5068 } 5069 5070 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5071 return out, metadata, &smithy.SerializationError{Err: err} 5072 } 5073 in.Request = request 5074 5075 return next.HandleSerialize(ctx, in) 5076} 5077func awsRestjson1_serializeOpHttpBindingsResumeContactRecordingInput(v *ResumeContactRecordingInput, encoder *httpbinding.Encoder) error { 5078 if v == nil { 5079 return fmt.Errorf("unsupported serialization of nil %T", v) 5080 } 5081 5082 return nil 5083} 5084 5085func awsRestjson1_serializeOpDocumentResumeContactRecordingInput(v *ResumeContactRecordingInput, value smithyjson.Value) error { 5086 object := value.Object() 5087 defer object.Close() 5088 5089 if v.ContactId != nil { 5090 ok := object.Key("ContactId") 5091 ok.String(*v.ContactId) 5092 } 5093 5094 if v.InitialContactId != nil { 5095 ok := object.Key("InitialContactId") 5096 ok.String(*v.InitialContactId) 5097 } 5098 5099 if v.InstanceId != nil { 5100 ok := object.Key("InstanceId") 5101 ok.String(*v.InstanceId) 5102 } 5103 5104 return nil 5105} 5106 5107type awsRestjson1_serializeOpStartChatContact struct { 5108} 5109 5110func (*awsRestjson1_serializeOpStartChatContact) ID() string { 5111 return "OperationSerializer" 5112} 5113 5114func (m *awsRestjson1_serializeOpStartChatContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5115 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5116) { 5117 request, ok := in.Request.(*smithyhttp.Request) 5118 if !ok { 5119 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5120 } 5121 5122 input, ok := in.Parameters.(*StartChatContactInput) 5123 _ = input 5124 if !ok { 5125 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5126 } 5127 5128 opPath, opQuery := httpbinding.SplitURI("/contact/chat") 5129 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5130 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5131 request.Method = "PUT" 5132 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5133 if err != nil { 5134 return out, metadata, &smithy.SerializationError{Err: err} 5135 } 5136 5137 restEncoder.SetHeader("Content-Type").String("application/json") 5138 5139 jsonEncoder := smithyjson.NewEncoder() 5140 if err := awsRestjson1_serializeOpDocumentStartChatContactInput(input, jsonEncoder.Value); err != nil { 5141 return out, metadata, &smithy.SerializationError{Err: err} 5142 } 5143 5144 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5145 return out, metadata, &smithy.SerializationError{Err: err} 5146 } 5147 5148 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5149 return out, metadata, &smithy.SerializationError{Err: err} 5150 } 5151 in.Request = request 5152 5153 return next.HandleSerialize(ctx, in) 5154} 5155func awsRestjson1_serializeOpHttpBindingsStartChatContactInput(v *StartChatContactInput, encoder *httpbinding.Encoder) error { 5156 if v == nil { 5157 return fmt.Errorf("unsupported serialization of nil %T", v) 5158 } 5159 5160 return nil 5161} 5162 5163func awsRestjson1_serializeOpDocumentStartChatContactInput(v *StartChatContactInput, value smithyjson.Value) error { 5164 object := value.Object() 5165 defer object.Close() 5166 5167 if v.Attributes != nil { 5168 ok := object.Key("Attributes") 5169 if err := awsRestjson1_serializeDocumentAttributes(v.Attributes, ok); err != nil { 5170 return err 5171 } 5172 } 5173 5174 if v.ClientToken != nil { 5175 ok := object.Key("ClientToken") 5176 ok.String(*v.ClientToken) 5177 } 5178 5179 if v.ContactFlowId != nil { 5180 ok := object.Key("ContactFlowId") 5181 ok.String(*v.ContactFlowId) 5182 } 5183 5184 if v.InitialMessage != nil { 5185 ok := object.Key("InitialMessage") 5186 if err := awsRestjson1_serializeDocumentChatMessage(v.InitialMessage, ok); err != nil { 5187 return err 5188 } 5189 } 5190 5191 if v.InstanceId != nil { 5192 ok := object.Key("InstanceId") 5193 ok.String(*v.InstanceId) 5194 } 5195 5196 if v.ParticipantDetails != nil { 5197 ok := object.Key("ParticipantDetails") 5198 if err := awsRestjson1_serializeDocumentParticipantDetails(v.ParticipantDetails, ok); err != nil { 5199 return err 5200 } 5201 } 5202 5203 return nil 5204} 5205 5206type awsRestjson1_serializeOpStartContactRecording struct { 5207} 5208 5209func (*awsRestjson1_serializeOpStartContactRecording) ID() string { 5210 return "OperationSerializer" 5211} 5212 5213func (m *awsRestjson1_serializeOpStartContactRecording) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5214 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5215) { 5216 request, ok := in.Request.(*smithyhttp.Request) 5217 if !ok { 5218 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5219 } 5220 5221 input, ok := in.Parameters.(*StartContactRecordingInput) 5222 _ = input 5223 if !ok { 5224 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5225 } 5226 5227 opPath, opQuery := httpbinding.SplitURI("/contact/start-recording") 5228 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5229 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5230 request.Method = "POST" 5231 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5232 if err != nil { 5233 return out, metadata, &smithy.SerializationError{Err: err} 5234 } 5235 5236 restEncoder.SetHeader("Content-Type").String("application/json") 5237 5238 jsonEncoder := smithyjson.NewEncoder() 5239 if err := awsRestjson1_serializeOpDocumentStartContactRecordingInput(input, jsonEncoder.Value); err != nil { 5240 return out, metadata, &smithy.SerializationError{Err: err} 5241 } 5242 5243 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5244 return out, metadata, &smithy.SerializationError{Err: err} 5245 } 5246 5247 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5248 return out, metadata, &smithy.SerializationError{Err: err} 5249 } 5250 in.Request = request 5251 5252 return next.HandleSerialize(ctx, in) 5253} 5254func awsRestjson1_serializeOpHttpBindingsStartContactRecordingInput(v *StartContactRecordingInput, encoder *httpbinding.Encoder) error { 5255 if v == nil { 5256 return fmt.Errorf("unsupported serialization of nil %T", v) 5257 } 5258 5259 return nil 5260} 5261 5262func awsRestjson1_serializeOpDocumentStartContactRecordingInput(v *StartContactRecordingInput, value smithyjson.Value) error { 5263 object := value.Object() 5264 defer object.Close() 5265 5266 if v.ContactId != nil { 5267 ok := object.Key("ContactId") 5268 ok.String(*v.ContactId) 5269 } 5270 5271 if v.InitialContactId != nil { 5272 ok := object.Key("InitialContactId") 5273 ok.String(*v.InitialContactId) 5274 } 5275 5276 if v.InstanceId != nil { 5277 ok := object.Key("InstanceId") 5278 ok.String(*v.InstanceId) 5279 } 5280 5281 if v.VoiceRecordingConfiguration != nil { 5282 ok := object.Key("VoiceRecordingConfiguration") 5283 if err := awsRestjson1_serializeDocumentVoiceRecordingConfiguration(v.VoiceRecordingConfiguration, ok); err != nil { 5284 return err 5285 } 5286 } 5287 5288 return nil 5289} 5290 5291type awsRestjson1_serializeOpStartOutboundVoiceContact struct { 5292} 5293 5294func (*awsRestjson1_serializeOpStartOutboundVoiceContact) ID() string { 5295 return "OperationSerializer" 5296} 5297 5298func (m *awsRestjson1_serializeOpStartOutboundVoiceContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5299 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5300) { 5301 request, ok := in.Request.(*smithyhttp.Request) 5302 if !ok { 5303 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5304 } 5305 5306 input, ok := in.Parameters.(*StartOutboundVoiceContactInput) 5307 _ = input 5308 if !ok { 5309 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5310 } 5311 5312 opPath, opQuery := httpbinding.SplitURI("/contact/outbound-voice") 5313 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5314 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5315 request.Method = "PUT" 5316 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5317 if err != nil { 5318 return out, metadata, &smithy.SerializationError{Err: err} 5319 } 5320 5321 restEncoder.SetHeader("Content-Type").String("application/json") 5322 5323 jsonEncoder := smithyjson.NewEncoder() 5324 if err := awsRestjson1_serializeOpDocumentStartOutboundVoiceContactInput(input, jsonEncoder.Value); err != nil { 5325 return out, metadata, &smithy.SerializationError{Err: err} 5326 } 5327 5328 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5329 return out, metadata, &smithy.SerializationError{Err: err} 5330 } 5331 5332 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5333 return out, metadata, &smithy.SerializationError{Err: err} 5334 } 5335 in.Request = request 5336 5337 return next.HandleSerialize(ctx, in) 5338} 5339func awsRestjson1_serializeOpHttpBindingsStartOutboundVoiceContactInput(v *StartOutboundVoiceContactInput, encoder *httpbinding.Encoder) error { 5340 if v == nil { 5341 return fmt.Errorf("unsupported serialization of nil %T", v) 5342 } 5343 5344 return nil 5345} 5346 5347func awsRestjson1_serializeOpDocumentStartOutboundVoiceContactInput(v *StartOutboundVoiceContactInput, value smithyjson.Value) error { 5348 object := value.Object() 5349 defer object.Close() 5350 5351 if v.Attributes != nil { 5352 ok := object.Key("Attributes") 5353 if err := awsRestjson1_serializeDocumentAttributes(v.Attributes, ok); err != nil { 5354 return err 5355 } 5356 } 5357 5358 if v.ClientToken != nil { 5359 ok := object.Key("ClientToken") 5360 ok.String(*v.ClientToken) 5361 } 5362 5363 if v.ContactFlowId != nil { 5364 ok := object.Key("ContactFlowId") 5365 ok.String(*v.ContactFlowId) 5366 } 5367 5368 if v.DestinationPhoneNumber != nil { 5369 ok := object.Key("DestinationPhoneNumber") 5370 ok.String(*v.DestinationPhoneNumber) 5371 } 5372 5373 if v.InstanceId != nil { 5374 ok := object.Key("InstanceId") 5375 ok.String(*v.InstanceId) 5376 } 5377 5378 if v.QueueId != nil { 5379 ok := object.Key("QueueId") 5380 ok.String(*v.QueueId) 5381 } 5382 5383 if v.SourcePhoneNumber != nil { 5384 ok := object.Key("SourcePhoneNumber") 5385 ok.String(*v.SourcePhoneNumber) 5386 } 5387 5388 return nil 5389} 5390 5391type awsRestjson1_serializeOpStartTaskContact struct { 5392} 5393 5394func (*awsRestjson1_serializeOpStartTaskContact) ID() string { 5395 return "OperationSerializer" 5396} 5397 5398func (m *awsRestjson1_serializeOpStartTaskContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5399 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5400) { 5401 request, ok := in.Request.(*smithyhttp.Request) 5402 if !ok { 5403 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5404 } 5405 5406 input, ok := in.Parameters.(*StartTaskContactInput) 5407 _ = input 5408 if !ok { 5409 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5410 } 5411 5412 opPath, opQuery := httpbinding.SplitURI("/contact/task") 5413 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5414 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5415 request.Method = "PUT" 5416 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5417 if err != nil { 5418 return out, metadata, &smithy.SerializationError{Err: err} 5419 } 5420 5421 restEncoder.SetHeader("Content-Type").String("application/json") 5422 5423 jsonEncoder := smithyjson.NewEncoder() 5424 if err := awsRestjson1_serializeOpDocumentStartTaskContactInput(input, jsonEncoder.Value); err != nil { 5425 return out, metadata, &smithy.SerializationError{Err: err} 5426 } 5427 5428 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5429 return out, metadata, &smithy.SerializationError{Err: err} 5430 } 5431 5432 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5433 return out, metadata, &smithy.SerializationError{Err: err} 5434 } 5435 in.Request = request 5436 5437 return next.HandleSerialize(ctx, in) 5438} 5439func awsRestjson1_serializeOpHttpBindingsStartTaskContactInput(v *StartTaskContactInput, encoder *httpbinding.Encoder) error { 5440 if v == nil { 5441 return fmt.Errorf("unsupported serialization of nil %T", v) 5442 } 5443 5444 return nil 5445} 5446 5447func awsRestjson1_serializeOpDocumentStartTaskContactInput(v *StartTaskContactInput, value smithyjson.Value) error { 5448 object := value.Object() 5449 defer object.Close() 5450 5451 if v.Attributes != nil { 5452 ok := object.Key("Attributes") 5453 if err := awsRestjson1_serializeDocumentAttributes(v.Attributes, ok); err != nil { 5454 return err 5455 } 5456 } 5457 5458 if v.ClientToken != nil { 5459 ok := object.Key("ClientToken") 5460 ok.String(*v.ClientToken) 5461 } 5462 5463 if v.ContactFlowId != nil { 5464 ok := object.Key("ContactFlowId") 5465 ok.String(*v.ContactFlowId) 5466 } 5467 5468 if v.Description != nil { 5469 ok := object.Key("Description") 5470 ok.String(*v.Description) 5471 } 5472 5473 if v.InstanceId != nil { 5474 ok := object.Key("InstanceId") 5475 ok.String(*v.InstanceId) 5476 } 5477 5478 if v.Name != nil { 5479 ok := object.Key("Name") 5480 ok.String(*v.Name) 5481 } 5482 5483 if v.PreviousContactId != nil { 5484 ok := object.Key("PreviousContactId") 5485 ok.String(*v.PreviousContactId) 5486 } 5487 5488 if v.References != nil { 5489 ok := object.Key("References") 5490 if err := awsRestjson1_serializeDocumentContactReferences(v.References, ok); err != nil { 5491 return err 5492 } 5493 } 5494 5495 return nil 5496} 5497 5498type awsRestjson1_serializeOpStopContact struct { 5499} 5500 5501func (*awsRestjson1_serializeOpStopContact) ID() string { 5502 return "OperationSerializer" 5503} 5504 5505func (m *awsRestjson1_serializeOpStopContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5506 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5507) { 5508 request, ok := in.Request.(*smithyhttp.Request) 5509 if !ok { 5510 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5511 } 5512 5513 input, ok := in.Parameters.(*StopContactInput) 5514 _ = input 5515 if !ok { 5516 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5517 } 5518 5519 opPath, opQuery := httpbinding.SplitURI("/contact/stop") 5520 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5521 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5522 request.Method = "POST" 5523 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5524 if err != nil { 5525 return out, metadata, &smithy.SerializationError{Err: err} 5526 } 5527 5528 restEncoder.SetHeader("Content-Type").String("application/json") 5529 5530 jsonEncoder := smithyjson.NewEncoder() 5531 if err := awsRestjson1_serializeOpDocumentStopContactInput(input, jsonEncoder.Value); err != nil { 5532 return out, metadata, &smithy.SerializationError{Err: err} 5533 } 5534 5535 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5536 return out, metadata, &smithy.SerializationError{Err: err} 5537 } 5538 5539 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5540 return out, metadata, &smithy.SerializationError{Err: err} 5541 } 5542 in.Request = request 5543 5544 return next.HandleSerialize(ctx, in) 5545} 5546func awsRestjson1_serializeOpHttpBindingsStopContactInput(v *StopContactInput, encoder *httpbinding.Encoder) error { 5547 if v == nil { 5548 return fmt.Errorf("unsupported serialization of nil %T", v) 5549 } 5550 5551 return nil 5552} 5553 5554func awsRestjson1_serializeOpDocumentStopContactInput(v *StopContactInput, value smithyjson.Value) error { 5555 object := value.Object() 5556 defer object.Close() 5557 5558 if v.ContactId != nil { 5559 ok := object.Key("ContactId") 5560 ok.String(*v.ContactId) 5561 } 5562 5563 if v.InstanceId != nil { 5564 ok := object.Key("InstanceId") 5565 ok.String(*v.InstanceId) 5566 } 5567 5568 return nil 5569} 5570 5571type awsRestjson1_serializeOpStopContactRecording struct { 5572} 5573 5574func (*awsRestjson1_serializeOpStopContactRecording) ID() string { 5575 return "OperationSerializer" 5576} 5577 5578func (m *awsRestjson1_serializeOpStopContactRecording) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5579 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5580) { 5581 request, ok := in.Request.(*smithyhttp.Request) 5582 if !ok { 5583 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5584 } 5585 5586 input, ok := in.Parameters.(*StopContactRecordingInput) 5587 _ = input 5588 if !ok { 5589 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5590 } 5591 5592 opPath, opQuery := httpbinding.SplitURI("/contact/stop-recording") 5593 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5594 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5595 request.Method = "POST" 5596 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5597 if err != nil { 5598 return out, metadata, &smithy.SerializationError{Err: err} 5599 } 5600 5601 restEncoder.SetHeader("Content-Type").String("application/json") 5602 5603 jsonEncoder := smithyjson.NewEncoder() 5604 if err := awsRestjson1_serializeOpDocumentStopContactRecordingInput(input, jsonEncoder.Value); err != nil { 5605 return out, metadata, &smithy.SerializationError{Err: err} 5606 } 5607 5608 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5609 return out, metadata, &smithy.SerializationError{Err: err} 5610 } 5611 5612 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5613 return out, metadata, &smithy.SerializationError{Err: err} 5614 } 5615 in.Request = request 5616 5617 return next.HandleSerialize(ctx, in) 5618} 5619func awsRestjson1_serializeOpHttpBindingsStopContactRecordingInput(v *StopContactRecordingInput, encoder *httpbinding.Encoder) error { 5620 if v == nil { 5621 return fmt.Errorf("unsupported serialization of nil %T", v) 5622 } 5623 5624 return nil 5625} 5626 5627func awsRestjson1_serializeOpDocumentStopContactRecordingInput(v *StopContactRecordingInput, value smithyjson.Value) error { 5628 object := value.Object() 5629 defer object.Close() 5630 5631 if v.ContactId != nil { 5632 ok := object.Key("ContactId") 5633 ok.String(*v.ContactId) 5634 } 5635 5636 if v.InitialContactId != nil { 5637 ok := object.Key("InitialContactId") 5638 ok.String(*v.InitialContactId) 5639 } 5640 5641 if v.InstanceId != nil { 5642 ok := object.Key("InstanceId") 5643 ok.String(*v.InstanceId) 5644 } 5645 5646 return nil 5647} 5648 5649type awsRestjson1_serializeOpSuspendContactRecording struct { 5650} 5651 5652func (*awsRestjson1_serializeOpSuspendContactRecording) ID() string { 5653 return "OperationSerializer" 5654} 5655 5656func (m *awsRestjson1_serializeOpSuspendContactRecording) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5657 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5658) { 5659 request, ok := in.Request.(*smithyhttp.Request) 5660 if !ok { 5661 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5662 } 5663 5664 input, ok := in.Parameters.(*SuspendContactRecordingInput) 5665 _ = input 5666 if !ok { 5667 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5668 } 5669 5670 opPath, opQuery := httpbinding.SplitURI("/contact/suspend-recording") 5671 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5672 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5673 request.Method = "POST" 5674 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5675 if err != nil { 5676 return out, metadata, &smithy.SerializationError{Err: err} 5677 } 5678 5679 restEncoder.SetHeader("Content-Type").String("application/json") 5680 5681 jsonEncoder := smithyjson.NewEncoder() 5682 if err := awsRestjson1_serializeOpDocumentSuspendContactRecordingInput(input, jsonEncoder.Value); err != nil { 5683 return out, metadata, &smithy.SerializationError{Err: err} 5684 } 5685 5686 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5687 return out, metadata, &smithy.SerializationError{Err: err} 5688 } 5689 5690 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5691 return out, metadata, &smithy.SerializationError{Err: err} 5692 } 5693 in.Request = request 5694 5695 return next.HandleSerialize(ctx, in) 5696} 5697func awsRestjson1_serializeOpHttpBindingsSuspendContactRecordingInput(v *SuspendContactRecordingInput, encoder *httpbinding.Encoder) error { 5698 if v == nil { 5699 return fmt.Errorf("unsupported serialization of nil %T", v) 5700 } 5701 5702 return nil 5703} 5704 5705func awsRestjson1_serializeOpDocumentSuspendContactRecordingInput(v *SuspendContactRecordingInput, value smithyjson.Value) error { 5706 object := value.Object() 5707 defer object.Close() 5708 5709 if v.ContactId != nil { 5710 ok := object.Key("ContactId") 5711 ok.String(*v.ContactId) 5712 } 5713 5714 if v.InitialContactId != nil { 5715 ok := object.Key("InitialContactId") 5716 ok.String(*v.InitialContactId) 5717 } 5718 5719 if v.InstanceId != nil { 5720 ok := object.Key("InstanceId") 5721 ok.String(*v.InstanceId) 5722 } 5723 5724 return nil 5725} 5726 5727type awsRestjson1_serializeOpTagResource struct { 5728} 5729 5730func (*awsRestjson1_serializeOpTagResource) ID() string { 5731 return "OperationSerializer" 5732} 5733 5734func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5735 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5736) { 5737 request, ok := in.Request.(*smithyhttp.Request) 5738 if !ok { 5739 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5740 } 5741 5742 input, ok := in.Parameters.(*TagResourceInput) 5743 _ = input 5744 if !ok { 5745 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5746 } 5747 5748 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 5749 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5750 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5751 request.Method = "POST" 5752 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5753 if err != nil { 5754 return out, metadata, &smithy.SerializationError{Err: err} 5755 } 5756 5757 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 5758 return out, metadata, &smithy.SerializationError{Err: err} 5759 } 5760 5761 restEncoder.SetHeader("Content-Type").String("application/json") 5762 5763 jsonEncoder := smithyjson.NewEncoder() 5764 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 5765 return out, metadata, &smithy.SerializationError{Err: err} 5766 } 5767 5768 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5769 return out, metadata, &smithy.SerializationError{Err: err} 5770 } 5771 5772 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5773 return out, metadata, &smithy.SerializationError{Err: err} 5774 } 5775 in.Request = request 5776 5777 return next.HandleSerialize(ctx, in) 5778} 5779func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 5780 if v == nil { 5781 return fmt.Errorf("unsupported serialization of nil %T", v) 5782 } 5783 5784 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 5785 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 5786 } 5787 if v.ResourceArn != nil { 5788 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 5789 return err 5790 } 5791 } 5792 5793 return nil 5794} 5795 5796func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 5797 object := value.Object() 5798 defer object.Close() 5799 5800 if v.Tags != nil { 5801 ok := object.Key("tags") 5802 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 5803 return err 5804 } 5805 } 5806 5807 return nil 5808} 5809 5810type awsRestjson1_serializeOpUntagResource struct { 5811} 5812 5813func (*awsRestjson1_serializeOpUntagResource) ID() string { 5814 return "OperationSerializer" 5815} 5816 5817func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5818 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5819) { 5820 request, ok := in.Request.(*smithyhttp.Request) 5821 if !ok { 5822 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5823 } 5824 5825 input, ok := in.Parameters.(*UntagResourceInput) 5826 _ = input 5827 if !ok { 5828 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5829 } 5830 5831 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 5832 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5833 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5834 request.Method = "DELETE" 5835 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5836 if err != nil { 5837 return out, metadata, &smithy.SerializationError{Err: err} 5838 } 5839 5840 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 5841 return out, metadata, &smithy.SerializationError{Err: err} 5842 } 5843 5844 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5845 return out, metadata, &smithy.SerializationError{Err: err} 5846 } 5847 in.Request = request 5848 5849 return next.HandleSerialize(ctx, in) 5850} 5851func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 5852 if v == nil { 5853 return fmt.Errorf("unsupported serialization of nil %T", v) 5854 } 5855 5856 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 5857 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 5858 } 5859 if v.ResourceArn != nil { 5860 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 5861 return err 5862 } 5863 } 5864 5865 if v.TagKeys != nil { 5866 for i := range v.TagKeys { 5867 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 5868 } 5869 } 5870 5871 return nil 5872} 5873 5874type awsRestjson1_serializeOpUpdateContactAttributes struct { 5875} 5876 5877func (*awsRestjson1_serializeOpUpdateContactAttributes) ID() string { 5878 return "OperationSerializer" 5879} 5880 5881func (m *awsRestjson1_serializeOpUpdateContactAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5882 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5883) { 5884 request, ok := in.Request.(*smithyhttp.Request) 5885 if !ok { 5886 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5887 } 5888 5889 input, ok := in.Parameters.(*UpdateContactAttributesInput) 5890 _ = input 5891 if !ok { 5892 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5893 } 5894 5895 opPath, opQuery := httpbinding.SplitURI("/contact/attributes") 5896 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5897 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5898 request.Method = "POST" 5899 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5900 if err != nil { 5901 return out, metadata, &smithy.SerializationError{Err: err} 5902 } 5903 5904 restEncoder.SetHeader("Content-Type").String("application/json") 5905 5906 jsonEncoder := smithyjson.NewEncoder() 5907 if err := awsRestjson1_serializeOpDocumentUpdateContactAttributesInput(input, jsonEncoder.Value); err != nil { 5908 return out, metadata, &smithy.SerializationError{Err: err} 5909 } 5910 5911 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5912 return out, metadata, &smithy.SerializationError{Err: err} 5913 } 5914 5915 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5916 return out, metadata, &smithy.SerializationError{Err: err} 5917 } 5918 in.Request = request 5919 5920 return next.HandleSerialize(ctx, in) 5921} 5922func awsRestjson1_serializeOpHttpBindingsUpdateContactAttributesInput(v *UpdateContactAttributesInput, encoder *httpbinding.Encoder) error { 5923 if v == nil { 5924 return fmt.Errorf("unsupported serialization of nil %T", v) 5925 } 5926 5927 return nil 5928} 5929 5930func awsRestjson1_serializeOpDocumentUpdateContactAttributesInput(v *UpdateContactAttributesInput, value smithyjson.Value) error { 5931 object := value.Object() 5932 defer object.Close() 5933 5934 if v.Attributes != nil { 5935 ok := object.Key("Attributes") 5936 if err := awsRestjson1_serializeDocumentAttributes(v.Attributes, ok); err != nil { 5937 return err 5938 } 5939 } 5940 5941 if v.InitialContactId != nil { 5942 ok := object.Key("InitialContactId") 5943 ok.String(*v.InitialContactId) 5944 } 5945 5946 if v.InstanceId != nil { 5947 ok := object.Key("InstanceId") 5948 ok.String(*v.InstanceId) 5949 } 5950 5951 return nil 5952} 5953 5954type awsRestjson1_serializeOpUpdateContactFlowContent struct { 5955} 5956 5957func (*awsRestjson1_serializeOpUpdateContactFlowContent) ID() string { 5958 return "OperationSerializer" 5959} 5960 5961func (m *awsRestjson1_serializeOpUpdateContactFlowContent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5962 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5963) { 5964 request, ok := in.Request.(*smithyhttp.Request) 5965 if !ok { 5966 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5967 } 5968 5969 input, ok := in.Parameters.(*UpdateContactFlowContentInput) 5970 _ = input 5971 if !ok { 5972 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5973 } 5974 5975 opPath, opQuery := httpbinding.SplitURI("/contact-flows/{InstanceId}/{ContactFlowId}/content") 5976 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5977 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5978 request.Method = "POST" 5979 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5980 if err != nil { 5981 return out, metadata, &smithy.SerializationError{Err: err} 5982 } 5983 5984 if err := awsRestjson1_serializeOpHttpBindingsUpdateContactFlowContentInput(input, restEncoder); err != nil { 5985 return out, metadata, &smithy.SerializationError{Err: err} 5986 } 5987 5988 restEncoder.SetHeader("Content-Type").String("application/json") 5989 5990 jsonEncoder := smithyjson.NewEncoder() 5991 if err := awsRestjson1_serializeOpDocumentUpdateContactFlowContentInput(input, jsonEncoder.Value); err != nil { 5992 return out, metadata, &smithy.SerializationError{Err: err} 5993 } 5994 5995 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5996 return out, metadata, &smithy.SerializationError{Err: err} 5997 } 5998 5999 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6000 return out, metadata, &smithy.SerializationError{Err: err} 6001 } 6002 in.Request = request 6003 6004 return next.HandleSerialize(ctx, in) 6005} 6006func awsRestjson1_serializeOpHttpBindingsUpdateContactFlowContentInput(v *UpdateContactFlowContentInput, encoder *httpbinding.Encoder) error { 6007 if v == nil { 6008 return fmt.Errorf("unsupported serialization of nil %T", v) 6009 } 6010 6011 if v.ContactFlowId == nil || len(*v.ContactFlowId) == 0 { 6012 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactFlowId must not be empty")} 6013 } 6014 if v.ContactFlowId != nil { 6015 if err := encoder.SetURI("ContactFlowId").String(*v.ContactFlowId); err != nil { 6016 return err 6017 } 6018 } 6019 6020 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6021 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6022 } 6023 if v.InstanceId != nil { 6024 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6025 return err 6026 } 6027 } 6028 6029 return nil 6030} 6031 6032func awsRestjson1_serializeOpDocumentUpdateContactFlowContentInput(v *UpdateContactFlowContentInput, value smithyjson.Value) error { 6033 object := value.Object() 6034 defer object.Close() 6035 6036 if v.Content != nil { 6037 ok := object.Key("Content") 6038 ok.String(*v.Content) 6039 } 6040 6041 return nil 6042} 6043 6044type awsRestjson1_serializeOpUpdateContactFlowName struct { 6045} 6046 6047func (*awsRestjson1_serializeOpUpdateContactFlowName) ID() string { 6048 return "OperationSerializer" 6049} 6050 6051func (m *awsRestjson1_serializeOpUpdateContactFlowName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6052 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6053) { 6054 request, ok := in.Request.(*smithyhttp.Request) 6055 if !ok { 6056 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6057 } 6058 6059 input, ok := in.Parameters.(*UpdateContactFlowNameInput) 6060 _ = input 6061 if !ok { 6062 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6063 } 6064 6065 opPath, opQuery := httpbinding.SplitURI("/contact-flows/{InstanceId}/{ContactFlowId}/name") 6066 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6067 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6068 request.Method = "POST" 6069 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6070 if err != nil { 6071 return out, metadata, &smithy.SerializationError{Err: err} 6072 } 6073 6074 if err := awsRestjson1_serializeOpHttpBindingsUpdateContactFlowNameInput(input, restEncoder); err != nil { 6075 return out, metadata, &smithy.SerializationError{Err: err} 6076 } 6077 6078 restEncoder.SetHeader("Content-Type").String("application/json") 6079 6080 jsonEncoder := smithyjson.NewEncoder() 6081 if err := awsRestjson1_serializeOpDocumentUpdateContactFlowNameInput(input, jsonEncoder.Value); err != nil { 6082 return out, metadata, &smithy.SerializationError{Err: err} 6083 } 6084 6085 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6086 return out, metadata, &smithy.SerializationError{Err: err} 6087 } 6088 6089 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6090 return out, metadata, &smithy.SerializationError{Err: err} 6091 } 6092 in.Request = request 6093 6094 return next.HandleSerialize(ctx, in) 6095} 6096func awsRestjson1_serializeOpHttpBindingsUpdateContactFlowNameInput(v *UpdateContactFlowNameInput, encoder *httpbinding.Encoder) error { 6097 if v == nil { 6098 return fmt.Errorf("unsupported serialization of nil %T", v) 6099 } 6100 6101 if v.ContactFlowId == nil || len(*v.ContactFlowId) == 0 { 6102 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactFlowId must not be empty")} 6103 } 6104 if v.ContactFlowId != nil { 6105 if err := encoder.SetURI("ContactFlowId").String(*v.ContactFlowId); err != nil { 6106 return err 6107 } 6108 } 6109 6110 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6111 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6112 } 6113 if v.InstanceId != nil { 6114 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6115 return err 6116 } 6117 } 6118 6119 return nil 6120} 6121 6122func awsRestjson1_serializeOpDocumentUpdateContactFlowNameInput(v *UpdateContactFlowNameInput, value smithyjson.Value) error { 6123 object := value.Object() 6124 defer object.Close() 6125 6126 if v.Description != nil { 6127 ok := object.Key("Description") 6128 ok.String(*v.Description) 6129 } 6130 6131 if v.Name != nil { 6132 ok := object.Key("Name") 6133 ok.String(*v.Name) 6134 } 6135 6136 return nil 6137} 6138 6139type awsRestjson1_serializeOpUpdateInstanceAttribute struct { 6140} 6141 6142func (*awsRestjson1_serializeOpUpdateInstanceAttribute) ID() string { 6143 return "OperationSerializer" 6144} 6145 6146func (m *awsRestjson1_serializeOpUpdateInstanceAttribute) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6147 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6148) { 6149 request, ok := in.Request.(*smithyhttp.Request) 6150 if !ok { 6151 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6152 } 6153 6154 input, ok := in.Parameters.(*UpdateInstanceAttributeInput) 6155 _ = input 6156 if !ok { 6157 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6158 } 6159 6160 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/attribute/{AttributeType}") 6161 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6162 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6163 request.Method = "POST" 6164 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6165 if err != nil { 6166 return out, metadata, &smithy.SerializationError{Err: err} 6167 } 6168 6169 if err := awsRestjson1_serializeOpHttpBindingsUpdateInstanceAttributeInput(input, restEncoder); err != nil { 6170 return out, metadata, &smithy.SerializationError{Err: err} 6171 } 6172 6173 restEncoder.SetHeader("Content-Type").String("application/json") 6174 6175 jsonEncoder := smithyjson.NewEncoder() 6176 if err := awsRestjson1_serializeOpDocumentUpdateInstanceAttributeInput(input, jsonEncoder.Value); err != nil { 6177 return out, metadata, &smithy.SerializationError{Err: err} 6178 } 6179 6180 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6181 return out, metadata, &smithy.SerializationError{Err: err} 6182 } 6183 6184 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6185 return out, metadata, &smithy.SerializationError{Err: err} 6186 } 6187 in.Request = request 6188 6189 return next.HandleSerialize(ctx, in) 6190} 6191func awsRestjson1_serializeOpHttpBindingsUpdateInstanceAttributeInput(v *UpdateInstanceAttributeInput, encoder *httpbinding.Encoder) error { 6192 if v == nil { 6193 return fmt.Errorf("unsupported serialization of nil %T", v) 6194 } 6195 6196 if len(v.AttributeType) == 0 { 6197 return &smithy.SerializationError{Err: fmt.Errorf("input member AttributeType must not be empty")} 6198 } 6199 if len(v.AttributeType) > 0 { 6200 if err := encoder.SetURI("AttributeType").String(string(v.AttributeType)); err != nil { 6201 return err 6202 } 6203 } 6204 6205 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6206 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6207 } 6208 if v.InstanceId != nil { 6209 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6210 return err 6211 } 6212 } 6213 6214 return nil 6215} 6216 6217func awsRestjson1_serializeOpDocumentUpdateInstanceAttributeInput(v *UpdateInstanceAttributeInput, value smithyjson.Value) error { 6218 object := value.Object() 6219 defer object.Close() 6220 6221 if v.Value != nil { 6222 ok := object.Key("Value") 6223 ok.String(*v.Value) 6224 } 6225 6226 return nil 6227} 6228 6229type awsRestjson1_serializeOpUpdateInstanceStorageConfig struct { 6230} 6231 6232func (*awsRestjson1_serializeOpUpdateInstanceStorageConfig) ID() string { 6233 return "OperationSerializer" 6234} 6235 6236func (m *awsRestjson1_serializeOpUpdateInstanceStorageConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6237 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6238) { 6239 request, ok := in.Request.(*smithyhttp.Request) 6240 if !ok { 6241 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6242 } 6243 6244 input, ok := in.Parameters.(*UpdateInstanceStorageConfigInput) 6245 _ = input 6246 if !ok { 6247 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6248 } 6249 6250 opPath, opQuery := httpbinding.SplitURI("/instance/{InstanceId}/storage-config/{AssociationId}") 6251 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6252 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6253 request.Method = "POST" 6254 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6255 if err != nil { 6256 return out, metadata, &smithy.SerializationError{Err: err} 6257 } 6258 6259 if err := awsRestjson1_serializeOpHttpBindingsUpdateInstanceStorageConfigInput(input, restEncoder); err != nil { 6260 return out, metadata, &smithy.SerializationError{Err: err} 6261 } 6262 6263 restEncoder.SetHeader("Content-Type").String("application/json") 6264 6265 jsonEncoder := smithyjson.NewEncoder() 6266 if err := awsRestjson1_serializeOpDocumentUpdateInstanceStorageConfigInput(input, jsonEncoder.Value); err != nil { 6267 return out, metadata, &smithy.SerializationError{Err: err} 6268 } 6269 6270 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6271 return out, metadata, &smithy.SerializationError{Err: err} 6272 } 6273 6274 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6275 return out, metadata, &smithy.SerializationError{Err: err} 6276 } 6277 in.Request = request 6278 6279 return next.HandleSerialize(ctx, in) 6280} 6281func awsRestjson1_serializeOpHttpBindingsUpdateInstanceStorageConfigInput(v *UpdateInstanceStorageConfigInput, encoder *httpbinding.Encoder) error { 6282 if v == nil { 6283 return fmt.Errorf("unsupported serialization of nil %T", v) 6284 } 6285 6286 if v.AssociationId == nil || len(*v.AssociationId) == 0 { 6287 return &smithy.SerializationError{Err: fmt.Errorf("input member AssociationId must not be empty")} 6288 } 6289 if v.AssociationId != nil { 6290 if err := encoder.SetURI("AssociationId").String(*v.AssociationId); err != nil { 6291 return err 6292 } 6293 } 6294 6295 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6296 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6297 } 6298 if v.InstanceId != nil { 6299 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6300 return err 6301 } 6302 } 6303 6304 if len(v.ResourceType) > 0 { 6305 encoder.SetQuery("resourceType").String(string(v.ResourceType)) 6306 } 6307 6308 return nil 6309} 6310 6311func awsRestjson1_serializeOpDocumentUpdateInstanceStorageConfigInput(v *UpdateInstanceStorageConfigInput, value smithyjson.Value) error { 6312 object := value.Object() 6313 defer object.Close() 6314 6315 if v.StorageConfig != nil { 6316 ok := object.Key("StorageConfig") 6317 if err := awsRestjson1_serializeDocumentInstanceStorageConfig(v.StorageConfig, ok); err != nil { 6318 return err 6319 } 6320 } 6321 6322 return nil 6323} 6324 6325type awsRestjson1_serializeOpUpdateQueueHoursOfOperation struct { 6326} 6327 6328func (*awsRestjson1_serializeOpUpdateQueueHoursOfOperation) ID() string { 6329 return "OperationSerializer" 6330} 6331 6332func (m *awsRestjson1_serializeOpUpdateQueueHoursOfOperation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6333 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6334) { 6335 request, ok := in.Request.(*smithyhttp.Request) 6336 if !ok { 6337 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6338 } 6339 6340 input, ok := in.Parameters.(*UpdateQueueHoursOfOperationInput) 6341 _ = input 6342 if !ok { 6343 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6344 } 6345 6346 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/hours-of-operation") 6347 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6348 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6349 request.Method = "POST" 6350 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6351 if err != nil { 6352 return out, metadata, &smithy.SerializationError{Err: err} 6353 } 6354 6355 if err := awsRestjson1_serializeOpHttpBindingsUpdateQueueHoursOfOperationInput(input, restEncoder); err != nil { 6356 return out, metadata, &smithy.SerializationError{Err: err} 6357 } 6358 6359 restEncoder.SetHeader("Content-Type").String("application/json") 6360 6361 jsonEncoder := smithyjson.NewEncoder() 6362 if err := awsRestjson1_serializeOpDocumentUpdateQueueHoursOfOperationInput(input, jsonEncoder.Value); err != nil { 6363 return out, metadata, &smithy.SerializationError{Err: err} 6364 } 6365 6366 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6367 return out, metadata, &smithy.SerializationError{Err: err} 6368 } 6369 6370 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6371 return out, metadata, &smithy.SerializationError{Err: err} 6372 } 6373 in.Request = request 6374 6375 return next.HandleSerialize(ctx, in) 6376} 6377func awsRestjson1_serializeOpHttpBindingsUpdateQueueHoursOfOperationInput(v *UpdateQueueHoursOfOperationInput, encoder *httpbinding.Encoder) error { 6378 if v == nil { 6379 return fmt.Errorf("unsupported serialization of nil %T", v) 6380 } 6381 6382 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6383 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6384 } 6385 if v.InstanceId != nil { 6386 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6387 return err 6388 } 6389 } 6390 6391 if v.QueueId == nil || len(*v.QueueId) == 0 { 6392 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 6393 } 6394 if v.QueueId != nil { 6395 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 6396 return err 6397 } 6398 } 6399 6400 return nil 6401} 6402 6403func awsRestjson1_serializeOpDocumentUpdateQueueHoursOfOperationInput(v *UpdateQueueHoursOfOperationInput, value smithyjson.Value) error { 6404 object := value.Object() 6405 defer object.Close() 6406 6407 if v.HoursOfOperationId != nil { 6408 ok := object.Key("HoursOfOperationId") 6409 ok.String(*v.HoursOfOperationId) 6410 } 6411 6412 return nil 6413} 6414 6415type awsRestjson1_serializeOpUpdateQueueMaxContacts struct { 6416} 6417 6418func (*awsRestjson1_serializeOpUpdateQueueMaxContacts) ID() string { 6419 return "OperationSerializer" 6420} 6421 6422func (m *awsRestjson1_serializeOpUpdateQueueMaxContacts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6423 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6424) { 6425 request, ok := in.Request.(*smithyhttp.Request) 6426 if !ok { 6427 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6428 } 6429 6430 input, ok := in.Parameters.(*UpdateQueueMaxContactsInput) 6431 _ = input 6432 if !ok { 6433 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6434 } 6435 6436 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/max-contacts") 6437 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6438 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6439 request.Method = "POST" 6440 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6441 if err != nil { 6442 return out, metadata, &smithy.SerializationError{Err: err} 6443 } 6444 6445 if err := awsRestjson1_serializeOpHttpBindingsUpdateQueueMaxContactsInput(input, restEncoder); err != nil { 6446 return out, metadata, &smithy.SerializationError{Err: err} 6447 } 6448 6449 restEncoder.SetHeader("Content-Type").String("application/json") 6450 6451 jsonEncoder := smithyjson.NewEncoder() 6452 if err := awsRestjson1_serializeOpDocumentUpdateQueueMaxContactsInput(input, jsonEncoder.Value); err != nil { 6453 return out, metadata, &smithy.SerializationError{Err: err} 6454 } 6455 6456 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6457 return out, metadata, &smithy.SerializationError{Err: err} 6458 } 6459 6460 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6461 return out, metadata, &smithy.SerializationError{Err: err} 6462 } 6463 in.Request = request 6464 6465 return next.HandleSerialize(ctx, in) 6466} 6467func awsRestjson1_serializeOpHttpBindingsUpdateQueueMaxContactsInput(v *UpdateQueueMaxContactsInput, encoder *httpbinding.Encoder) error { 6468 if v == nil { 6469 return fmt.Errorf("unsupported serialization of nil %T", v) 6470 } 6471 6472 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6473 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6474 } 6475 if v.InstanceId != nil { 6476 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6477 return err 6478 } 6479 } 6480 6481 if v.QueueId == nil || len(*v.QueueId) == 0 { 6482 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 6483 } 6484 if v.QueueId != nil { 6485 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 6486 return err 6487 } 6488 } 6489 6490 return nil 6491} 6492 6493func awsRestjson1_serializeOpDocumentUpdateQueueMaxContactsInput(v *UpdateQueueMaxContactsInput, value smithyjson.Value) error { 6494 object := value.Object() 6495 defer object.Close() 6496 6497 { 6498 ok := object.Key("MaxContacts") 6499 ok.Integer(v.MaxContacts) 6500 } 6501 6502 return nil 6503} 6504 6505type awsRestjson1_serializeOpUpdateQueueName struct { 6506} 6507 6508func (*awsRestjson1_serializeOpUpdateQueueName) ID() string { 6509 return "OperationSerializer" 6510} 6511 6512func (m *awsRestjson1_serializeOpUpdateQueueName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6513 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6514) { 6515 request, ok := in.Request.(*smithyhttp.Request) 6516 if !ok { 6517 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6518 } 6519 6520 input, ok := in.Parameters.(*UpdateQueueNameInput) 6521 _ = input 6522 if !ok { 6523 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6524 } 6525 6526 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/name") 6527 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6528 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6529 request.Method = "POST" 6530 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6531 if err != nil { 6532 return out, metadata, &smithy.SerializationError{Err: err} 6533 } 6534 6535 if err := awsRestjson1_serializeOpHttpBindingsUpdateQueueNameInput(input, restEncoder); err != nil { 6536 return out, metadata, &smithy.SerializationError{Err: err} 6537 } 6538 6539 restEncoder.SetHeader("Content-Type").String("application/json") 6540 6541 jsonEncoder := smithyjson.NewEncoder() 6542 if err := awsRestjson1_serializeOpDocumentUpdateQueueNameInput(input, jsonEncoder.Value); err != nil { 6543 return out, metadata, &smithy.SerializationError{Err: err} 6544 } 6545 6546 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6547 return out, metadata, &smithy.SerializationError{Err: err} 6548 } 6549 6550 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6551 return out, metadata, &smithy.SerializationError{Err: err} 6552 } 6553 in.Request = request 6554 6555 return next.HandleSerialize(ctx, in) 6556} 6557func awsRestjson1_serializeOpHttpBindingsUpdateQueueNameInput(v *UpdateQueueNameInput, encoder *httpbinding.Encoder) error { 6558 if v == nil { 6559 return fmt.Errorf("unsupported serialization of nil %T", v) 6560 } 6561 6562 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6563 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6564 } 6565 if v.InstanceId != nil { 6566 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6567 return err 6568 } 6569 } 6570 6571 if v.QueueId == nil || len(*v.QueueId) == 0 { 6572 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 6573 } 6574 if v.QueueId != nil { 6575 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 6576 return err 6577 } 6578 } 6579 6580 return nil 6581} 6582 6583func awsRestjson1_serializeOpDocumentUpdateQueueNameInput(v *UpdateQueueNameInput, value smithyjson.Value) error { 6584 object := value.Object() 6585 defer object.Close() 6586 6587 if v.Description != nil { 6588 ok := object.Key("Description") 6589 ok.String(*v.Description) 6590 } 6591 6592 if v.Name != nil { 6593 ok := object.Key("Name") 6594 ok.String(*v.Name) 6595 } 6596 6597 return nil 6598} 6599 6600type awsRestjson1_serializeOpUpdateQueueOutboundCallerConfig struct { 6601} 6602 6603func (*awsRestjson1_serializeOpUpdateQueueOutboundCallerConfig) ID() string { 6604 return "OperationSerializer" 6605} 6606 6607func (m *awsRestjson1_serializeOpUpdateQueueOutboundCallerConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6608 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6609) { 6610 request, ok := in.Request.(*smithyhttp.Request) 6611 if !ok { 6612 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6613 } 6614 6615 input, ok := in.Parameters.(*UpdateQueueOutboundCallerConfigInput) 6616 _ = input 6617 if !ok { 6618 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6619 } 6620 6621 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/outbound-caller-config") 6622 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6623 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6624 request.Method = "POST" 6625 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6626 if err != nil { 6627 return out, metadata, &smithy.SerializationError{Err: err} 6628 } 6629 6630 if err := awsRestjson1_serializeOpHttpBindingsUpdateQueueOutboundCallerConfigInput(input, restEncoder); err != nil { 6631 return out, metadata, &smithy.SerializationError{Err: err} 6632 } 6633 6634 restEncoder.SetHeader("Content-Type").String("application/json") 6635 6636 jsonEncoder := smithyjson.NewEncoder() 6637 if err := awsRestjson1_serializeOpDocumentUpdateQueueOutboundCallerConfigInput(input, jsonEncoder.Value); err != nil { 6638 return out, metadata, &smithy.SerializationError{Err: err} 6639 } 6640 6641 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6642 return out, metadata, &smithy.SerializationError{Err: err} 6643 } 6644 6645 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6646 return out, metadata, &smithy.SerializationError{Err: err} 6647 } 6648 in.Request = request 6649 6650 return next.HandleSerialize(ctx, in) 6651} 6652func awsRestjson1_serializeOpHttpBindingsUpdateQueueOutboundCallerConfigInput(v *UpdateQueueOutboundCallerConfigInput, encoder *httpbinding.Encoder) error { 6653 if v == nil { 6654 return fmt.Errorf("unsupported serialization of nil %T", v) 6655 } 6656 6657 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6658 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6659 } 6660 if v.InstanceId != nil { 6661 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6662 return err 6663 } 6664 } 6665 6666 if v.QueueId == nil || len(*v.QueueId) == 0 { 6667 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 6668 } 6669 if v.QueueId != nil { 6670 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 6671 return err 6672 } 6673 } 6674 6675 return nil 6676} 6677 6678func awsRestjson1_serializeOpDocumentUpdateQueueOutboundCallerConfigInput(v *UpdateQueueOutboundCallerConfigInput, value smithyjson.Value) error { 6679 object := value.Object() 6680 defer object.Close() 6681 6682 if v.OutboundCallerConfig != nil { 6683 ok := object.Key("OutboundCallerConfig") 6684 if err := awsRestjson1_serializeDocumentOutboundCallerConfig(v.OutboundCallerConfig, ok); err != nil { 6685 return err 6686 } 6687 } 6688 6689 return nil 6690} 6691 6692type awsRestjson1_serializeOpUpdateQueueStatus struct { 6693} 6694 6695func (*awsRestjson1_serializeOpUpdateQueueStatus) ID() string { 6696 return "OperationSerializer" 6697} 6698 6699func (m *awsRestjson1_serializeOpUpdateQueueStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6700 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6701) { 6702 request, ok := in.Request.(*smithyhttp.Request) 6703 if !ok { 6704 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6705 } 6706 6707 input, ok := in.Parameters.(*UpdateQueueStatusInput) 6708 _ = input 6709 if !ok { 6710 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6711 } 6712 6713 opPath, opQuery := httpbinding.SplitURI("/queues/{InstanceId}/{QueueId}/status") 6714 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6715 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6716 request.Method = "POST" 6717 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6718 if err != nil { 6719 return out, metadata, &smithy.SerializationError{Err: err} 6720 } 6721 6722 if err := awsRestjson1_serializeOpHttpBindingsUpdateQueueStatusInput(input, restEncoder); err != nil { 6723 return out, metadata, &smithy.SerializationError{Err: err} 6724 } 6725 6726 restEncoder.SetHeader("Content-Type").String("application/json") 6727 6728 jsonEncoder := smithyjson.NewEncoder() 6729 if err := awsRestjson1_serializeOpDocumentUpdateQueueStatusInput(input, jsonEncoder.Value); err != nil { 6730 return out, metadata, &smithy.SerializationError{Err: err} 6731 } 6732 6733 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6734 return out, metadata, &smithy.SerializationError{Err: err} 6735 } 6736 6737 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6738 return out, metadata, &smithy.SerializationError{Err: err} 6739 } 6740 in.Request = request 6741 6742 return next.HandleSerialize(ctx, in) 6743} 6744func awsRestjson1_serializeOpHttpBindingsUpdateQueueStatusInput(v *UpdateQueueStatusInput, encoder *httpbinding.Encoder) error { 6745 if v == nil { 6746 return fmt.Errorf("unsupported serialization of nil %T", v) 6747 } 6748 6749 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6750 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6751 } 6752 if v.InstanceId != nil { 6753 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6754 return err 6755 } 6756 } 6757 6758 if v.QueueId == nil || len(*v.QueueId) == 0 { 6759 return &smithy.SerializationError{Err: fmt.Errorf("input member QueueId must not be empty")} 6760 } 6761 if v.QueueId != nil { 6762 if err := encoder.SetURI("QueueId").String(*v.QueueId); err != nil { 6763 return err 6764 } 6765 } 6766 6767 return nil 6768} 6769 6770func awsRestjson1_serializeOpDocumentUpdateQueueStatusInput(v *UpdateQueueStatusInput, value smithyjson.Value) error { 6771 object := value.Object() 6772 defer object.Close() 6773 6774 if len(v.Status) > 0 { 6775 ok := object.Key("Status") 6776 ok.String(string(v.Status)) 6777 } 6778 6779 return nil 6780} 6781 6782type awsRestjson1_serializeOpUpdateQuickConnectConfig struct { 6783} 6784 6785func (*awsRestjson1_serializeOpUpdateQuickConnectConfig) ID() string { 6786 return "OperationSerializer" 6787} 6788 6789func (m *awsRestjson1_serializeOpUpdateQuickConnectConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6790 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6791) { 6792 request, ok := in.Request.(*smithyhttp.Request) 6793 if !ok { 6794 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6795 } 6796 6797 input, ok := in.Parameters.(*UpdateQuickConnectConfigInput) 6798 _ = input 6799 if !ok { 6800 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6801 } 6802 6803 opPath, opQuery := httpbinding.SplitURI("/quick-connects/{InstanceId}/{QuickConnectId}/config") 6804 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6805 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6806 request.Method = "POST" 6807 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6808 if err != nil { 6809 return out, metadata, &smithy.SerializationError{Err: err} 6810 } 6811 6812 if err := awsRestjson1_serializeOpHttpBindingsUpdateQuickConnectConfigInput(input, restEncoder); err != nil { 6813 return out, metadata, &smithy.SerializationError{Err: err} 6814 } 6815 6816 restEncoder.SetHeader("Content-Type").String("application/json") 6817 6818 jsonEncoder := smithyjson.NewEncoder() 6819 if err := awsRestjson1_serializeOpDocumentUpdateQuickConnectConfigInput(input, jsonEncoder.Value); err != nil { 6820 return out, metadata, &smithy.SerializationError{Err: err} 6821 } 6822 6823 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6824 return out, metadata, &smithy.SerializationError{Err: err} 6825 } 6826 6827 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6828 return out, metadata, &smithy.SerializationError{Err: err} 6829 } 6830 in.Request = request 6831 6832 return next.HandleSerialize(ctx, in) 6833} 6834func awsRestjson1_serializeOpHttpBindingsUpdateQuickConnectConfigInput(v *UpdateQuickConnectConfigInput, encoder *httpbinding.Encoder) error { 6835 if v == nil { 6836 return fmt.Errorf("unsupported serialization of nil %T", v) 6837 } 6838 6839 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6840 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6841 } 6842 if v.InstanceId != nil { 6843 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6844 return err 6845 } 6846 } 6847 6848 if v.QuickConnectId == nil || len(*v.QuickConnectId) == 0 { 6849 return &smithy.SerializationError{Err: fmt.Errorf("input member QuickConnectId must not be empty")} 6850 } 6851 if v.QuickConnectId != nil { 6852 if err := encoder.SetURI("QuickConnectId").String(*v.QuickConnectId); err != nil { 6853 return err 6854 } 6855 } 6856 6857 return nil 6858} 6859 6860func awsRestjson1_serializeOpDocumentUpdateQuickConnectConfigInput(v *UpdateQuickConnectConfigInput, value smithyjson.Value) error { 6861 object := value.Object() 6862 defer object.Close() 6863 6864 if v.QuickConnectConfig != nil { 6865 ok := object.Key("QuickConnectConfig") 6866 if err := awsRestjson1_serializeDocumentQuickConnectConfig(v.QuickConnectConfig, ok); err != nil { 6867 return err 6868 } 6869 } 6870 6871 return nil 6872} 6873 6874type awsRestjson1_serializeOpUpdateQuickConnectName struct { 6875} 6876 6877func (*awsRestjson1_serializeOpUpdateQuickConnectName) ID() string { 6878 return "OperationSerializer" 6879} 6880 6881func (m *awsRestjson1_serializeOpUpdateQuickConnectName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6882 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6883) { 6884 request, ok := in.Request.(*smithyhttp.Request) 6885 if !ok { 6886 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6887 } 6888 6889 input, ok := in.Parameters.(*UpdateQuickConnectNameInput) 6890 _ = input 6891 if !ok { 6892 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6893 } 6894 6895 opPath, opQuery := httpbinding.SplitURI("/quick-connects/{InstanceId}/{QuickConnectId}/name") 6896 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6897 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6898 request.Method = "POST" 6899 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6900 if err != nil { 6901 return out, metadata, &smithy.SerializationError{Err: err} 6902 } 6903 6904 if err := awsRestjson1_serializeOpHttpBindingsUpdateQuickConnectNameInput(input, restEncoder); err != nil { 6905 return out, metadata, &smithy.SerializationError{Err: err} 6906 } 6907 6908 restEncoder.SetHeader("Content-Type").String("application/json") 6909 6910 jsonEncoder := smithyjson.NewEncoder() 6911 if err := awsRestjson1_serializeOpDocumentUpdateQuickConnectNameInput(input, jsonEncoder.Value); err != nil { 6912 return out, metadata, &smithy.SerializationError{Err: err} 6913 } 6914 6915 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6916 return out, metadata, &smithy.SerializationError{Err: err} 6917 } 6918 6919 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6920 return out, metadata, &smithy.SerializationError{Err: err} 6921 } 6922 in.Request = request 6923 6924 return next.HandleSerialize(ctx, in) 6925} 6926func awsRestjson1_serializeOpHttpBindingsUpdateQuickConnectNameInput(v *UpdateQuickConnectNameInput, encoder *httpbinding.Encoder) error { 6927 if v == nil { 6928 return fmt.Errorf("unsupported serialization of nil %T", v) 6929 } 6930 6931 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 6932 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 6933 } 6934 if v.InstanceId != nil { 6935 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 6936 return err 6937 } 6938 } 6939 6940 if v.QuickConnectId == nil || len(*v.QuickConnectId) == 0 { 6941 return &smithy.SerializationError{Err: fmt.Errorf("input member QuickConnectId must not be empty")} 6942 } 6943 if v.QuickConnectId != nil { 6944 if err := encoder.SetURI("QuickConnectId").String(*v.QuickConnectId); err != nil { 6945 return err 6946 } 6947 } 6948 6949 return nil 6950} 6951 6952func awsRestjson1_serializeOpDocumentUpdateQuickConnectNameInput(v *UpdateQuickConnectNameInput, value smithyjson.Value) error { 6953 object := value.Object() 6954 defer object.Close() 6955 6956 if v.Description != nil { 6957 ok := object.Key("Description") 6958 ok.String(*v.Description) 6959 } 6960 6961 if v.Name != nil { 6962 ok := object.Key("Name") 6963 ok.String(*v.Name) 6964 } 6965 6966 return nil 6967} 6968 6969type awsRestjson1_serializeOpUpdateRoutingProfileConcurrency struct { 6970} 6971 6972func (*awsRestjson1_serializeOpUpdateRoutingProfileConcurrency) ID() string { 6973 return "OperationSerializer" 6974} 6975 6976func (m *awsRestjson1_serializeOpUpdateRoutingProfileConcurrency) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6977 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6978) { 6979 request, ok := in.Request.(*smithyhttp.Request) 6980 if !ok { 6981 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6982 } 6983 6984 input, ok := in.Parameters.(*UpdateRoutingProfileConcurrencyInput) 6985 _ = input 6986 if !ok { 6987 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6988 } 6989 6990 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}/concurrency") 6991 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 6992 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 6993 request.Method = "POST" 6994 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6995 if err != nil { 6996 return out, metadata, &smithy.SerializationError{Err: err} 6997 } 6998 6999 if err := awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileConcurrencyInput(input, restEncoder); err != nil { 7000 return out, metadata, &smithy.SerializationError{Err: err} 7001 } 7002 7003 restEncoder.SetHeader("Content-Type").String("application/json") 7004 7005 jsonEncoder := smithyjson.NewEncoder() 7006 if err := awsRestjson1_serializeOpDocumentUpdateRoutingProfileConcurrencyInput(input, jsonEncoder.Value); err != nil { 7007 return out, metadata, &smithy.SerializationError{Err: err} 7008 } 7009 7010 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7011 return out, metadata, &smithy.SerializationError{Err: err} 7012 } 7013 7014 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7015 return out, metadata, &smithy.SerializationError{Err: err} 7016 } 7017 in.Request = request 7018 7019 return next.HandleSerialize(ctx, in) 7020} 7021func awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileConcurrencyInput(v *UpdateRoutingProfileConcurrencyInput, encoder *httpbinding.Encoder) error { 7022 if v == nil { 7023 return fmt.Errorf("unsupported serialization of nil %T", v) 7024 } 7025 7026 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7027 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7028 } 7029 if v.InstanceId != nil { 7030 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7031 return err 7032 } 7033 } 7034 7035 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 7036 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 7037 } 7038 if v.RoutingProfileId != nil { 7039 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 7040 return err 7041 } 7042 } 7043 7044 return nil 7045} 7046 7047func awsRestjson1_serializeOpDocumentUpdateRoutingProfileConcurrencyInput(v *UpdateRoutingProfileConcurrencyInput, value smithyjson.Value) error { 7048 object := value.Object() 7049 defer object.Close() 7050 7051 if v.MediaConcurrencies != nil { 7052 ok := object.Key("MediaConcurrencies") 7053 if err := awsRestjson1_serializeDocumentMediaConcurrencies(v.MediaConcurrencies, ok); err != nil { 7054 return err 7055 } 7056 } 7057 7058 return nil 7059} 7060 7061type awsRestjson1_serializeOpUpdateRoutingProfileDefaultOutboundQueue struct { 7062} 7063 7064func (*awsRestjson1_serializeOpUpdateRoutingProfileDefaultOutboundQueue) ID() string { 7065 return "OperationSerializer" 7066} 7067 7068func (m *awsRestjson1_serializeOpUpdateRoutingProfileDefaultOutboundQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7069 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7070) { 7071 request, ok := in.Request.(*smithyhttp.Request) 7072 if !ok { 7073 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7074 } 7075 7076 input, ok := in.Parameters.(*UpdateRoutingProfileDefaultOutboundQueueInput) 7077 _ = input 7078 if !ok { 7079 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7080 } 7081 7082 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}/default-outbound-queue") 7083 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7084 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7085 request.Method = "POST" 7086 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7087 if err != nil { 7088 return out, metadata, &smithy.SerializationError{Err: err} 7089 } 7090 7091 if err := awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileDefaultOutboundQueueInput(input, restEncoder); err != nil { 7092 return out, metadata, &smithy.SerializationError{Err: err} 7093 } 7094 7095 restEncoder.SetHeader("Content-Type").String("application/json") 7096 7097 jsonEncoder := smithyjson.NewEncoder() 7098 if err := awsRestjson1_serializeOpDocumentUpdateRoutingProfileDefaultOutboundQueueInput(input, jsonEncoder.Value); err != nil { 7099 return out, metadata, &smithy.SerializationError{Err: err} 7100 } 7101 7102 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7103 return out, metadata, &smithy.SerializationError{Err: err} 7104 } 7105 7106 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7107 return out, metadata, &smithy.SerializationError{Err: err} 7108 } 7109 in.Request = request 7110 7111 return next.HandleSerialize(ctx, in) 7112} 7113func awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileDefaultOutboundQueueInput(v *UpdateRoutingProfileDefaultOutboundQueueInput, encoder *httpbinding.Encoder) error { 7114 if v == nil { 7115 return fmt.Errorf("unsupported serialization of nil %T", v) 7116 } 7117 7118 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7119 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7120 } 7121 if v.InstanceId != nil { 7122 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7123 return err 7124 } 7125 } 7126 7127 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 7128 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 7129 } 7130 if v.RoutingProfileId != nil { 7131 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 7132 return err 7133 } 7134 } 7135 7136 return nil 7137} 7138 7139func awsRestjson1_serializeOpDocumentUpdateRoutingProfileDefaultOutboundQueueInput(v *UpdateRoutingProfileDefaultOutboundQueueInput, value smithyjson.Value) error { 7140 object := value.Object() 7141 defer object.Close() 7142 7143 if v.DefaultOutboundQueueId != nil { 7144 ok := object.Key("DefaultOutboundQueueId") 7145 ok.String(*v.DefaultOutboundQueueId) 7146 } 7147 7148 return nil 7149} 7150 7151type awsRestjson1_serializeOpUpdateRoutingProfileName struct { 7152} 7153 7154func (*awsRestjson1_serializeOpUpdateRoutingProfileName) ID() string { 7155 return "OperationSerializer" 7156} 7157 7158func (m *awsRestjson1_serializeOpUpdateRoutingProfileName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7159 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7160) { 7161 request, ok := in.Request.(*smithyhttp.Request) 7162 if !ok { 7163 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7164 } 7165 7166 input, ok := in.Parameters.(*UpdateRoutingProfileNameInput) 7167 _ = input 7168 if !ok { 7169 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7170 } 7171 7172 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}/name") 7173 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7174 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7175 request.Method = "POST" 7176 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7177 if err != nil { 7178 return out, metadata, &smithy.SerializationError{Err: err} 7179 } 7180 7181 if err := awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileNameInput(input, restEncoder); err != nil { 7182 return out, metadata, &smithy.SerializationError{Err: err} 7183 } 7184 7185 restEncoder.SetHeader("Content-Type").String("application/json") 7186 7187 jsonEncoder := smithyjson.NewEncoder() 7188 if err := awsRestjson1_serializeOpDocumentUpdateRoutingProfileNameInput(input, jsonEncoder.Value); err != nil { 7189 return out, metadata, &smithy.SerializationError{Err: err} 7190 } 7191 7192 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7193 return out, metadata, &smithy.SerializationError{Err: err} 7194 } 7195 7196 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7197 return out, metadata, &smithy.SerializationError{Err: err} 7198 } 7199 in.Request = request 7200 7201 return next.HandleSerialize(ctx, in) 7202} 7203func awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileNameInput(v *UpdateRoutingProfileNameInput, encoder *httpbinding.Encoder) error { 7204 if v == nil { 7205 return fmt.Errorf("unsupported serialization of nil %T", v) 7206 } 7207 7208 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7209 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7210 } 7211 if v.InstanceId != nil { 7212 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7213 return err 7214 } 7215 } 7216 7217 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 7218 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 7219 } 7220 if v.RoutingProfileId != nil { 7221 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 7222 return err 7223 } 7224 } 7225 7226 return nil 7227} 7228 7229func awsRestjson1_serializeOpDocumentUpdateRoutingProfileNameInput(v *UpdateRoutingProfileNameInput, value smithyjson.Value) error { 7230 object := value.Object() 7231 defer object.Close() 7232 7233 if v.Description != nil { 7234 ok := object.Key("Description") 7235 ok.String(*v.Description) 7236 } 7237 7238 if v.Name != nil { 7239 ok := object.Key("Name") 7240 ok.String(*v.Name) 7241 } 7242 7243 return nil 7244} 7245 7246type awsRestjson1_serializeOpUpdateRoutingProfileQueues struct { 7247} 7248 7249func (*awsRestjson1_serializeOpUpdateRoutingProfileQueues) ID() string { 7250 return "OperationSerializer" 7251} 7252 7253func (m *awsRestjson1_serializeOpUpdateRoutingProfileQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7254 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7255) { 7256 request, ok := in.Request.(*smithyhttp.Request) 7257 if !ok { 7258 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7259 } 7260 7261 input, ok := in.Parameters.(*UpdateRoutingProfileQueuesInput) 7262 _ = input 7263 if !ok { 7264 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7265 } 7266 7267 opPath, opQuery := httpbinding.SplitURI("/routing-profiles/{InstanceId}/{RoutingProfileId}/queues") 7268 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7269 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7270 request.Method = "POST" 7271 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7272 if err != nil { 7273 return out, metadata, &smithy.SerializationError{Err: err} 7274 } 7275 7276 if err := awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileQueuesInput(input, restEncoder); err != nil { 7277 return out, metadata, &smithy.SerializationError{Err: err} 7278 } 7279 7280 restEncoder.SetHeader("Content-Type").String("application/json") 7281 7282 jsonEncoder := smithyjson.NewEncoder() 7283 if err := awsRestjson1_serializeOpDocumentUpdateRoutingProfileQueuesInput(input, jsonEncoder.Value); err != nil { 7284 return out, metadata, &smithy.SerializationError{Err: err} 7285 } 7286 7287 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7288 return out, metadata, &smithy.SerializationError{Err: err} 7289 } 7290 7291 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7292 return out, metadata, &smithy.SerializationError{Err: err} 7293 } 7294 in.Request = request 7295 7296 return next.HandleSerialize(ctx, in) 7297} 7298func awsRestjson1_serializeOpHttpBindingsUpdateRoutingProfileQueuesInput(v *UpdateRoutingProfileQueuesInput, encoder *httpbinding.Encoder) error { 7299 if v == nil { 7300 return fmt.Errorf("unsupported serialization of nil %T", v) 7301 } 7302 7303 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7304 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7305 } 7306 if v.InstanceId != nil { 7307 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7308 return err 7309 } 7310 } 7311 7312 if v.RoutingProfileId == nil || len(*v.RoutingProfileId) == 0 { 7313 return &smithy.SerializationError{Err: fmt.Errorf("input member RoutingProfileId must not be empty")} 7314 } 7315 if v.RoutingProfileId != nil { 7316 if err := encoder.SetURI("RoutingProfileId").String(*v.RoutingProfileId); err != nil { 7317 return err 7318 } 7319 } 7320 7321 return nil 7322} 7323 7324func awsRestjson1_serializeOpDocumentUpdateRoutingProfileQueuesInput(v *UpdateRoutingProfileQueuesInput, value smithyjson.Value) error { 7325 object := value.Object() 7326 defer object.Close() 7327 7328 if v.QueueConfigs != nil { 7329 ok := object.Key("QueueConfigs") 7330 if err := awsRestjson1_serializeDocumentRoutingProfileQueueConfigList(v.QueueConfigs, ok); err != nil { 7331 return err 7332 } 7333 } 7334 7335 return nil 7336} 7337 7338type awsRestjson1_serializeOpUpdateUserHierarchy struct { 7339} 7340 7341func (*awsRestjson1_serializeOpUpdateUserHierarchy) ID() string { 7342 return "OperationSerializer" 7343} 7344 7345func (m *awsRestjson1_serializeOpUpdateUserHierarchy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7346 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7347) { 7348 request, ok := in.Request.(*smithyhttp.Request) 7349 if !ok { 7350 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7351 } 7352 7353 input, ok := in.Parameters.(*UpdateUserHierarchyInput) 7354 _ = input 7355 if !ok { 7356 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7357 } 7358 7359 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}/{UserId}/hierarchy") 7360 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7361 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7362 request.Method = "POST" 7363 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7364 if err != nil { 7365 return out, metadata, &smithy.SerializationError{Err: err} 7366 } 7367 7368 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserHierarchyInput(input, restEncoder); err != nil { 7369 return out, metadata, &smithy.SerializationError{Err: err} 7370 } 7371 7372 restEncoder.SetHeader("Content-Type").String("application/json") 7373 7374 jsonEncoder := smithyjson.NewEncoder() 7375 if err := awsRestjson1_serializeOpDocumentUpdateUserHierarchyInput(input, jsonEncoder.Value); err != nil { 7376 return out, metadata, &smithy.SerializationError{Err: err} 7377 } 7378 7379 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7380 return out, metadata, &smithy.SerializationError{Err: err} 7381 } 7382 7383 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7384 return out, metadata, &smithy.SerializationError{Err: err} 7385 } 7386 in.Request = request 7387 7388 return next.HandleSerialize(ctx, in) 7389} 7390func awsRestjson1_serializeOpHttpBindingsUpdateUserHierarchyInput(v *UpdateUserHierarchyInput, encoder *httpbinding.Encoder) error { 7391 if v == nil { 7392 return fmt.Errorf("unsupported serialization of nil %T", v) 7393 } 7394 7395 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7396 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7397 } 7398 if v.InstanceId != nil { 7399 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7400 return err 7401 } 7402 } 7403 7404 if v.UserId == nil || len(*v.UserId) == 0 { 7405 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 7406 } 7407 if v.UserId != nil { 7408 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 7409 return err 7410 } 7411 } 7412 7413 return nil 7414} 7415 7416func awsRestjson1_serializeOpDocumentUpdateUserHierarchyInput(v *UpdateUserHierarchyInput, value smithyjson.Value) error { 7417 object := value.Object() 7418 defer object.Close() 7419 7420 if v.HierarchyGroupId != nil { 7421 ok := object.Key("HierarchyGroupId") 7422 ok.String(*v.HierarchyGroupId) 7423 } 7424 7425 return nil 7426} 7427 7428type awsRestjson1_serializeOpUpdateUserHierarchyGroupName struct { 7429} 7430 7431func (*awsRestjson1_serializeOpUpdateUserHierarchyGroupName) ID() string { 7432 return "OperationSerializer" 7433} 7434 7435func (m *awsRestjson1_serializeOpUpdateUserHierarchyGroupName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7436 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7437) { 7438 request, ok := in.Request.(*smithyhttp.Request) 7439 if !ok { 7440 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7441 } 7442 7443 input, ok := in.Parameters.(*UpdateUserHierarchyGroupNameInput) 7444 _ = input 7445 if !ok { 7446 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7447 } 7448 7449 opPath, opQuery := httpbinding.SplitURI("/user-hierarchy-groups/{InstanceId}/{HierarchyGroupId}/name") 7450 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7451 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7452 request.Method = "POST" 7453 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7454 if err != nil { 7455 return out, metadata, &smithy.SerializationError{Err: err} 7456 } 7457 7458 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserHierarchyGroupNameInput(input, restEncoder); err != nil { 7459 return out, metadata, &smithy.SerializationError{Err: err} 7460 } 7461 7462 restEncoder.SetHeader("Content-Type").String("application/json") 7463 7464 jsonEncoder := smithyjson.NewEncoder() 7465 if err := awsRestjson1_serializeOpDocumentUpdateUserHierarchyGroupNameInput(input, jsonEncoder.Value); err != nil { 7466 return out, metadata, &smithy.SerializationError{Err: err} 7467 } 7468 7469 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7470 return out, metadata, &smithy.SerializationError{Err: err} 7471 } 7472 7473 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7474 return out, metadata, &smithy.SerializationError{Err: err} 7475 } 7476 in.Request = request 7477 7478 return next.HandleSerialize(ctx, in) 7479} 7480func awsRestjson1_serializeOpHttpBindingsUpdateUserHierarchyGroupNameInput(v *UpdateUserHierarchyGroupNameInput, encoder *httpbinding.Encoder) error { 7481 if v == nil { 7482 return fmt.Errorf("unsupported serialization of nil %T", v) 7483 } 7484 7485 if v.HierarchyGroupId == nil || len(*v.HierarchyGroupId) == 0 { 7486 return &smithy.SerializationError{Err: fmt.Errorf("input member HierarchyGroupId must not be empty")} 7487 } 7488 if v.HierarchyGroupId != nil { 7489 if err := encoder.SetURI("HierarchyGroupId").String(*v.HierarchyGroupId); err != nil { 7490 return err 7491 } 7492 } 7493 7494 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7495 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7496 } 7497 if v.InstanceId != nil { 7498 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7499 return err 7500 } 7501 } 7502 7503 return nil 7504} 7505 7506func awsRestjson1_serializeOpDocumentUpdateUserHierarchyGroupNameInput(v *UpdateUserHierarchyGroupNameInput, value smithyjson.Value) error { 7507 object := value.Object() 7508 defer object.Close() 7509 7510 if v.Name != nil { 7511 ok := object.Key("Name") 7512 ok.String(*v.Name) 7513 } 7514 7515 return nil 7516} 7517 7518type awsRestjson1_serializeOpUpdateUserHierarchyStructure struct { 7519} 7520 7521func (*awsRestjson1_serializeOpUpdateUserHierarchyStructure) ID() string { 7522 return "OperationSerializer" 7523} 7524 7525func (m *awsRestjson1_serializeOpUpdateUserHierarchyStructure) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7526 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7527) { 7528 request, ok := in.Request.(*smithyhttp.Request) 7529 if !ok { 7530 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7531 } 7532 7533 input, ok := in.Parameters.(*UpdateUserHierarchyStructureInput) 7534 _ = input 7535 if !ok { 7536 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7537 } 7538 7539 opPath, opQuery := httpbinding.SplitURI("/user-hierarchy-structure/{InstanceId}") 7540 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7541 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7542 request.Method = "POST" 7543 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7544 if err != nil { 7545 return out, metadata, &smithy.SerializationError{Err: err} 7546 } 7547 7548 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserHierarchyStructureInput(input, restEncoder); err != nil { 7549 return out, metadata, &smithy.SerializationError{Err: err} 7550 } 7551 7552 restEncoder.SetHeader("Content-Type").String("application/json") 7553 7554 jsonEncoder := smithyjson.NewEncoder() 7555 if err := awsRestjson1_serializeOpDocumentUpdateUserHierarchyStructureInput(input, jsonEncoder.Value); err != nil { 7556 return out, metadata, &smithy.SerializationError{Err: err} 7557 } 7558 7559 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7560 return out, metadata, &smithy.SerializationError{Err: err} 7561 } 7562 7563 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7564 return out, metadata, &smithy.SerializationError{Err: err} 7565 } 7566 in.Request = request 7567 7568 return next.HandleSerialize(ctx, in) 7569} 7570func awsRestjson1_serializeOpHttpBindingsUpdateUserHierarchyStructureInput(v *UpdateUserHierarchyStructureInput, encoder *httpbinding.Encoder) error { 7571 if v == nil { 7572 return fmt.Errorf("unsupported serialization of nil %T", v) 7573 } 7574 7575 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7576 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7577 } 7578 if v.InstanceId != nil { 7579 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7580 return err 7581 } 7582 } 7583 7584 return nil 7585} 7586 7587func awsRestjson1_serializeOpDocumentUpdateUserHierarchyStructureInput(v *UpdateUserHierarchyStructureInput, value smithyjson.Value) error { 7588 object := value.Object() 7589 defer object.Close() 7590 7591 if v.HierarchyStructure != nil { 7592 ok := object.Key("HierarchyStructure") 7593 if err := awsRestjson1_serializeDocumentHierarchyStructureUpdate(v.HierarchyStructure, ok); err != nil { 7594 return err 7595 } 7596 } 7597 7598 return nil 7599} 7600 7601type awsRestjson1_serializeOpUpdateUserIdentityInfo struct { 7602} 7603 7604func (*awsRestjson1_serializeOpUpdateUserIdentityInfo) ID() string { 7605 return "OperationSerializer" 7606} 7607 7608func (m *awsRestjson1_serializeOpUpdateUserIdentityInfo) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7609 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7610) { 7611 request, ok := in.Request.(*smithyhttp.Request) 7612 if !ok { 7613 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7614 } 7615 7616 input, ok := in.Parameters.(*UpdateUserIdentityInfoInput) 7617 _ = input 7618 if !ok { 7619 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7620 } 7621 7622 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}/{UserId}/identity-info") 7623 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7624 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7625 request.Method = "POST" 7626 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7627 if err != nil { 7628 return out, metadata, &smithy.SerializationError{Err: err} 7629 } 7630 7631 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserIdentityInfoInput(input, restEncoder); err != nil { 7632 return out, metadata, &smithy.SerializationError{Err: err} 7633 } 7634 7635 restEncoder.SetHeader("Content-Type").String("application/json") 7636 7637 jsonEncoder := smithyjson.NewEncoder() 7638 if err := awsRestjson1_serializeOpDocumentUpdateUserIdentityInfoInput(input, jsonEncoder.Value); err != nil { 7639 return out, metadata, &smithy.SerializationError{Err: err} 7640 } 7641 7642 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7643 return out, metadata, &smithy.SerializationError{Err: err} 7644 } 7645 7646 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7647 return out, metadata, &smithy.SerializationError{Err: err} 7648 } 7649 in.Request = request 7650 7651 return next.HandleSerialize(ctx, in) 7652} 7653func awsRestjson1_serializeOpHttpBindingsUpdateUserIdentityInfoInput(v *UpdateUserIdentityInfoInput, encoder *httpbinding.Encoder) error { 7654 if v == nil { 7655 return fmt.Errorf("unsupported serialization of nil %T", v) 7656 } 7657 7658 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7659 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7660 } 7661 if v.InstanceId != nil { 7662 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7663 return err 7664 } 7665 } 7666 7667 if v.UserId == nil || len(*v.UserId) == 0 { 7668 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 7669 } 7670 if v.UserId != nil { 7671 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 7672 return err 7673 } 7674 } 7675 7676 return nil 7677} 7678 7679func awsRestjson1_serializeOpDocumentUpdateUserIdentityInfoInput(v *UpdateUserIdentityInfoInput, value smithyjson.Value) error { 7680 object := value.Object() 7681 defer object.Close() 7682 7683 if v.IdentityInfo != nil { 7684 ok := object.Key("IdentityInfo") 7685 if err := awsRestjson1_serializeDocumentUserIdentityInfo(v.IdentityInfo, ok); err != nil { 7686 return err 7687 } 7688 } 7689 7690 return nil 7691} 7692 7693type awsRestjson1_serializeOpUpdateUserPhoneConfig struct { 7694} 7695 7696func (*awsRestjson1_serializeOpUpdateUserPhoneConfig) ID() string { 7697 return "OperationSerializer" 7698} 7699 7700func (m *awsRestjson1_serializeOpUpdateUserPhoneConfig) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7701 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7702) { 7703 request, ok := in.Request.(*smithyhttp.Request) 7704 if !ok { 7705 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7706 } 7707 7708 input, ok := in.Parameters.(*UpdateUserPhoneConfigInput) 7709 _ = input 7710 if !ok { 7711 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7712 } 7713 7714 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}/{UserId}/phone-config") 7715 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7716 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7717 request.Method = "POST" 7718 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7719 if err != nil { 7720 return out, metadata, &smithy.SerializationError{Err: err} 7721 } 7722 7723 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserPhoneConfigInput(input, restEncoder); err != nil { 7724 return out, metadata, &smithy.SerializationError{Err: err} 7725 } 7726 7727 restEncoder.SetHeader("Content-Type").String("application/json") 7728 7729 jsonEncoder := smithyjson.NewEncoder() 7730 if err := awsRestjson1_serializeOpDocumentUpdateUserPhoneConfigInput(input, jsonEncoder.Value); err != nil { 7731 return out, metadata, &smithy.SerializationError{Err: err} 7732 } 7733 7734 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7735 return out, metadata, &smithy.SerializationError{Err: err} 7736 } 7737 7738 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7739 return out, metadata, &smithy.SerializationError{Err: err} 7740 } 7741 in.Request = request 7742 7743 return next.HandleSerialize(ctx, in) 7744} 7745func awsRestjson1_serializeOpHttpBindingsUpdateUserPhoneConfigInput(v *UpdateUserPhoneConfigInput, encoder *httpbinding.Encoder) error { 7746 if v == nil { 7747 return fmt.Errorf("unsupported serialization of nil %T", v) 7748 } 7749 7750 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7751 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7752 } 7753 if v.InstanceId != nil { 7754 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7755 return err 7756 } 7757 } 7758 7759 if v.UserId == nil || len(*v.UserId) == 0 { 7760 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 7761 } 7762 if v.UserId != nil { 7763 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 7764 return err 7765 } 7766 } 7767 7768 return nil 7769} 7770 7771func awsRestjson1_serializeOpDocumentUpdateUserPhoneConfigInput(v *UpdateUserPhoneConfigInput, value smithyjson.Value) error { 7772 object := value.Object() 7773 defer object.Close() 7774 7775 if v.PhoneConfig != nil { 7776 ok := object.Key("PhoneConfig") 7777 if err := awsRestjson1_serializeDocumentUserPhoneConfig(v.PhoneConfig, ok); err != nil { 7778 return err 7779 } 7780 } 7781 7782 return nil 7783} 7784 7785type awsRestjson1_serializeOpUpdateUserRoutingProfile struct { 7786} 7787 7788func (*awsRestjson1_serializeOpUpdateUserRoutingProfile) ID() string { 7789 return "OperationSerializer" 7790} 7791 7792func (m *awsRestjson1_serializeOpUpdateUserRoutingProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7793 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7794) { 7795 request, ok := in.Request.(*smithyhttp.Request) 7796 if !ok { 7797 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7798 } 7799 7800 input, ok := in.Parameters.(*UpdateUserRoutingProfileInput) 7801 _ = input 7802 if !ok { 7803 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7804 } 7805 7806 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}/{UserId}/routing-profile") 7807 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7808 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7809 request.Method = "POST" 7810 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7811 if err != nil { 7812 return out, metadata, &smithy.SerializationError{Err: err} 7813 } 7814 7815 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserRoutingProfileInput(input, restEncoder); err != nil { 7816 return out, metadata, &smithy.SerializationError{Err: err} 7817 } 7818 7819 restEncoder.SetHeader("Content-Type").String("application/json") 7820 7821 jsonEncoder := smithyjson.NewEncoder() 7822 if err := awsRestjson1_serializeOpDocumentUpdateUserRoutingProfileInput(input, jsonEncoder.Value); err != nil { 7823 return out, metadata, &smithy.SerializationError{Err: err} 7824 } 7825 7826 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7827 return out, metadata, &smithy.SerializationError{Err: err} 7828 } 7829 7830 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7831 return out, metadata, &smithy.SerializationError{Err: err} 7832 } 7833 in.Request = request 7834 7835 return next.HandleSerialize(ctx, in) 7836} 7837func awsRestjson1_serializeOpHttpBindingsUpdateUserRoutingProfileInput(v *UpdateUserRoutingProfileInput, encoder *httpbinding.Encoder) error { 7838 if v == nil { 7839 return fmt.Errorf("unsupported serialization of nil %T", v) 7840 } 7841 7842 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7843 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7844 } 7845 if v.InstanceId != nil { 7846 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7847 return err 7848 } 7849 } 7850 7851 if v.UserId == nil || len(*v.UserId) == 0 { 7852 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 7853 } 7854 if v.UserId != nil { 7855 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 7856 return err 7857 } 7858 } 7859 7860 return nil 7861} 7862 7863func awsRestjson1_serializeOpDocumentUpdateUserRoutingProfileInput(v *UpdateUserRoutingProfileInput, value smithyjson.Value) error { 7864 object := value.Object() 7865 defer object.Close() 7866 7867 if v.RoutingProfileId != nil { 7868 ok := object.Key("RoutingProfileId") 7869 ok.String(*v.RoutingProfileId) 7870 } 7871 7872 return nil 7873} 7874 7875type awsRestjson1_serializeOpUpdateUserSecurityProfiles struct { 7876} 7877 7878func (*awsRestjson1_serializeOpUpdateUserSecurityProfiles) ID() string { 7879 return "OperationSerializer" 7880} 7881 7882func (m *awsRestjson1_serializeOpUpdateUserSecurityProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 7883 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 7884) { 7885 request, ok := in.Request.(*smithyhttp.Request) 7886 if !ok { 7887 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 7888 } 7889 7890 input, ok := in.Parameters.(*UpdateUserSecurityProfilesInput) 7891 _ = input 7892 if !ok { 7893 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 7894 } 7895 7896 opPath, opQuery := httpbinding.SplitURI("/users/{InstanceId}/{UserId}/security-profiles") 7897 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 7898 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 7899 request.Method = "POST" 7900 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 7901 if err != nil { 7902 return out, metadata, &smithy.SerializationError{Err: err} 7903 } 7904 7905 if err := awsRestjson1_serializeOpHttpBindingsUpdateUserSecurityProfilesInput(input, restEncoder); err != nil { 7906 return out, metadata, &smithy.SerializationError{Err: err} 7907 } 7908 7909 restEncoder.SetHeader("Content-Type").String("application/json") 7910 7911 jsonEncoder := smithyjson.NewEncoder() 7912 if err := awsRestjson1_serializeOpDocumentUpdateUserSecurityProfilesInput(input, jsonEncoder.Value); err != nil { 7913 return out, metadata, &smithy.SerializationError{Err: err} 7914 } 7915 7916 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 7917 return out, metadata, &smithy.SerializationError{Err: err} 7918 } 7919 7920 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 7921 return out, metadata, &smithy.SerializationError{Err: err} 7922 } 7923 in.Request = request 7924 7925 return next.HandleSerialize(ctx, in) 7926} 7927func awsRestjson1_serializeOpHttpBindingsUpdateUserSecurityProfilesInput(v *UpdateUserSecurityProfilesInput, encoder *httpbinding.Encoder) error { 7928 if v == nil { 7929 return fmt.Errorf("unsupported serialization of nil %T", v) 7930 } 7931 7932 if v.InstanceId == nil || len(*v.InstanceId) == 0 { 7933 return &smithy.SerializationError{Err: fmt.Errorf("input member InstanceId must not be empty")} 7934 } 7935 if v.InstanceId != nil { 7936 if err := encoder.SetURI("InstanceId").String(*v.InstanceId); err != nil { 7937 return err 7938 } 7939 } 7940 7941 if v.UserId == nil || len(*v.UserId) == 0 { 7942 return &smithy.SerializationError{Err: fmt.Errorf("input member UserId must not be empty")} 7943 } 7944 if v.UserId != nil { 7945 if err := encoder.SetURI("UserId").String(*v.UserId); err != nil { 7946 return err 7947 } 7948 } 7949 7950 return nil 7951} 7952 7953func awsRestjson1_serializeOpDocumentUpdateUserSecurityProfilesInput(v *UpdateUserSecurityProfilesInput, value smithyjson.Value) error { 7954 object := value.Object() 7955 defer object.Close() 7956 7957 if v.SecurityProfileIds != nil { 7958 ok := object.Key("SecurityProfileIds") 7959 if err := awsRestjson1_serializeDocumentSecurityProfileIds(v.SecurityProfileIds, ok); err != nil { 7960 return err 7961 } 7962 } 7963 7964 return nil 7965} 7966 7967func awsRestjson1_serializeDocumentAttributes(v map[string]string, value smithyjson.Value) error { 7968 object := value.Object() 7969 defer object.Close() 7970 7971 for key := range v { 7972 om := object.Key(key) 7973 om.String(v[key]) 7974 } 7975 return nil 7976} 7977 7978func awsRestjson1_serializeDocumentChannels(v []types.Channel, value smithyjson.Value) error { 7979 array := value.Array() 7980 defer array.Close() 7981 7982 for i := range v { 7983 av := array.Value() 7984 av.String(string(v[i])) 7985 } 7986 return nil 7987} 7988 7989func awsRestjson1_serializeDocumentChatMessage(v *types.ChatMessage, value smithyjson.Value) error { 7990 object := value.Object() 7991 defer object.Close() 7992 7993 if v.Content != nil { 7994 ok := object.Key("Content") 7995 ok.String(*v.Content) 7996 } 7997 7998 if v.ContentType != nil { 7999 ok := object.Key("ContentType") 8000 ok.String(*v.ContentType) 8001 } 8002 8003 return nil 8004} 8005 8006func awsRestjson1_serializeDocumentContactReferences(v map[string]types.Reference, value smithyjson.Value) error { 8007 object := value.Object() 8008 defer object.Close() 8009 8010 for key := range v { 8011 om := object.Key(key) 8012 mapVar := v[key] 8013 if err := awsRestjson1_serializeDocumentReference(&mapVar, om); err != nil { 8014 return err 8015 } 8016 } 8017 return nil 8018} 8019 8020func awsRestjson1_serializeDocumentCurrentMetric(v *types.CurrentMetric, value smithyjson.Value) error { 8021 object := value.Object() 8022 defer object.Close() 8023 8024 if len(v.Name) > 0 { 8025 ok := object.Key("Name") 8026 ok.String(string(v.Name)) 8027 } 8028 8029 if len(v.Unit) > 0 { 8030 ok := object.Key("Unit") 8031 ok.String(string(v.Unit)) 8032 } 8033 8034 return nil 8035} 8036 8037func awsRestjson1_serializeDocumentCurrentMetrics(v []types.CurrentMetric, value smithyjson.Value) error { 8038 array := value.Array() 8039 defer array.Close() 8040 8041 for i := range v { 8042 av := array.Value() 8043 if err := awsRestjson1_serializeDocumentCurrentMetric(&v[i], av); err != nil { 8044 return err 8045 } 8046 } 8047 return nil 8048} 8049 8050func awsRestjson1_serializeDocumentEncryptionConfig(v *types.EncryptionConfig, value smithyjson.Value) error { 8051 object := value.Object() 8052 defer object.Close() 8053 8054 if len(v.EncryptionType) > 0 { 8055 ok := object.Key("EncryptionType") 8056 ok.String(string(v.EncryptionType)) 8057 } 8058 8059 if v.KeyId != nil { 8060 ok := object.Key("KeyId") 8061 ok.String(*v.KeyId) 8062 } 8063 8064 return nil 8065} 8066 8067func awsRestjson1_serializeDocumentFilters(v *types.Filters, value smithyjson.Value) error { 8068 object := value.Object() 8069 defer object.Close() 8070 8071 if v.Channels != nil { 8072 ok := object.Key("Channels") 8073 if err := awsRestjson1_serializeDocumentChannels(v.Channels, ok); err != nil { 8074 return err 8075 } 8076 } 8077 8078 if v.Queues != nil { 8079 ok := object.Key("Queues") 8080 if err := awsRestjson1_serializeDocumentQueues(v.Queues, ok); err != nil { 8081 return err 8082 } 8083 } 8084 8085 return nil 8086} 8087 8088func awsRestjson1_serializeDocumentGroupings(v []types.Grouping, value smithyjson.Value) error { 8089 array := value.Array() 8090 defer array.Close() 8091 8092 for i := range v { 8093 av := array.Value() 8094 av.String(string(v[i])) 8095 } 8096 return nil 8097} 8098 8099func awsRestjson1_serializeDocumentHierarchyLevelUpdate(v *types.HierarchyLevelUpdate, value smithyjson.Value) error { 8100 object := value.Object() 8101 defer object.Close() 8102 8103 if v.Name != nil { 8104 ok := object.Key("Name") 8105 ok.String(*v.Name) 8106 } 8107 8108 return nil 8109} 8110 8111func awsRestjson1_serializeDocumentHierarchyStructureUpdate(v *types.HierarchyStructureUpdate, value smithyjson.Value) error { 8112 object := value.Object() 8113 defer object.Close() 8114 8115 if v.LevelFive != nil { 8116 ok := object.Key("LevelFive") 8117 if err := awsRestjson1_serializeDocumentHierarchyLevelUpdate(v.LevelFive, ok); err != nil { 8118 return err 8119 } 8120 } 8121 8122 if v.LevelFour != nil { 8123 ok := object.Key("LevelFour") 8124 if err := awsRestjson1_serializeDocumentHierarchyLevelUpdate(v.LevelFour, ok); err != nil { 8125 return err 8126 } 8127 } 8128 8129 if v.LevelOne != nil { 8130 ok := object.Key("LevelOne") 8131 if err := awsRestjson1_serializeDocumentHierarchyLevelUpdate(v.LevelOne, ok); err != nil { 8132 return err 8133 } 8134 } 8135 8136 if v.LevelThree != nil { 8137 ok := object.Key("LevelThree") 8138 if err := awsRestjson1_serializeDocumentHierarchyLevelUpdate(v.LevelThree, ok); err != nil { 8139 return err 8140 } 8141 } 8142 8143 if v.LevelTwo != nil { 8144 ok := object.Key("LevelTwo") 8145 if err := awsRestjson1_serializeDocumentHierarchyLevelUpdate(v.LevelTwo, ok); err != nil { 8146 return err 8147 } 8148 } 8149 8150 return nil 8151} 8152 8153func awsRestjson1_serializeDocumentHistoricalMetric(v *types.HistoricalMetric, value smithyjson.Value) error { 8154 object := value.Object() 8155 defer object.Close() 8156 8157 if len(v.Name) > 0 { 8158 ok := object.Key("Name") 8159 ok.String(string(v.Name)) 8160 } 8161 8162 if len(v.Statistic) > 0 { 8163 ok := object.Key("Statistic") 8164 ok.String(string(v.Statistic)) 8165 } 8166 8167 if v.Threshold != nil { 8168 ok := object.Key("Threshold") 8169 if err := awsRestjson1_serializeDocumentThreshold(v.Threshold, ok); err != nil { 8170 return err 8171 } 8172 } 8173 8174 if len(v.Unit) > 0 { 8175 ok := object.Key("Unit") 8176 ok.String(string(v.Unit)) 8177 } 8178 8179 return nil 8180} 8181 8182func awsRestjson1_serializeDocumentHistoricalMetrics(v []types.HistoricalMetric, value smithyjson.Value) error { 8183 array := value.Array() 8184 defer array.Close() 8185 8186 for i := range v { 8187 av := array.Value() 8188 if err := awsRestjson1_serializeDocumentHistoricalMetric(&v[i], av); err != nil { 8189 return err 8190 } 8191 } 8192 return nil 8193} 8194 8195func awsRestjson1_serializeDocumentInstanceStorageConfig(v *types.InstanceStorageConfig, value smithyjson.Value) error { 8196 object := value.Object() 8197 defer object.Close() 8198 8199 if v.AssociationId != nil { 8200 ok := object.Key("AssociationId") 8201 ok.String(*v.AssociationId) 8202 } 8203 8204 if v.KinesisFirehoseConfig != nil { 8205 ok := object.Key("KinesisFirehoseConfig") 8206 if err := awsRestjson1_serializeDocumentKinesisFirehoseConfig(v.KinesisFirehoseConfig, ok); err != nil { 8207 return err 8208 } 8209 } 8210 8211 if v.KinesisStreamConfig != nil { 8212 ok := object.Key("KinesisStreamConfig") 8213 if err := awsRestjson1_serializeDocumentKinesisStreamConfig(v.KinesisStreamConfig, ok); err != nil { 8214 return err 8215 } 8216 } 8217 8218 if v.KinesisVideoStreamConfig != nil { 8219 ok := object.Key("KinesisVideoStreamConfig") 8220 if err := awsRestjson1_serializeDocumentKinesisVideoStreamConfig(v.KinesisVideoStreamConfig, ok); err != nil { 8221 return err 8222 } 8223 } 8224 8225 if v.S3Config != nil { 8226 ok := object.Key("S3Config") 8227 if err := awsRestjson1_serializeDocumentS3Config(v.S3Config, ok); err != nil { 8228 return err 8229 } 8230 } 8231 8232 if len(v.StorageType) > 0 { 8233 ok := object.Key("StorageType") 8234 ok.String(string(v.StorageType)) 8235 } 8236 8237 return nil 8238} 8239 8240func awsRestjson1_serializeDocumentKinesisFirehoseConfig(v *types.KinesisFirehoseConfig, value smithyjson.Value) error { 8241 object := value.Object() 8242 defer object.Close() 8243 8244 if v.FirehoseArn != nil { 8245 ok := object.Key("FirehoseArn") 8246 ok.String(*v.FirehoseArn) 8247 } 8248 8249 return nil 8250} 8251 8252func awsRestjson1_serializeDocumentKinesisStreamConfig(v *types.KinesisStreamConfig, value smithyjson.Value) error { 8253 object := value.Object() 8254 defer object.Close() 8255 8256 if v.StreamArn != nil { 8257 ok := object.Key("StreamArn") 8258 ok.String(*v.StreamArn) 8259 } 8260 8261 return nil 8262} 8263 8264func awsRestjson1_serializeDocumentKinesisVideoStreamConfig(v *types.KinesisVideoStreamConfig, value smithyjson.Value) error { 8265 object := value.Object() 8266 defer object.Close() 8267 8268 if v.EncryptionConfig != nil { 8269 ok := object.Key("EncryptionConfig") 8270 if err := awsRestjson1_serializeDocumentEncryptionConfig(v.EncryptionConfig, ok); err != nil { 8271 return err 8272 } 8273 } 8274 8275 if v.Prefix != nil { 8276 ok := object.Key("Prefix") 8277 ok.String(*v.Prefix) 8278 } 8279 8280 { 8281 ok := object.Key("RetentionPeriodHours") 8282 ok.Integer(v.RetentionPeriodHours) 8283 } 8284 8285 return nil 8286} 8287 8288func awsRestjson1_serializeDocumentLexBot(v *types.LexBot, value smithyjson.Value) error { 8289 object := value.Object() 8290 defer object.Close() 8291 8292 if v.LexRegion != nil { 8293 ok := object.Key("LexRegion") 8294 ok.String(*v.LexRegion) 8295 } 8296 8297 if v.Name != nil { 8298 ok := object.Key("Name") 8299 ok.String(*v.Name) 8300 } 8301 8302 return nil 8303} 8304 8305func awsRestjson1_serializeDocumentMediaConcurrencies(v []types.MediaConcurrency, value smithyjson.Value) error { 8306 array := value.Array() 8307 defer array.Close() 8308 8309 for i := range v { 8310 av := array.Value() 8311 if err := awsRestjson1_serializeDocumentMediaConcurrency(&v[i], av); err != nil { 8312 return err 8313 } 8314 } 8315 return nil 8316} 8317 8318func awsRestjson1_serializeDocumentMediaConcurrency(v *types.MediaConcurrency, value smithyjson.Value) error { 8319 object := value.Object() 8320 defer object.Close() 8321 8322 if len(v.Channel) > 0 { 8323 ok := object.Key("Channel") 8324 ok.String(string(v.Channel)) 8325 } 8326 8327 { 8328 ok := object.Key("Concurrency") 8329 ok.Integer(v.Concurrency) 8330 } 8331 8332 return nil 8333} 8334 8335func awsRestjson1_serializeDocumentOutboundCallerConfig(v *types.OutboundCallerConfig, value smithyjson.Value) error { 8336 object := value.Object() 8337 defer object.Close() 8338 8339 if v.OutboundCallerIdName != nil { 8340 ok := object.Key("OutboundCallerIdName") 8341 ok.String(*v.OutboundCallerIdName) 8342 } 8343 8344 if v.OutboundCallerIdNumberId != nil { 8345 ok := object.Key("OutboundCallerIdNumberId") 8346 ok.String(*v.OutboundCallerIdNumberId) 8347 } 8348 8349 if v.OutboundFlowId != nil { 8350 ok := object.Key("OutboundFlowId") 8351 ok.String(*v.OutboundFlowId) 8352 } 8353 8354 return nil 8355} 8356 8357func awsRestjson1_serializeDocumentParticipantDetails(v *types.ParticipantDetails, value smithyjson.Value) error { 8358 object := value.Object() 8359 defer object.Close() 8360 8361 if v.DisplayName != nil { 8362 ok := object.Key("DisplayName") 8363 ok.String(*v.DisplayName) 8364 } 8365 8366 return nil 8367} 8368 8369func awsRestjson1_serializeDocumentPhoneNumberQuickConnectConfig(v *types.PhoneNumberQuickConnectConfig, value smithyjson.Value) error { 8370 object := value.Object() 8371 defer object.Close() 8372 8373 if v.PhoneNumber != nil { 8374 ok := object.Key("PhoneNumber") 8375 ok.String(*v.PhoneNumber) 8376 } 8377 8378 return nil 8379} 8380 8381func awsRestjson1_serializeDocumentQueueQuickConnectConfig(v *types.QueueQuickConnectConfig, value smithyjson.Value) error { 8382 object := value.Object() 8383 defer object.Close() 8384 8385 if v.ContactFlowId != nil { 8386 ok := object.Key("ContactFlowId") 8387 ok.String(*v.ContactFlowId) 8388 } 8389 8390 if v.QueueId != nil { 8391 ok := object.Key("QueueId") 8392 ok.String(*v.QueueId) 8393 } 8394 8395 return nil 8396} 8397 8398func awsRestjson1_serializeDocumentQueues(v []string, value smithyjson.Value) error { 8399 array := value.Array() 8400 defer array.Close() 8401 8402 for i := range v { 8403 av := array.Value() 8404 av.String(v[i]) 8405 } 8406 return nil 8407} 8408 8409func awsRestjson1_serializeDocumentQuickConnectConfig(v *types.QuickConnectConfig, value smithyjson.Value) error { 8410 object := value.Object() 8411 defer object.Close() 8412 8413 if v.PhoneConfig != nil { 8414 ok := object.Key("PhoneConfig") 8415 if err := awsRestjson1_serializeDocumentPhoneNumberQuickConnectConfig(v.PhoneConfig, ok); err != nil { 8416 return err 8417 } 8418 } 8419 8420 if v.QueueConfig != nil { 8421 ok := object.Key("QueueConfig") 8422 if err := awsRestjson1_serializeDocumentQueueQuickConnectConfig(v.QueueConfig, ok); err != nil { 8423 return err 8424 } 8425 } 8426 8427 if len(v.QuickConnectType) > 0 { 8428 ok := object.Key("QuickConnectType") 8429 ok.String(string(v.QuickConnectType)) 8430 } 8431 8432 if v.UserConfig != nil { 8433 ok := object.Key("UserConfig") 8434 if err := awsRestjson1_serializeDocumentUserQuickConnectConfig(v.UserConfig, ok); err != nil { 8435 return err 8436 } 8437 } 8438 8439 return nil 8440} 8441 8442func awsRestjson1_serializeDocumentQuickConnectsList(v []string, value smithyjson.Value) error { 8443 array := value.Array() 8444 defer array.Close() 8445 8446 for i := range v { 8447 av := array.Value() 8448 av.String(v[i]) 8449 } 8450 return nil 8451} 8452 8453func awsRestjson1_serializeDocumentReference(v *types.Reference, value smithyjson.Value) error { 8454 object := value.Object() 8455 defer object.Close() 8456 8457 if len(v.Type) > 0 { 8458 ok := object.Key("Type") 8459 ok.String(string(v.Type)) 8460 } 8461 8462 if v.Value != nil { 8463 ok := object.Key("Value") 8464 ok.String(*v.Value) 8465 } 8466 8467 return nil 8468} 8469 8470func awsRestjson1_serializeDocumentRoutingProfileQueueConfig(v *types.RoutingProfileQueueConfig, value smithyjson.Value) error { 8471 object := value.Object() 8472 defer object.Close() 8473 8474 { 8475 ok := object.Key("Delay") 8476 ok.Integer(v.Delay) 8477 } 8478 8479 { 8480 ok := object.Key("Priority") 8481 ok.Integer(v.Priority) 8482 } 8483 8484 if v.QueueReference != nil { 8485 ok := object.Key("QueueReference") 8486 if err := awsRestjson1_serializeDocumentRoutingProfileQueueReference(v.QueueReference, ok); err != nil { 8487 return err 8488 } 8489 } 8490 8491 return nil 8492} 8493 8494func awsRestjson1_serializeDocumentRoutingProfileQueueConfigList(v []types.RoutingProfileQueueConfig, value smithyjson.Value) error { 8495 array := value.Array() 8496 defer array.Close() 8497 8498 for i := range v { 8499 av := array.Value() 8500 if err := awsRestjson1_serializeDocumentRoutingProfileQueueConfig(&v[i], av); err != nil { 8501 return err 8502 } 8503 } 8504 return nil 8505} 8506 8507func awsRestjson1_serializeDocumentRoutingProfileQueueReference(v *types.RoutingProfileQueueReference, value smithyjson.Value) error { 8508 object := value.Object() 8509 defer object.Close() 8510 8511 if len(v.Channel) > 0 { 8512 ok := object.Key("Channel") 8513 ok.String(string(v.Channel)) 8514 } 8515 8516 if v.QueueId != nil { 8517 ok := object.Key("QueueId") 8518 ok.String(*v.QueueId) 8519 } 8520 8521 return nil 8522} 8523 8524func awsRestjson1_serializeDocumentRoutingProfileQueueReferenceList(v []types.RoutingProfileQueueReference, value smithyjson.Value) error { 8525 array := value.Array() 8526 defer array.Close() 8527 8528 for i := range v { 8529 av := array.Value() 8530 if err := awsRestjson1_serializeDocumentRoutingProfileQueueReference(&v[i], av); err != nil { 8531 return err 8532 } 8533 } 8534 return nil 8535} 8536 8537func awsRestjson1_serializeDocumentS3Config(v *types.S3Config, value smithyjson.Value) error { 8538 object := value.Object() 8539 defer object.Close() 8540 8541 if v.BucketName != nil { 8542 ok := object.Key("BucketName") 8543 ok.String(*v.BucketName) 8544 } 8545 8546 if v.BucketPrefix != nil { 8547 ok := object.Key("BucketPrefix") 8548 ok.String(*v.BucketPrefix) 8549 } 8550 8551 if v.EncryptionConfig != nil { 8552 ok := object.Key("EncryptionConfig") 8553 if err := awsRestjson1_serializeDocumentEncryptionConfig(v.EncryptionConfig, ok); err != nil { 8554 return err 8555 } 8556 } 8557 8558 return nil 8559} 8560 8561func awsRestjson1_serializeDocumentSecurityProfileIds(v []string, value smithyjson.Value) error { 8562 array := value.Array() 8563 defer array.Close() 8564 8565 for i := range v { 8566 av := array.Value() 8567 av.String(v[i]) 8568 } 8569 return nil 8570} 8571 8572func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 8573 object := value.Object() 8574 defer object.Close() 8575 8576 for key := range v { 8577 om := object.Key(key) 8578 om.String(v[key]) 8579 } 8580 return nil 8581} 8582 8583func awsRestjson1_serializeDocumentThreshold(v *types.Threshold, value smithyjson.Value) error { 8584 object := value.Object() 8585 defer object.Close() 8586 8587 if len(v.Comparison) > 0 { 8588 ok := object.Key("Comparison") 8589 ok.String(string(v.Comparison)) 8590 } 8591 8592 if v.ThresholdValue != nil { 8593 ok := object.Key("ThresholdValue") 8594 ok.Double(*v.ThresholdValue) 8595 } 8596 8597 return nil 8598} 8599 8600func awsRestjson1_serializeDocumentUserIdentityInfo(v *types.UserIdentityInfo, value smithyjson.Value) error { 8601 object := value.Object() 8602 defer object.Close() 8603 8604 if v.Email != nil { 8605 ok := object.Key("Email") 8606 ok.String(*v.Email) 8607 } 8608 8609 if v.FirstName != nil { 8610 ok := object.Key("FirstName") 8611 ok.String(*v.FirstName) 8612 } 8613 8614 if v.LastName != nil { 8615 ok := object.Key("LastName") 8616 ok.String(*v.LastName) 8617 } 8618 8619 return nil 8620} 8621 8622func awsRestjson1_serializeDocumentUserPhoneConfig(v *types.UserPhoneConfig, value smithyjson.Value) error { 8623 object := value.Object() 8624 defer object.Close() 8625 8626 if v.AfterContactWorkTimeLimit != 0 { 8627 ok := object.Key("AfterContactWorkTimeLimit") 8628 ok.Integer(v.AfterContactWorkTimeLimit) 8629 } 8630 8631 if v.AutoAccept { 8632 ok := object.Key("AutoAccept") 8633 ok.Boolean(v.AutoAccept) 8634 } 8635 8636 if v.DeskPhoneNumber != nil { 8637 ok := object.Key("DeskPhoneNumber") 8638 ok.String(*v.DeskPhoneNumber) 8639 } 8640 8641 if len(v.PhoneType) > 0 { 8642 ok := object.Key("PhoneType") 8643 ok.String(string(v.PhoneType)) 8644 } 8645 8646 return nil 8647} 8648 8649func awsRestjson1_serializeDocumentUserQuickConnectConfig(v *types.UserQuickConnectConfig, value smithyjson.Value) error { 8650 object := value.Object() 8651 defer object.Close() 8652 8653 if v.ContactFlowId != nil { 8654 ok := object.Key("ContactFlowId") 8655 ok.String(*v.ContactFlowId) 8656 } 8657 8658 if v.UserId != nil { 8659 ok := object.Key("UserId") 8660 ok.String(*v.UserId) 8661 } 8662 8663 return nil 8664} 8665 8666func awsRestjson1_serializeDocumentVoiceRecordingConfiguration(v *types.VoiceRecordingConfiguration, value smithyjson.Value) error { 8667 object := value.Object() 8668 defer object.Close() 8669 8670 if len(v.VoiceRecordingTrack) > 0 { 8671 ok := object.Key("VoiceRecordingTrack") 8672 ok.String(string(v.VoiceRecordingTrack)) 8673 } 8674 8675 return nil 8676} 8677