1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package clouddirectory 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/clouddirectory/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_serializeOpAddFacetToObject struct { 19} 20 21func (*awsRestjson1_serializeOpAddFacetToObject) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpAddFacetToObject) 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.(*AddFacetToObjectInput) 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("/amazonclouddirectory/2017-01-11/object/facets") 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_serializeOpHttpBindingsAddFacetToObjectInput(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_serializeOpDocumentAddFacetToObjectInput(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_serializeOpHttpBindingsAddFacetToObjectInput(v *AddFacetToObjectInput, encoder *httpbinding.Encoder) error { 71 if v == nil { 72 return fmt.Errorf("unsupported serialization of nil %T", v) 73 } 74 75 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 76 locationName := "X-Amz-Data-Partition" 77 encoder.SetHeader(locationName).String(*v.DirectoryArn) 78 } 79 80 return nil 81} 82 83func awsRestjson1_serializeOpDocumentAddFacetToObjectInput(v *AddFacetToObjectInput, value smithyjson.Value) error { 84 object := value.Object() 85 defer object.Close() 86 87 if v.ObjectAttributeList != nil { 88 ok := object.Key("ObjectAttributeList") 89 if err := awsRestjson1_serializeDocumentAttributeKeyAndValueList(v.ObjectAttributeList, ok); err != nil { 90 return err 91 } 92 } 93 94 if v.ObjectReference != nil { 95 ok := object.Key("ObjectReference") 96 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 97 return err 98 } 99 } 100 101 if v.SchemaFacet != nil { 102 ok := object.Key("SchemaFacet") 103 if err := awsRestjson1_serializeDocumentSchemaFacet(v.SchemaFacet, ok); err != nil { 104 return err 105 } 106 } 107 108 return nil 109} 110 111type awsRestjson1_serializeOpApplySchema struct { 112} 113 114func (*awsRestjson1_serializeOpApplySchema) ID() string { 115 return "OperationSerializer" 116} 117 118func (m *awsRestjson1_serializeOpApplySchema) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 119 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 120) { 121 request, ok := in.Request.(*smithyhttp.Request) 122 if !ok { 123 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 124 } 125 126 input, ok := in.Parameters.(*ApplySchemaInput) 127 _ = input 128 if !ok { 129 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 130 } 131 132 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/apply") 133 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 134 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 135 request.Method = "PUT" 136 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 137 if err != nil { 138 return out, metadata, &smithy.SerializationError{Err: err} 139 } 140 141 if err := awsRestjson1_serializeOpHttpBindingsApplySchemaInput(input, restEncoder); err != nil { 142 return out, metadata, &smithy.SerializationError{Err: err} 143 } 144 145 restEncoder.SetHeader("Content-Type").String("application/json") 146 147 jsonEncoder := smithyjson.NewEncoder() 148 if err := awsRestjson1_serializeOpDocumentApplySchemaInput(input, jsonEncoder.Value); err != nil { 149 return out, metadata, &smithy.SerializationError{Err: err} 150 } 151 152 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 153 return out, metadata, &smithy.SerializationError{Err: err} 154 } 155 156 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 157 return out, metadata, &smithy.SerializationError{Err: err} 158 } 159 in.Request = request 160 161 return next.HandleSerialize(ctx, in) 162} 163func awsRestjson1_serializeOpHttpBindingsApplySchemaInput(v *ApplySchemaInput, encoder *httpbinding.Encoder) error { 164 if v == nil { 165 return fmt.Errorf("unsupported serialization of nil %T", v) 166 } 167 168 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 169 locationName := "X-Amz-Data-Partition" 170 encoder.SetHeader(locationName).String(*v.DirectoryArn) 171 } 172 173 return nil 174} 175 176func awsRestjson1_serializeOpDocumentApplySchemaInput(v *ApplySchemaInput, value smithyjson.Value) error { 177 object := value.Object() 178 defer object.Close() 179 180 if v.PublishedSchemaArn != nil { 181 ok := object.Key("PublishedSchemaArn") 182 ok.String(*v.PublishedSchemaArn) 183 } 184 185 return nil 186} 187 188type awsRestjson1_serializeOpAttachObject struct { 189} 190 191func (*awsRestjson1_serializeOpAttachObject) ID() string { 192 return "OperationSerializer" 193} 194 195func (m *awsRestjson1_serializeOpAttachObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 196 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 197) { 198 request, ok := in.Request.(*smithyhttp.Request) 199 if !ok { 200 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 201 } 202 203 input, ok := in.Parameters.(*AttachObjectInput) 204 _ = input 205 if !ok { 206 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 207 } 208 209 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/attach") 210 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 211 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 212 request.Method = "PUT" 213 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 214 if err != nil { 215 return out, metadata, &smithy.SerializationError{Err: err} 216 } 217 218 if err := awsRestjson1_serializeOpHttpBindingsAttachObjectInput(input, restEncoder); err != nil { 219 return out, metadata, &smithy.SerializationError{Err: err} 220 } 221 222 restEncoder.SetHeader("Content-Type").String("application/json") 223 224 jsonEncoder := smithyjson.NewEncoder() 225 if err := awsRestjson1_serializeOpDocumentAttachObjectInput(input, jsonEncoder.Value); err != nil { 226 return out, metadata, &smithy.SerializationError{Err: err} 227 } 228 229 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 230 return out, metadata, &smithy.SerializationError{Err: err} 231 } 232 233 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 234 return out, metadata, &smithy.SerializationError{Err: err} 235 } 236 in.Request = request 237 238 return next.HandleSerialize(ctx, in) 239} 240func awsRestjson1_serializeOpHttpBindingsAttachObjectInput(v *AttachObjectInput, encoder *httpbinding.Encoder) error { 241 if v == nil { 242 return fmt.Errorf("unsupported serialization of nil %T", v) 243 } 244 245 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 246 locationName := "X-Amz-Data-Partition" 247 encoder.SetHeader(locationName).String(*v.DirectoryArn) 248 } 249 250 return nil 251} 252 253func awsRestjson1_serializeOpDocumentAttachObjectInput(v *AttachObjectInput, value smithyjson.Value) error { 254 object := value.Object() 255 defer object.Close() 256 257 if v.ChildReference != nil { 258 ok := object.Key("ChildReference") 259 if err := awsRestjson1_serializeDocumentObjectReference(v.ChildReference, ok); err != nil { 260 return err 261 } 262 } 263 264 if v.LinkName != nil { 265 ok := object.Key("LinkName") 266 ok.String(*v.LinkName) 267 } 268 269 if v.ParentReference != nil { 270 ok := object.Key("ParentReference") 271 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 272 return err 273 } 274 } 275 276 return nil 277} 278 279type awsRestjson1_serializeOpAttachPolicy struct { 280} 281 282func (*awsRestjson1_serializeOpAttachPolicy) ID() string { 283 return "OperationSerializer" 284} 285 286func (m *awsRestjson1_serializeOpAttachPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 287 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 288) { 289 request, ok := in.Request.(*smithyhttp.Request) 290 if !ok { 291 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 292 } 293 294 input, ok := in.Parameters.(*AttachPolicyInput) 295 _ = input 296 if !ok { 297 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 298 } 299 300 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/policy/attach") 301 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 302 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 303 request.Method = "PUT" 304 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 305 if err != nil { 306 return out, metadata, &smithy.SerializationError{Err: err} 307 } 308 309 if err := awsRestjson1_serializeOpHttpBindingsAttachPolicyInput(input, restEncoder); err != nil { 310 return out, metadata, &smithy.SerializationError{Err: err} 311 } 312 313 restEncoder.SetHeader("Content-Type").String("application/json") 314 315 jsonEncoder := smithyjson.NewEncoder() 316 if err := awsRestjson1_serializeOpDocumentAttachPolicyInput(input, jsonEncoder.Value); err != nil { 317 return out, metadata, &smithy.SerializationError{Err: err} 318 } 319 320 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 321 return out, metadata, &smithy.SerializationError{Err: err} 322 } 323 324 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 325 return out, metadata, &smithy.SerializationError{Err: err} 326 } 327 in.Request = request 328 329 return next.HandleSerialize(ctx, in) 330} 331func awsRestjson1_serializeOpHttpBindingsAttachPolicyInput(v *AttachPolicyInput, encoder *httpbinding.Encoder) error { 332 if v == nil { 333 return fmt.Errorf("unsupported serialization of nil %T", v) 334 } 335 336 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 337 locationName := "X-Amz-Data-Partition" 338 encoder.SetHeader(locationName).String(*v.DirectoryArn) 339 } 340 341 return nil 342} 343 344func awsRestjson1_serializeOpDocumentAttachPolicyInput(v *AttachPolicyInput, value smithyjson.Value) error { 345 object := value.Object() 346 defer object.Close() 347 348 if v.ObjectReference != nil { 349 ok := object.Key("ObjectReference") 350 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 351 return err 352 } 353 } 354 355 if v.PolicyReference != nil { 356 ok := object.Key("PolicyReference") 357 if err := awsRestjson1_serializeDocumentObjectReference(v.PolicyReference, ok); err != nil { 358 return err 359 } 360 } 361 362 return nil 363} 364 365type awsRestjson1_serializeOpAttachToIndex struct { 366} 367 368func (*awsRestjson1_serializeOpAttachToIndex) ID() string { 369 return "OperationSerializer" 370} 371 372func (m *awsRestjson1_serializeOpAttachToIndex) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 373 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 374) { 375 request, ok := in.Request.(*smithyhttp.Request) 376 if !ok { 377 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 378 } 379 380 input, ok := in.Parameters.(*AttachToIndexInput) 381 _ = input 382 if !ok { 383 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 384 } 385 386 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/index/attach") 387 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 388 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 389 request.Method = "PUT" 390 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 391 if err != nil { 392 return out, metadata, &smithy.SerializationError{Err: err} 393 } 394 395 if err := awsRestjson1_serializeOpHttpBindingsAttachToIndexInput(input, restEncoder); err != nil { 396 return out, metadata, &smithy.SerializationError{Err: err} 397 } 398 399 restEncoder.SetHeader("Content-Type").String("application/json") 400 401 jsonEncoder := smithyjson.NewEncoder() 402 if err := awsRestjson1_serializeOpDocumentAttachToIndexInput(input, jsonEncoder.Value); err != nil { 403 return out, metadata, &smithy.SerializationError{Err: err} 404 } 405 406 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 407 return out, metadata, &smithy.SerializationError{Err: err} 408 } 409 410 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 411 return out, metadata, &smithy.SerializationError{Err: err} 412 } 413 in.Request = request 414 415 return next.HandleSerialize(ctx, in) 416} 417func awsRestjson1_serializeOpHttpBindingsAttachToIndexInput(v *AttachToIndexInput, encoder *httpbinding.Encoder) error { 418 if v == nil { 419 return fmt.Errorf("unsupported serialization of nil %T", v) 420 } 421 422 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 423 locationName := "X-Amz-Data-Partition" 424 encoder.SetHeader(locationName).String(*v.DirectoryArn) 425 } 426 427 return nil 428} 429 430func awsRestjson1_serializeOpDocumentAttachToIndexInput(v *AttachToIndexInput, value smithyjson.Value) error { 431 object := value.Object() 432 defer object.Close() 433 434 if v.IndexReference != nil { 435 ok := object.Key("IndexReference") 436 if err := awsRestjson1_serializeDocumentObjectReference(v.IndexReference, ok); err != nil { 437 return err 438 } 439 } 440 441 if v.TargetReference != nil { 442 ok := object.Key("TargetReference") 443 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetReference, ok); err != nil { 444 return err 445 } 446 } 447 448 return nil 449} 450 451type awsRestjson1_serializeOpAttachTypedLink struct { 452} 453 454func (*awsRestjson1_serializeOpAttachTypedLink) ID() string { 455 return "OperationSerializer" 456} 457 458func (m *awsRestjson1_serializeOpAttachTypedLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 459 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 460) { 461 request, ok := in.Request.(*smithyhttp.Request) 462 if !ok { 463 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 464 } 465 466 input, ok := in.Parameters.(*AttachTypedLinkInput) 467 _ = input 468 if !ok { 469 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 470 } 471 472 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/attach") 473 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 474 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 475 request.Method = "PUT" 476 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 477 if err != nil { 478 return out, metadata, &smithy.SerializationError{Err: err} 479 } 480 481 if err := awsRestjson1_serializeOpHttpBindingsAttachTypedLinkInput(input, restEncoder); err != nil { 482 return out, metadata, &smithy.SerializationError{Err: err} 483 } 484 485 restEncoder.SetHeader("Content-Type").String("application/json") 486 487 jsonEncoder := smithyjson.NewEncoder() 488 if err := awsRestjson1_serializeOpDocumentAttachTypedLinkInput(input, jsonEncoder.Value); err != nil { 489 return out, metadata, &smithy.SerializationError{Err: err} 490 } 491 492 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 493 return out, metadata, &smithy.SerializationError{Err: err} 494 } 495 496 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 497 return out, metadata, &smithy.SerializationError{Err: err} 498 } 499 in.Request = request 500 501 return next.HandleSerialize(ctx, in) 502} 503func awsRestjson1_serializeOpHttpBindingsAttachTypedLinkInput(v *AttachTypedLinkInput, encoder *httpbinding.Encoder) error { 504 if v == nil { 505 return fmt.Errorf("unsupported serialization of nil %T", v) 506 } 507 508 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 509 locationName := "X-Amz-Data-Partition" 510 encoder.SetHeader(locationName).String(*v.DirectoryArn) 511 } 512 513 return nil 514} 515 516func awsRestjson1_serializeOpDocumentAttachTypedLinkInput(v *AttachTypedLinkInput, value smithyjson.Value) error { 517 object := value.Object() 518 defer object.Close() 519 520 if v.Attributes != nil { 521 ok := object.Key("Attributes") 522 if err := awsRestjson1_serializeDocumentAttributeNameAndValueList(v.Attributes, ok); err != nil { 523 return err 524 } 525 } 526 527 if v.SourceObjectReference != nil { 528 ok := object.Key("SourceObjectReference") 529 if err := awsRestjson1_serializeDocumentObjectReference(v.SourceObjectReference, ok); err != nil { 530 return err 531 } 532 } 533 534 if v.TargetObjectReference != nil { 535 ok := object.Key("TargetObjectReference") 536 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetObjectReference, ok); err != nil { 537 return err 538 } 539 } 540 541 if v.TypedLinkFacet != nil { 542 ok := object.Key("TypedLinkFacet") 543 if err := awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v.TypedLinkFacet, ok); err != nil { 544 return err 545 } 546 } 547 548 return nil 549} 550 551type awsRestjson1_serializeOpBatchRead struct { 552} 553 554func (*awsRestjson1_serializeOpBatchRead) ID() string { 555 return "OperationSerializer" 556} 557 558func (m *awsRestjson1_serializeOpBatchRead) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 559 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 560) { 561 request, ok := in.Request.(*smithyhttp.Request) 562 if !ok { 563 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 564 } 565 566 input, ok := in.Parameters.(*BatchReadInput) 567 _ = input 568 if !ok { 569 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 570 } 571 572 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/batchread") 573 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 574 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 575 request.Method = "POST" 576 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 577 if err != nil { 578 return out, metadata, &smithy.SerializationError{Err: err} 579 } 580 581 if err := awsRestjson1_serializeOpHttpBindingsBatchReadInput(input, restEncoder); err != nil { 582 return out, metadata, &smithy.SerializationError{Err: err} 583 } 584 585 restEncoder.SetHeader("Content-Type").String("application/json") 586 587 jsonEncoder := smithyjson.NewEncoder() 588 if err := awsRestjson1_serializeOpDocumentBatchReadInput(input, jsonEncoder.Value); err != nil { 589 return out, metadata, &smithy.SerializationError{Err: err} 590 } 591 592 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 593 return out, metadata, &smithy.SerializationError{Err: err} 594 } 595 596 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 597 return out, metadata, &smithy.SerializationError{Err: err} 598 } 599 in.Request = request 600 601 return next.HandleSerialize(ctx, in) 602} 603func awsRestjson1_serializeOpHttpBindingsBatchReadInput(v *BatchReadInput, encoder *httpbinding.Encoder) error { 604 if v == nil { 605 return fmt.Errorf("unsupported serialization of nil %T", v) 606 } 607 608 if len(v.ConsistencyLevel) > 0 { 609 locationName := "X-Amz-Consistency-Level" 610 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 611 } 612 613 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 614 locationName := "X-Amz-Data-Partition" 615 encoder.SetHeader(locationName).String(*v.DirectoryArn) 616 } 617 618 return nil 619} 620 621func awsRestjson1_serializeOpDocumentBatchReadInput(v *BatchReadInput, value smithyjson.Value) error { 622 object := value.Object() 623 defer object.Close() 624 625 if v.Operations != nil { 626 ok := object.Key("Operations") 627 if err := awsRestjson1_serializeDocumentBatchReadOperationList(v.Operations, ok); err != nil { 628 return err 629 } 630 } 631 632 return nil 633} 634 635type awsRestjson1_serializeOpBatchWrite struct { 636} 637 638func (*awsRestjson1_serializeOpBatchWrite) ID() string { 639 return "OperationSerializer" 640} 641 642func (m *awsRestjson1_serializeOpBatchWrite) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 643 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 644) { 645 request, ok := in.Request.(*smithyhttp.Request) 646 if !ok { 647 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 648 } 649 650 input, ok := in.Parameters.(*BatchWriteInput) 651 _ = input 652 if !ok { 653 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 654 } 655 656 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/batchwrite") 657 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 658 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 659 request.Method = "PUT" 660 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 661 if err != nil { 662 return out, metadata, &smithy.SerializationError{Err: err} 663 } 664 665 if err := awsRestjson1_serializeOpHttpBindingsBatchWriteInput(input, restEncoder); err != nil { 666 return out, metadata, &smithy.SerializationError{Err: err} 667 } 668 669 restEncoder.SetHeader("Content-Type").String("application/json") 670 671 jsonEncoder := smithyjson.NewEncoder() 672 if err := awsRestjson1_serializeOpDocumentBatchWriteInput(input, jsonEncoder.Value); err != nil { 673 return out, metadata, &smithy.SerializationError{Err: err} 674 } 675 676 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 677 return out, metadata, &smithy.SerializationError{Err: err} 678 } 679 680 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 681 return out, metadata, &smithy.SerializationError{Err: err} 682 } 683 in.Request = request 684 685 return next.HandleSerialize(ctx, in) 686} 687func awsRestjson1_serializeOpHttpBindingsBatchWriteInput(v *BatchWriteInput, encoder *httpbinding.Encoder) error { 688 if v == nil { 689 return fmt.Errorf("unsupported serialization of nil %T", v) 690 } 691 692 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 693 locationName := "X-Amz-Data-Partition" 694 encoder.SetHeader(locationName).String(*v.DirectoryArn) 695 } 696 697 return nil 698} 699 700func awsRestjson1_serializeOpDocumentBatchWriteInput(v *BatchWriteInput, value smithyjson.Value) error { 701 object := value.Object() 702 defer object.Close() 703 704 if v.Operations != nil { 705 ok := object.Key("Operations") 706 if err := awsRestjson1_serializeDocumentBatchWriteOperationList(v.Operations, ok); err != nil { 707 return err 708 } 709 } 710 711 return nil 712} 713 714type awsRestjson1_serializeOpCreateDirectory struct { 715} 716 717func (*awsRestjson1_serializeOpCreateDirectory) ID() string { 718 return "OperationSerializer" 719} 720 721func (m *awsRestjson1_serializeOpCreateDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 722 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 723) { 724 request, ok := in.Request.(*smithyhttp.Request) 725 if !ok { 726 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 727 } 728 729 input, ok := in.Parameters.(*CreateDirectoryInput) 730 _ = input 731 if !ok { 732 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 733 } 734 735 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/directory/create") 736 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 737 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 738 request.Method = "PUT" 739 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 740 if err != nil { 741 return out, metadata, &smithy.SerializationError{Err: err} 742 } 743 744 if err := awsRestjson1_serializeOpHttpBindingsCreateDirectoryInput(input, restEncoder); err != nil { 745 return out, metadata, &smithy.SerializationError{Err: err} 746 } 747 748 restEncoder.SetHeader("Content-Type").String("application/json") 749 750 jsonEncoder := smithyjson.NewEncoder() 751 if err := awsRestjson1_serializeOpDocumentCreateDirectoryInput(input, jsonEncoder.Value); err != nil { 752 return out, metadata, &smithy.SerializationError{Err: err} 753 } 754 755 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 756 return out, metadata, &smithy.SerializationError{Err: err} 757 } 758 759 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 760 return out, metadata, &smithy.SerializationError{Err: err} 761 } 762 in.Request = request 763 764 return next.HandleSerialize(ctx, in) 765} 766func awsRestjson1_serializeOpHttpBindingsCreateDirectoryInput(v *CreateDirectoryInput, encoder *httpbinding.Encoder) error { 767 if v == nil { 768 return fmt.Errorf("unsupported serialization of nil %T", v) 769 } 770 771 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 772 locationName := "X-Amz-Data-Partition" 773 encoder.SetHeader(locationName).String(*v.SchemaArn) 774 } 775 776 return nil 777} 778 779func awsRestjson1_serializeOpDocumentCreateDirectoryInput(v *CreateDirectoryInput, value smithyjson.Value) error { 780 object := value.Object() 781 defer object.Close() 782 783 if v.Name != nil { 784 ok := object.Key("Name") 785 ok.String(*v.Name) 786 } 787 788 return nil 789} 790 791type awsRestjson1_serializeOpCreateFacet struct { 792} 793 794func (*awsRestjson1_serializeOpCreateFacet) ID() string { 795 return "OperationSerializer" 796} 797 798func (m *awsRestjson1_serializeOpCreateFacet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 799 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 800) { 801 request, ok := in.Request.(*smithyhttp.Request) 802 if !ok { 803 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 804 } 805 806 input, ok := in.Parameters.(*CreateFacetInput) 807 _ = input 808 if !ok { 809 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 810 } 811 812 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/facet/create") 813 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 814 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 815 request.Method = "PUT" 816 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 817 if err != nil { 818 return out, metadata, &smithy.SerializationError{Err: err} 819 } 820 821 if err := awsRestjson1_serializeOpHttpBindingsCreateFacetInput(input, restEncoder); err != nil { 822 return out, metadata, &smithy.SerializationError{Err: err} 823 } 824 825 restEncoder.SetHeader("Content-Type").String("application/json") 826 827 jsonEncoder := smithyjson.NewEncoder() 828 if err := awsRestjson1_serializeOpDocumentCreateFacetInput(input, jsonEncoder.Value); err != nil { 829 return out, metadata, &smithy.SerializationError{Err: err} 830 } 831 832 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 833 return out, metadata, &smithy.SerializationError{Err: err} 834 } 835 836 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 837 return out, metadata, &smithy.SerializationError{Err: err} 838 } 839 in.Request = request 840 841 return next.HandleSerialize(ctx, in) 842} 843func awsRestjson1_serializeOpHttpBindingsCreateFacetInput(v *CreateFacetInput, encoder *httpbinding.Encoder) error { 844 if v == nil { 845 return fmt.Errorf("unsupported serialization of nil %T", v) 846 } 847 848 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 849 locationName := "X-Amz-Data-Partition" 850 encoder.SetHeader(locationName).String(*v.SchemaArn) 851 } 852 853 return nil 854} 855 856func awsRestjson1_serializeOpDocumentCreateFacetInput(v *CreateFacetInput, value smithyjson.Value) error { 857 object := value.Object() 858 defer object.Close() 859 860 if v.Attributes != nil { 861 ok := object.Key("Attributes") 862 if err := awsRestjson1_serializeDocumentFacetAttributeList(v.Attributes, ok); err != nil { 863 return err 864 } 865 } 866 867 if len(v.FacetStyle) > 0 { 868 ok := object.Key("FacetStyle") 869 ok.String(string(v.FacetStyle)) 870 } 871 872 if v.Name != nil { 873 ok := object.Key("Name") 874 ok.String(*v.Name) 875 } 876 877 if len(v.ObjectType) > 0 { 878 ok := object.Key("ObjectType") 879 ok.String(string(v.ObjectType)) 880 } 881 882 return nil 883} 884 885type awsRestjson1_serializeOpCreateIndex struct { 886} 887 888func (*awsRestjson1_serializeOpCreateIndex) ID() string { 889 return "OperationSerializer" 890} 891 892func (m *awsRestjson1_serializeOpCreateIndex) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 893 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 894) { 895 request, ok := in.Request.(*smithyhttp.Request) 896 if !ok { 897 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 898 } 899 900 input, ok := in.Parameters.(*CreateIndexInput) 901 _ = input 902 if !ok { 903 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 904 } 905 906 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/index") 907 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 908 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 909 request.Method = "PUT" 910 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 911 if err != nil { 912 return out, metadata, &smithy.SerializationError{Err: err} 913 } 914 915 if err := awsRestjson1_serializeOpHttpBindingsCreateIndexInput(input, restEncoder); err != nil { 916 return out, metadata, &smithy.SerializationError{Err: err} 917 } 918 919 restEncoder.SetHeader("Content-Type").String("application/json") 920 921 jsonEncoder := smithyjson.NewEncoder() 922 if err := awsRestjson1_serializeOpDocumentCreateIndexInput(input, jsonEncoder.Value); err != nil { 923 return out, metadata, &smithy.SerializationError{Err: err} 924 } 925 926 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 927 return out, metadata, &smithy.SerializationError{Err: err} 928 } 929 930 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 931 return out, metadata, &smithy.SerializationError{Err: err} 932 } 933 in.Request = request 934 935 return next.HandleSerialize(ctx, in) 936} 937func awsRestjson1_serializeOpHttpBindingsCreateIndexInput(v *CreateIndexInput, encoder *httpbinding.Encoder) error { 938 if v == nil { 939 return fmt.Errorf("unsupported serialization of nil %T", v) 940 } 941 942 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 943 locationName := "X-Amz-Data-Partition" 944 encoder.SetHeader(locationName).String(*v.DirectoryArn) 945 } 946 947 return nil 948} 949 950func awsRestjson1_serializeOpDocumentCreateIndexInput(v *CreateIndexInput, value smithyjson.Value) error { 951 object := value.Object() 952 defer object.Close() 953 954 { 955 ok := object.Key("IsUnique") 956 ok.Boolean(v.IsUnique) 957 } 958 959 if v.LinkName != nil { 960 ok := object.Key("LinkName") 961 ok.String(*v.LinkName) 962 } 963 964 if v.OrderedIndexedAttributeList != nil { 965 ok := object.Key("OrderedIndexedAttributeList") 966 if err := awsRestjson1_serializeDocumentAttributeKeyList(v.OrderedIndexedAttributeList, ok); err != nil { 967 return err 968 } 969 } 970 971 if v.ParentReference != nil { 972 ok := object.Key("ParentReference") 973 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 974 return err 975 } 976 } 977 978 return nil 979} 980 981type awsRestjson1_serializeOpCreateObject struct { 982} 983 984func (*awsRestjson1_serializeOpCreateObject) ID() string { 985 return "OperationSerializer" 986} 987 988func (m *awsRestjson1_serializeOpCreateObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 989 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 990) { 991 request, ok := in.Request.(*smithyhttp.Request) 992 if !ok { 993 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 994 } 995 996 input, ok := in.Parameters.(*CreateObjectInput) 997 _ = input 998 if !ok { 999 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1000 } 1001 1002 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object") 1003 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1004 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1005 request.Method = "PUT" 1006 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1007 if err != nil { 1008 return out, metadata, &smithy.SerializationError{Err: err} 1009 } 1010 1011 if err := awsRestjson1_serializeOpHttpBindingsCreateObjectInput(input, restEncoder); err != nil { 1012 return out, metadata, &smithy.SerializationError{Err: err} 1013 } 1014 1015 restEncoder.SetHeader("Content-Type").String("application/json") 1016 1017 jsonEncoder := smithyjson.NewEncoder() 1018 if err := awsRestjson1_serializeOpDocumentCreateObjectInput(input, jsonEncoder.Value); err != nil { 1019 return out, metadata, &smithy.SerializationError{Err: err} 1020 } 1021 1022 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1023 return out, metadata, &smithy.SerializationError{Err: err} 1024 } 1025 1026 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1027 return out, metadata, &smithy.SerializationError{Err: err} 1028 } 1029 in.Request = request 1030 1031 return next.HandleSerialize(ctx, in) 1032} 1033func awsRestjson1_serializeOpHttpBindingsCreateObjectInput(v *CreateObjectInput, encoder *httpbinding.Encoder) error { 1034 if v == nil { 1035 return fmt.Errorf("unsupported serialization of nil %T", v) 1036 } 1037 1038 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1039 locationName := "X-Amz-Data-Partition" 1040 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1041 } 1042 1043 return nil 1044} 1045 1046func awsRestjson1_serializeOpDocumentCreateObjectInput(v *CreateObjectInput, value smithyjson.Value) error { 1047 object := value.Object() 1048 defer object.Close() 1049 1050 if v.LinkName != nil { 1051 ok := object.Key("LinkName") 1052 ok.String(*v.LinkName) 1053 } 1054 1055 if v.ObjectAttributeList != nil { 1056 ok := object.Key("ObjectAttributeList") 1057 if err := awsRestjson1_serializeDocumentAttributeKeyAndValueList(v.ObjectAttributeList, ok); err != nil { 1058 return err 1059 } 1060 } 1061 1062 if v.ParentReference != nil { 1063 ok := object.Key("ParentReference") 1064 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 1065 return err 1066 } 1067 } 1068 1069 if v.SchemaFacets != nil { 1070 ok := object.Key("SchemaFacets") 1071 if err := awsRestjson1_serializeDocumentSchemaFacetList(v.SchemaFacets, ok); err != nil { 1072 return err 1073 } 1074 } 1075 1076 return nil 1077} 1078 1079type awsRestjson1_serializeOpCreateSchema struct { 1080} 1081 1082func (*awsRestjson1_serializeOpCreateSchema) ID() string { 1083 return "OperationSerializer" 1084} 1085 1086func (m *awsRestjson1_serializeOpCreateSchema) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1087 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1088) { 1089 request, ok := in.Request.(*smithyhttp.Request) 1090 if !ok { 1091 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1092 } 1093 1094 input, ok := in.Parameters.(*CreateSchemaInput) 1095 _ = input 1096 if !ok { 1097 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1098 } 1099 1100 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/create") 1101 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1102 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1103 request.Method = "PUT" 1104 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1105 if err != nil { 1106 return out, metadata, &smithy.SerializationError{Err: err} 1107 } 1108 1109 restEncoder.SetHeader("Content-Type").String("application/json") 1110 1111 jsonEncoder := smithyjson.NewEncoder() 1112 if err := awsRestjson1_serializeOpDocumentCreateSchemaInput(input, jsonEncoder.Value); err != nil { 1113 return out, metadata, &smithy.SerializationError{Err: err} 1114 } 1115 1116 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1117 return out, metadata, &smithy.SerializationError{Err: err} 1118 } 1119 1120 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1121 return out, metadata, &smithy.SerializationError{Err: err} 1122 } 1123 in.Request = request 1124 1125 return next.HandleSerialize(ctx, in) 1126} 1127func awsRestjson1_serializeOpHttpBindingsCreateSchemaInput(v *CreateSchemaInput, encoder *httpbinding.Encoder) error { 1128 if v == nil { 1129 return fmt.Errorf("unsupported serialization of nil %T", v) 1130 } 1131 1132 return nil 1133} 1134 1135func awsRestjson1_serializeOpDocumentCreateSchemaInput(v *CreateSchemaInput, value smithyjson.Value) error { 1136 object := value.Object() 1137 defer object.Close() 1138 1139 if v.Name != nil { 1140 ok := object.Key("Name") 1141 ok.String(*v.Name) 1142 } 1143 1144 return nil 1145} 1146 1147type awsRestjson1_serializeOpCreateTypedLinkFacet struct { 1148} 1149 1150func (*awsRestjson1_serializeOpCreateTypedLinkFacet) ID() string { 1151 return "OperationSerializer" 1152} 1153 1154func (m *awsRestjson1_serializeOpCreateTypedLinkFacet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1155 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1156) { 1157 request, ok := in.Request.(*smithyhttp.Request) 1158 if !ok { 1159 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1160 } 1161 1162 input, ok := in.Parameters.(*CreateTypedLinkFacetInput) 1163 _ = input 1164 if !ok { 1165 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1166 } 1167 1168 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/facet/create") 1169 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1170 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1171 request.Method = "PUT" 1172 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1173 if err != nil { 1174 return out, metadata, &smithy.SerializationError{Err: err} 1175 } 1176 1177 if err := awsRestjson1_serializeOpHttpBindingsCreateTypedLinkFacetInput(input, restEncoder); err != nil { 1178 return out, metadata, &smithy.SerializationError{Err: err} 1179 } 1180 1181 restEncoder.SetHeader("Content-Type").String("application/json") 1182 1183 jsonEncoder := smithyjson.NewEncoder() 1184 if err := awsRestjson1_serializeOpDocumentCreateTypedLinkFacetInput(input, jsonEncoder.Value); err != nil { 1185 return out, metadata, &smithy.SerializationError{Err: err} 1186 } 1187 1188 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1189 return out, metadata, &smithy.SerializationError{Err: err} 1190 } 1191 1192 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1193 return out, metadata, &smithy.SerializationError{Err: err} 1194 } 1195 in.Request = request 1196 1197 return next.HandleSerialize(ctx, in) 1198} 1199func awsRestjson1_serializeOpHttpBindingsCreateTypedLinkFacetInput(v *CreateTypedLinkFacetInput, encoder *httpbinding.Encoder) error { 1200 if v == nil { 1201 return fmt.Errorf("unsupported serialization of nil %T", v) 1202 } 1203 1204 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 1205 locationName := "X-Amz-Data-Partition" 1206 encoder.SetHeader(locationName).String(*v.SchemaArn) 1207 } 1208 1209 return nil 1210} 1211 1212func awsRestjson1_serializeOpDocumentCreateTypedLinkFacetInput(v *CreateTypedLinkFacetInput, value smithyjson.Value) error { 1213 object := value.Object() 1214 defer object.Close() 1215 1216 if v.Facet != nil { 1217 ok := object.Key("Facet") 1218 if err := awsRestjson1_serializeDocumentTypedLinkFacet(v.Facet, ok); err != nil { 1219 return err 1220 } 1221 } 1222 1223 return nil 1224} 1225 1226type awsRestjson1_serializeOpDeleteDirectory struct { 1227} 1228 1229func (*awsRestjson1_serializeOpDeleteDirectory) ID() string { 1230 return "OperationSerializer" 1231} 1232 1233func (m *awsRestjson1_serializeOpDeleteDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1234 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1235) { 1236 request, ok := in.Request.(*smithyhttp.Request) 1237 if !ok { 1238 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1239 } 1240 1241 input, ok := in.Parameters.(*DeleteDirectoryInput) 1242 _ = input 1243 if !ok { 1244 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1245 } 1246 1247 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/directory") 1248 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1249 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1250 request.Method = "PUT" 1251 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1252 if err != nil { 1253 return out, metadata, &smithy.SerializationError{Err: err} 1254 } 1255 1256 if err := awsRestjson1_serializeOpHttpBindingsDeleteDirectoryInput(input, restEncoder); err != nil { 1257 return out, metadata, &smithy.SerializationError{Err: err} 1258 } 1259 1260 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1261 return out, metadata, &smithy.SerializationError{Err: err} 1262 } 1263 in.Request = request 1264 1265 return next.HandleSerialize(ctx, in) 1266} 1267func awsRestjson1_serializeOpHttpBindingsDeleteDirectoryInput(v *DeleteDirectoryInput, encoder *httpbinding.Encoder) error { 1268 if v == nil { 1269 return fmt.Errorf("unsupported serialization of nil %T", v) 1270 } 1271 1272 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1273 locationName := "X-Amz-Data-Partition" 1274 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1275 } 1276 1277 return nil 1278} 1279 1280type awsRestjson1_serializeOpDeleteFacet struct { 1281} 1282 1283func (*awsRestjson1_serializeOpDeleteFacet) ID() string { 1284 return "OperationSerializer" 1285} 1286 1287func (m *awsRestjson1_serializeOpDeleteFacet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1288 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1289) { 1290 request, ok := in.Request.(*smithyhttp.Request) 1291 if !ok { 1292 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1293 } 1294 1295 input, ok := in.Parameters.(*DeleteFacetInput) 1296 _ = input 1297 if !ok { 1298 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1299 } 1300 1301 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/facet/delete") 1302 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1303 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1304 request.Method = "PUT" 1305 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1306 if err != nil { 1307 return out, metadata, &smithy.SerializationError{Err: err} 1308 } 1309 1310 if err := awsRestjson1_serializeOpHttpBindingsDeleteFacetInput(input, restEncoder); err != nil { 1311 return out, metadata, &smithy.SerializationError{Err: err} 1312 } 1313 1314 restEncoder.SetHeader("Content-Type").String("application/json") 1315 1316 jsonEncoder := smithyjson.NewEncoder() 1317 if err := awsRestjson1_serializeOpDocumentDeleteFacetInput(input, jsonEncoder.Value); err != nil { 1318 return out, metadata, &smithy.SerializationError{Err: err} 1319 } 1320 1321 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1322 return out, metadata, &smithy.SerializationError{Err: err} 1323 } 1324 1325 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1326 return out, metadata, &smithy.SerializationError{Err: err} 1327 } 1328 in.Request = request 1329 1330 return next.HandleSerialize(ctx, in) 1331} 1332func awsRestjson1_serializeOpHttpBindingsDeleteFacetInput(v *DeleteFacetInput, encoder *httpbinding.Encoder) error { 1333 if v == nil { 1334 return fmt.Errorf("unsupported serialization of nil %T", v) 1335 } 1336 1337 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 1338 locationName := "X-Amz-Data-Partition" 1339 encoder.SetHeader(locationName).String(*v.SchemaArn) 1340 } 1341 1342 return nil 1343} 1344 1345func awsRestjson1_serializeOpDocumentDeleteFacetInput(v *DeleteFacetInput, value smithyjson.Value) error { 1346 object := value.Object() 1347 defer object.Close() 1348 1349 if v.Name != nil { 1350 ok := object.Key("Name") 1351 ok.String(*v.Name) 1352 } 1353 1354 return nil 1355} 1356 1357type awsRestjson1_serializeOpDeleteObject struct { 1358} 1359 1360func (*awsRestjson1_serializeOpDeleteObject) ID() string { 1361 return "OperationSerializer" 1362} 1363 1364func (m *awsRestjson1_serializeOpDeleteObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1365 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1366) { 1367 request, ok := in.Request.(*smithyhttp.Request) 1368 if !ok { 1369 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1370 } 1371 1372 input, ok := in.Parameters.(*DeleteObjectInput) 1373 _ = input 1374 if !ok { 1375 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1376 } 1377 1378 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/delete") 1379 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1380 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1381 request.Method = "PUT" 1382 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1383 if err != nil { 1384 return out, metadata, &smithy.SerializationError{Err: err} 1385 } 1386 1387 if err := awsRestjson1_serializeOpHttpBindingsDeleteObjectInput(input, restEncoder); err != nil { 1388 return out, metadata, &smithy.SerializationError{Err: err} 1389 } 1390 1391 restEncoder.SetHeader("Content-Type").String("application/json") 1392 1393 jsonEncoder := smithyjson.NewEncoder() 1394 if err := awsRestjson1_serializeOpDocumentDeleteObjectInput(input, jsonEncoder.Value); err != nil { 1395 return out, metadata, &smithy.SerializationError{Err: err} 1396 } 1397 1398 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1399 return out, metadata, &smithy.SerializationError{Err: err} 1400 } 1401 1402 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1403 return out, metadata, &smithy.SerializationError{Err: err} 1404 } 1405 in.Request = request 1406 1407 return next.HandleSerialize(ctx, in) 1408} 1409func awsRestjson1_serializeOpHttpBindingsDeleteObjectInput(v *DeleteObjectInput, encoder *httpbinding.Encoder) error { 1410 if v == nil { 1411 return fmt.Errorf("unsupported serialization of nil %T", v) 1412 } 1413 1414 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1415 locationName := "X-Amz-Data-Partition" 1416 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1417 } 1418 1419 return nil 1420} 1421 1422func awsRestjson1_serializeOpDocumentDeleteObjectInput(v *DeleteObjectInput, value smithyjson.Value) error { 1423 object := value.Object() 1424 defer object.Close() 1425 1426 if v.ObjectReference != nil { 1427 ok := object.Key("ObjectReference") 1428 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 1429 return err 1430 } 1431 } 1432 1433 return nil 1434} 1435 1436type awsRestjson1_serializeOpDeleteSchema struct { 1437} 1438 1439func (*awsRestjson1_serializeOpDeleteSchema) ID() string { 1440 return "OperationSerializer" 1441} 1442 1443func (m *awsRestjson1_serializeOpDeleteSchema) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1444 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1445) { 1446 request, ok := in.Request.(*smithyhttp.Request) 1447 if !ok { 1448 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1449 } 1450 1451 input, ok := in.Parameters.(*DeleteSchemaInput) 1452 _ = input 1453 if !ok { 1454 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1455 } 1456 1457 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema") 1458 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1459 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1460 request.Method = "PUT" 1461 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1462 if err != nil { 1463 return out, metadata, &smithy.SerializationError{Err: err} 1464 } 1465 1466 if err := awsRestjson1_serializeOpHttpBindingsDeleteSchemaInput(input, restEncoder); err != nil { 1467 return out, metadata, &smithy.SerializationError{Err: err} 1468 } 1469 1470 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1471 return out, metadata, &smithy.SerializationError{Err: err} 1472 } 1473 in.Request = request 1474 1475 return next.HandleSerialize(ctx, in) 1476} 1477func awsRestjson1_serializeOpHttpBindingsDeleteSchemaInput(v *DeleteSchemaInput, encoder *httpbinding.Encoder) error { 1478 if v == nil { 1479 return fmt.Errorf("unsupported serialization of nil %T", v) 1480 } 1481 1482 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 1483 locationName := "X-Amz-Data-Partition" 1484 encoder.SetHeader(locationName).String(*v.SchemaArn) 1485 } 1486 1487 return nil 1488} 1489 1490type awsRestjson1_serializeOpDeleteTypedLinkFacet struct { 1491} 1492 1493func (*awsRestjson1_serializeOpDeleteTypedLinkFacet) ID() string { 1494 return "OperationSerializer" 1495} 1496 1497func (m *awsRestjson1_serializeOpDeleteTypedLinkFacet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1498 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1499) { 1500 request, ok := in.Request.(*smithyhttp.Request) 1501 if !ok { 1502 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1503 } 1504 1505 input, ok := in.Parameters.(*DeleteTypedLinkFacetInput) 1506 _ = input 1507 if !ok { 1508 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1509 } 1510 1511 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/facet/delete") 1512 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1513 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1514 request.Method = "PUT" 1515 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1516 if err != nil { 1517 return out, metadata, &smithy.SerializationError{Err: err} 1518 } 1519 1520 if err := awsRestjson1_serializeOpHttpBindingsDeleteTypedLinkFacetInput(input, restEncoder); err != nil { 1521 return out, metadata, &smithy.SerializationError{Err: err} 1522 } 1523 1524 restEncoder.SetHeader("Content-Type").String("application/json") 1525 1526 jsonEncoder := smithyjson.NewEncoder() 1527 if err := awsRestjson1_serializeOpDocumentDeleteTypedLinkFacetInput(input, jsonEncoder.Value); err != nil { 1528 return out, metadata, &smithy.SerializationError{Err: err} 1529 } 1530 1531 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1532 return out, metadata, &smithy.SerializationError{Err: err} 1533 } 1534 1535 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1536 return out, metadata, &smithy.SerializationError{Err: err} 1537 } 1538 in.Request = request 1539 1540 return next.HandleSerialize(ctx, in) 1541} 1542func awsRestjson1_serializeOpHttpBindingsDeleteTypedLinkFacetInput(v *DeleteTypedLinkFacetInput, encoder *httpbinding.Encoder) error { 1543 if v == nil { 1544 return fmt.Errorf("unsupported serialization of nil %T", v) 1545 } 1546 1547 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 1548 locationName := "X-Amz-Data-Partition" 1549 encoder.SetHeader(locationName).String(*v.SchemaArn) 1550 } 1551 1552 return nil 1553} 1554 1555func awsRestjson1_serializeOpDocumentDeleteTypedLinkFacetInput(v *DeleteTypedLinkFacetInput, value smithyjson.Value) error { 1556 object := value.Object() 1557 defer object.Close() 1558 1559 if v.Name != nil { 1560 ok := object.Key("Name") 1561 ok.String(*v.Name) 1562 } 1563 1564 return nil 1565} 1566 1567type awsRestjson1_serializeOpDetachFromIndex struct { 1568} 1569 1570func (*awsRestjson1_serializeOpDetachFromIndex) ID() string { 1571 return "OperationSerializer" 1572} 1573 1574func (m *awsRestjson1_serializeOpDetachFromIndex) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1575 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1576) { 1577 request, ok := in.Request.(*smithyhttp.Request) 1578 if !ok { 1579 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1580 } 1581 1582 input, ok := in.Parameters.(*DetachFromIndexInput) 1583 _ = input 1584 if !ok { 1585 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1586 } 1587 1588 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/index/detach") 1589 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1590 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1591 request.Method = "PUT" 1592 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1593 if err != nil { 1594 return out, metadata, &smithy.SerializationError{Err: err} 1595 } 1596 1597 if err := awsRestjson1_serializeOpHttpBindingsDetachFromIndexInput(input, restEncoder); err != nil { 1598 return out, metadata, &smithy.SerializationError{Err: err} 1599 } 1600 1601 restEncoder.SetHeader("Content-Type").String("application/json") 1602 1603 jsonEncoder := smithyjson.NewEncoder() 1604 if err := awsRestjson1_serializeOpDocumentDetachFromIndexInput(input, jsonEncoder.Value); err != nil { 1605 return out, metadata, &smithy.SerializationError{Err: err} 1606 } 1607 1608 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1609 return out, metadata, &smithy.SerializationError{Err: err} 1610 } 1611 1612 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1613 return out, metadata, &smithy.SerializationError{Err: err} 1614 } 1615 in.Request = request 1616 1617 return next.HandleSerialize(ctx, in) 1618} 1619func awsRestjson1_serializeOpHttpBindingsDetachFromIndexInput(v *DetachFromIndexInput, encoder *httpbinding.Encoder) error { 1620 if v == nil { 1621 return fmt.Errorf("unsupported serialization of nil %T", v) 1622 } 1623 1624 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1625 locationName := "X-Amz-Data-Partition" 1626 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1627 } 1628 1629 return nil 1630} 1631 1632func awsRestjson1_serializeOpDocumentDetachFromIndexInput(v *DetachFromIndexInput, value smithyjson.Value) error { 1633 object := value.Object() 1634 defer object.Close() 1635 1636 if v.IndexReference != nil { 1637 ok := object.Key("IndexReference") 1638 if err := awsRestjson1_serializeDocumentObjectReference(v.IndexReference, ok); err != nil { 1639 return err 1640 } 1641 } 1642 1643 if v.TargetReference != nil { 1644 ok := object.Key("TargetReference") 1645 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetReference, ok); err != nil { 1646 return err 1647 } 1648 } 1649 1650 return nil 1651} 1652 1653type awsRestjson1_serializeOpDetachObject struct { 1654} 1655 1656func (*awsRestjson1_serializeOpDetachObject) ID() string { 1657 return "OperationSerializer" 1658} 1659 1660func (m *awsRestjson1_serializeOpDetachObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1661 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1662) { 1663 request, ok := in.Request.(*smithyhttp.Request) 1664 if !ok { 1665 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1666 } 1667 1668 input, ok := in.Parameters.(*DetachObjectInput) 1669 _ = input 1670 if !ok { 1671 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1672 } 1673 1674 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/detach") 1675 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1676 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1677 request.Method = "PUT" 1678 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1679 if err != nil { 1680 return out, metadata, &smithy.SerializationError{Err: err} 1681 } 1682 1683 if err := awsRestjson1_serializeOpHttpBindingsDetachObjectInput(input, restEncoder); err != nil { 1684 return out, metadata, &smithy.SerializationError{Err: err} 1685 } 1686 1687 restEncoder.SetHeader("Content-Type").String("application/json") 1688 1689 jsonEncoder := smithyjson.NewEncoder() 1690 if err := awsRestjson1_serializeOpDocumentDetachObjectInput(input, jsonEncoder.Value); err != nil { 1691 return out, metadata, &smithy.SerializationError{Err: err} 1692 } 1693 1694 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1695 return out, metadata, &smithy.SerializationError{Err: err} 1696 } 1697 1698 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1699 return out, metadata, &smithy.SerializationError{Err: err} 1700 } 1701 in.Request = request 1702 1703 return next.HandleSerialize(ctx, in) 1704} 1705func awsRestjson1_serializeOpHttpBindingsDetachObjectInput(v *DetachObjectInput, encoder *httpbinding.Encoder) error { 1706 if v == nil { 1707 return fmt.Errorf("unsupported serialization of nil %T", v) 1708 } 1709 1710 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1711 locationName := "X-Amz-Data-Partition" 1712 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1713 } 1714 1715 return nil 1716} 1717 1718func awsRestjson1_serializeOpDocumentDetachObjectInput(v *DetachObjectInput, value smithyjson.Value) error { 1719 object := value.Object() 1720 defer object.Close() 1721 1722 if v.LinkName != nil { 1723 ok := object.Key("LinkName") 1724 ok.String(*v.LinkName) 1725 } 1726 1727 if v.ParentReference != nil { 1728 ok := object.Key("ParentReference") 1729 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 1730 return err 1731 } 1732 } 1733 1734 return nil 1735} 1736 1737type awsRestjson1_serializeOpDetachPolicy struct { 1738} 1739 1740func (*awsRestjson1_serializeOpDetachPolicy) ID() string { 1741 return "OperationSerializer" 1742} 1743 1744func (m *awsRestjson1_serializeOpDetachPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1745 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1746) { 1747 request, ok := in.Request.(*smithyhttp.Request) 1748 if !ok { 1749 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1750 } 1751 1752 input, ok := in.Parameters.(*DetachPolicyInput) 1753 _ = input 1754 if !ok { 1755 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1756 } 1757 1758 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/policy/detach") 1759 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1760 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1761 request.Method = "PUT" 1762 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1763 if err != nil { 1764 return out, metadata, &smithy.SerializationError{Err: err} 1765 } 1766 1767 if err := awsRestjson1_serializeOpHttpBindingsDetachPolicyInput(input, restEncoder); err != nil { 1768 return out, metadata, &smithy.SerializationError{Err: err} 1769 } 1770 1771 restEncoder.SetHeader("Content-Type").String("application/json") 1772 1773 jsonEncoder := smithyjson.NewEncoder() 1774 if err := awsRestjson1_serializeOpDocumentDetachPolicyInput(input, jsonEncoder.Value); err != nil { 1775 return out, metadata, &smithy.SerializationError{Err: err} 1776 } 1777 1778 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1779 return out, metadata, &smithy.SerializationError{Err: err} 1780 } 1781 1782 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1783 return out, metadata, &smithy.SerializationError{Err: err} 1784 } 1785 in.Request = request 1786 1787 return next.HandleSerialize(ctx, in) 1788} 1789func awsRestjson1_serializeOpHttpBindingsDetachPolicyInput(v *DetachPolicyInput, encoder *httpbinding.Encoder) error { 1790 if v == nil { 1791 return fmt.Errorf("unsupported serialization of nil %T", v) 1792 } 1793 1794 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1795 locationName := "X-Amz-Data-Partition" 1796 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1797 } 1798 1799 return nil 1800} 1801 1802func awsRestjson1_serializeOpDocumentDetachPolicyInput(v *DetachPolicyInput, value smithyjson.Value) error { 1803 object := value.Object() 1804 defer object.Close() 1805 1806 if v.ObjectReference != nil { 1807 ok := object.Key("ObjectReference") 1808 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 1809 return err 1810 } 1811 } 1812 1813 if v.PolicyReference != nil { 1814 ok := object.Key("PolicyReference") 1815 if err := awsRestjson1_serializeDocumentObjectReference(v.PolicyReference, ok); err != nil { 1816 return err 1817 } 1818 } 1819 1820 return nil 1821} 1822 1823type awsRestjson1_serializeOpDetachTypedLink struct { 1824} 1825 1826func (*awsRestjson1_serializeOpDetachTypedLink) ID() string { 1827 return "OperationSerializer" 1828} 1829 1830func (m *awsRestjson1_serializeOpDetachTypedLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1831 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1832) { 1833 request, ok := in.Request.(*smithyhttp.Request) 1834 if !ok { 1835 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1836 } 1837 1838 input, ok := in.Parameters.(*DetachTypedLinkInput) 1839 _ = input 1840 if !ok { 1841 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1842 } 1843 1844 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/detach") 1845 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1846 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1847 request.Method = "PUT" 1848 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1849 if err != nil { 1850 return out, metadata, &smithy.SerializationError{Err: err} 1851 } 1852 1853 if err := awsRestjson1_serializeOpHttpBindingsDetachTypedLinkInput(input, restEncoder); err != nil { 1854 return out, metadata, &smithy.SerializationError{Err: err} 1855 } 1856 1857 restEncoder.SetHeader("Content-Type").String("application/json") 1858 1859 jsonEncoder := smithyjson.NewEncoder() 1860 if err := awsRestjson1_serializeOpDocumentDetachTypedLinkInput(input, jsonEncoder.Value); err != nil { 1861 return out, metadata, &smithy.SerializationError{Err: err} 1862 } 1863 1864 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1865 return out, metadata, &smithy.SerializationError{Err: err} 1866 } 1867 1868 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1869 return out, metadata, &smithy.SerializationError{Err: err} 1870 } 1871 in.Request = request 1872 1873 return next.HandleSerialize(ctx, in) 1874} 1875func awsRestjson1_serializeOpHttpBindingsDetachTypedLinkInput(v *DetachTypedLinkInput, encoder *httpbinding.Encoder) error { 1876 if v == nil { 1877 return fmt.Errorf("unsupported serialization of nil %T", v) 1878 } 1879 1880 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1881 locationName := "X-Amz-Data-Partition" 1882 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1883 } 1884 1885 return nil 1886} 1887 1888func awsRestjson1_serializeOpDocumentDetachTypedLinkInput(v *DetachTypedLinkInput, value smithyjson.Value) error { 1889 object := value.Object() 1890 defer object.Close() 1891 1892 if v.TypedLinkSpecifier != nil { 1893 ok := object.Key("TypedLinkSpecifier") 1894 if err := awsRestjson1_serializeDocumentTypedLinkSpecifier(v.TypedLinkSpecifier, ok); err != nil { 1895 return err 1896 } 1897 } 1898 1899 return nil 1900} 1901 1902type awsRestjson1_serializeOpDisableDirectory struct { 1903} 1904 1905func (*awsRestjson1_serializeOpDisableDirectory) ID() string { 1906 return "OperationSerializer" 1907} 1908 1909func (m *awsRestjson1_serializeOpDisableDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1910 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1911) { 1912 request, ok := in.Request.(*smithyhttp.Request) 1913 if !ok { 1914 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1915 } 1916 1917 input, ok := in.Parameters.(*DisableDirectoryInput) 1918 _ = input 1919 if !ok { 1920 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1921 } 1922 1923 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/directory/disable") 1924 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1925 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1926 request.Method = "PUT" 1927 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1928 if err != nil { 1929 return out, metadata, &smithy.SerializationError{Err: err} 1930 } 1931 1932 if err := awsRestjson1_serializeOpHttpBindingsDisableDirectoryInput(input, restEncoder); err != nil { 1933 return out, metadata, &smithy.SerializationError{Err: err} 1934 } 1935 1936 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1937 return out, metadata, &smithy.SerializationError{Err: err} 1938 } 1939 in.Request = request 1940 1941 return next.HandleSerialize(ctx, in) 1942} 1943func awsRestjson1_serializeOpHttpBindingsDisableDirectoryInput(v *DisableDirectoryInput, encoder *httpbinding.Encoder) error { 1944 if v == nil { 1945 return fmt.Errorf("unsupported serialization of nil %T", v) 1946 } 1947 1948 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 1949 locationName := "X-Amz-Data-Partition" 1950 encoder.SetHeader(locationName).String(*v.DirectoryArn) 1951 } 1952 1953 return nil 1954} 1955 1956type awsRestjson1_serializeOpEnableDirectory struct { 1957} 1958 1959func (*awsRestjson1_serializeOpEnableDirectory) ID() string { 1960 return "OperationSerializer" 1961} 1962 1963func (m *awsRestjson1_serializeOpEnableDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1964 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1965) { 1966 request, ok := in.Request.(*smithyhttp.Request) 1967 if !ok { 1968 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1969 } 1970 1971 input, ok := in.Parameters.(*EnableDirectoryInput) 1972 _ = input 1973 if !ok { 1974 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1975 } 1976 1977 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/directory/enable") 1978 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1979 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1980 request.Method = "PUT" 1981 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1982 if err != nil { 1983 return out, metadata, &smithy.SerializationError{Err: err} 1984 } 1985 1986 if err := awsRestjson1_serializeOpHttpBindingsEnableDirectoryInput(input, restEncoder); err != nil { 1987 return out, metadata, &smithy.SerializationError{Err: err} 1988 } 1989 1990 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1991 return out, metadata, &smithy.SerializationError{Err: err} 1992 } 1993 in.Request = request 1994 1995 return next.HandleSerialize(ctx, in) 1996} 1997func awsRestjson1_serializeOpHttpBindingsEnableDirectoryInput(v *EnableDirectoryInput, encoder *httpbinding.Encoder) error { 1998 if v == nil { 1999 return fmt.Errorf("unsupported serialization of nil %T", v) 2000 } 2001 2002 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 2003 locationName := "X-Amz-Data-Partition" 2004 encoder.SetHeader(locationName).String(*v.DirectoryArn) 2005 } 2006 2007 return nil 2008} 2009 2010type awsRestjson1_serializeOpGetAppliedSchemaVersion struct { 2011} 2012 2013func (*awsRestjson1_serializeOpGetAppliedSchemaVersion) ID() string { 2014 return "OperationSerializer" 2015} 2016 2017func (m *awsRestjson1_serializeOpGetAppliedSchemaVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2018 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2019) { 2020 request, ok := in.Request.(*smithyhttp.Request) 2021 if !ok { 2022 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2023 } 2024 2025 input, ok := in.Parameters.(*GetAppliedSchemaVersionInput) 2026 _ = input 2027 if !ok { 2028 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2029 } 2030 2031 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/getappliedschema") 2032 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2033 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2034 request.Method = "POST" 2035 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2036 if err != nil { 2037 return out, metadata, &smithy.SerializationError{Err: err} 2038 } 2039 2040 restEncoder.SetHeader("Content-Type").String("application/json") 2041 2042 jsonEncoder := smithyjson.NewEncoder() 2043 if err := awsRestjson1_serializeOpDocumentGetAppliedSchemaVersionInput(input, jsonEncoder.Value); err != nil { 2044 return out, metadata, &smithy.SerializationError{Err: err} 2045 } 2046 2047 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2048 return out, metadata, &smithy.SerializationError{Err: err} 2049 } 2050 2051 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2052 return out, metadata, &smithy.SerializationError{Err: err} 2053 } 2054 in.Request = request 2055 2056 return next.HandleSerialize(ctx, in) 2057} 2058func awsRestjson1_serializeOpHttpBindingsGetAppliedSchemaVersionInput(v *GetAppliedSchemaVersionInput, encoder *httpbinding.Encoder) error { 2059 if v == nil { 2060 return fmt.Errorf("unsupported serialization of nil %T", v) 2061 } 2062 2063 return nil 2064} 2065 2066func awsRestjson1_serializeOpDocumentGetAppliedSchemaVersionInput(v *GetAppliedSchemaVersionInput, value smithyjson.Value) error { 2067 object := value.Object() 2068 defer object.Close() 2069 2070 if v.SchemaArn != nil { 2071 ok := object.Key("SchemaArn") 2072 ok.String(*v.SchemaArn) 2073 } 2074 2075 return nil 2076} 2077 2078type awsRestjson1_serializeOpGetDirectory struct { 2079} 2080 2081func (*awsRestjson1_serializeOpGetDirectory) ID() string { 2082 return "OperationSerializer" 2083} 2084 2085func (m *awsRestjson1_serializeOpGetDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2086 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2087) { 2088 request, ok := in.Request.(*smithyhttp.Request) 2089 if !ok { 2090 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2091 } 2092 2093 input, ok := in.Parameters.(*GetDirectoryInput) 2094 _ = input 2095 if !ok { 2096 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2097 } 2098 2099 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/directory/get") 2100 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2101 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2102 request.Method = "POST" 2103 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2104 if err != nil { 2105 return out, metadata, &smithy.SerializationError{Err: err} 2106 } 2107 2108 if err := awsRestjson1_serializeOpHttpBindingsGetDirectoryInput(input, restEncoder); err != nil { 2109 return out, metadata, &smithy.SerializationError{Err: err} 2110 } 2111 2112 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2113 return out, metadata, &smithy.SerializationError{Err: err} 2114 } 2115 in.Request = request 2116 2117 return next.HandleSerialize(ctx, in) 2118} 2119func awsRestjson1_serializeOpHttpBindingsGetDirectoryInput(v *GetDirectoryInput, encoder *httpbinding.Encoder) error { 2120 if v == nil { 2121 return fmt.Errorf("unsupported serialization of nil %T", v) 2122 } 2123 2124 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 2125 locationName := "X-Amz-Data-Partition" 2126 encoder.SetHeader(locationName).String(*v.DirectoryArn) 2127 } 2128 2129 return nil 2130} 2131 2132type awsRestjson1_serializeOpGetFacet struct { 2133} 2134 2135func (*awsRestjson1_serializeOpGetFacet) ID() string { 2136 return "OperationSerializer" 2137} 2138 2139func (m *awsRestjson1_serializeOpGetFacet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2140 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2141) { 2142 request, ok := in.Request.(*smithyhttp.Request) 2143 if !ok { 2144 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2145 } 2146 2147 input, ok := in.Parameters.(*GetFacetInput) 2148 _ = input 2149 if !ok { 2150 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2151 } 2152 2153 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/facet") 2154 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2155 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2156 request.Method = "POST" 2157 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2158 if err != nil { 2159 return out, metadata, &smithy.SerializationError{Err: err} 2160 } 2161 2162 if err := awsRestjson1_serializeOpHttpBindingsGetFacetInput(input, restEncoder); err != nil { 2163 return out, metadata, &smithy.SerializationError{Err: err} 2164 } 2165 2166 restEncoder.SetHeader("Content-Type").String("application/json") 2167 2168 jsonEncoder := smithyjson.NewEncoder() 2169 if err := awsRestjson1_serializeOpDocumentGetFacetInput(input, jsonEncoder.Value); err != nil { 2170 return out, metadata, &smithy.SerializationError{Err: err} 2171 } 2172 2173 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2174 return out, metadata, &smithy.SerializationError{Err: err} 2175 } 2176 2177 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2178 return out, metadata, &smithy.SerializationError{Err: err} 2179 } 2180 in.Request = request 2181 2182 return next.HandleSerialize(ctx, in) 2183} 2184func awsRestjson1_serializeOpHttpBindingsGetFacetInput(v *GetFacetInput, encoder *httpbinding.Encoder) error { 2185 if v == nil { 2186 return fmt.Errorf("unsupported serialization of nil %T", v) 2187 } 2188 2189 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 2190 locationName := "X-Amz-Data-Partition" 2191 encoder.SetHeader(locationName).String(*v.SchemaArn) 2192 } 2193 2194 return nil 2195} 2196 2197func awsRestjson1_serializeOpDocumentGetFacetInput(v *GetFacetInput, value smithyjson.Value) error { 2198 object := value.Object() 2199 defer object.Close() 2200 2201 if v.Name != nil { 2202 ok := object.Key("Name") 2203 ok.String(*v.Name) 2204 } 2205 2206 return nil 2207} 2208 2209type awsRestjson1_serializeOpGetLinkAttributes struct { 2210} 2211 2212func (*awsRestjson1_serializeOpGetLinkAttributes) ID() string { 2213 return "OperationSerializer" 2214} 2215 2216func (m *awsRestjson1_serializeOpGetLinkAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2217 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2218) { 2219 request, ok := in.Request.(*smithyhttp.Request) 2220 if !ok { 2221 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2222 } 2223 2224 input, ok := in.Parameters.(*GetLinkAttributesInput) 2225 _ = input 2226 if !ok { 2227 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2228 } 2229 2230 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/attributes/get") 2231 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2232 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2233 request.Method = "POST" 2234 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2235 if err != nil { 2236 return out, metadata, &smithy.SerializationError{Err: err} 2237 } 2238 2239 if err := awsRestjson1_serializeOpHttpBindingsGetLinkAttributesInput(input, restEncoder); err != nil { 2240 return out, metadata, &smithy.SerializationError{Err: err} 2241 } 2242 2243 restEncoder.SetHeader("Content-Type").String("application/json") 2244 2245 jsonEncoder := smithyjson.NewEncoder() 2246 if err := awsRestjson1_serializeOpDocumentGetLinkAttributesInput(input, jsonEncoder.Value); err != nil { 2247 return out, metadata, &smithy.SerializationError{Err: err} 2248 } 2249 2250 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2251 return out, metadata, &smithy.SerializationError{Err: err} 2252 } 2253 2254 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2255 return out, metadata, &smithy.SerializationError{Err: err} 2256 } 2257 in.Request = request 2258 2259 return next.HandleSerialize(ctx, in) 2260} 2261func awsRestjson1_serializeOpHttpBindingsGetLinkAttributesInput(v *GetLinkAttributesInput, encoder *httpbinding.Encoder) error { 2262 if v == nil { 2263 return fmt.Errorf("unsupported serialization of nil %T", v) 2264 } 2265 2266 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 2267 locationName := "X-Amz-Data-Partition" 2268 encoder.SetHeader(locationName).String(*v.DirectoryArn) 2269 } 2270 2271 return nil 2272} 2273 2274func awsRestjson1_serializeOpDocumentGetLinkAttributesInput(v *GetLinkAttributesInput, value smithyjson.Value) error { 2275 object := value.Object() 2276 defer object.Close() 2277 2278 if v.AttributeNames != nil { 2279 ok := object.Key("AttributeNames") 2280 if err := awsRestjson1_serializeDocumentAttributeNameList(v.AttributeNames, ok); err != nil { 2281 return err 2282 } 2283 } 2284 2285 if len(v.ConsistencyLevel) > 0 { 2286 ok := object.Key("ConsistencyLevel") 2287 ok.String(string(v.ConsistencyLevel)) 2288 } 2289 2290 if v.TypedLinkSpecifier != nil { 2291 ok := object.Key("TypedLinkSpecifier") 2292 if err := awsRestjson1_serializeDocumentTypedLinkSpecifier(v.TypedLinkSpecifier, ok); err != nil { 2293 return err 2294 } 2295 } 2296 2297 return nil 2298} 2299 2300type awsRestjson1_serializeOpGetObjectAttributes struct { 2301} 2302 2303func (*awsRestjson1_serializeOpGetObjectAttributes) ID() string { 2304 return "OperationSerializer" 2305} 2306 2307func (m *awsRestjson1_serializeOpGetObjectAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2308 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2309) { 2310 request, ok := in.Request.(*smithyhttp.Request) 2311 if !ok { 2312 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2313 } 2314 2315 input, ok := in.Parameters.(*GetObjectAttributesInput) 2316 _ = input 2317 if !ok { 2318 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2319 } 2320 2321 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/attributes/get") 2322 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2323 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2324 request.Method = "POST" 2325 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2326 if err != nil { 2327 return out, metadata, &smithy.SerializationError{Err: err} 2328 } 2329 2330 if err := awsRestjson1_serializeOpHttpBindingsGetObjectAttributesInput(input, restEncoder); err != nil { 2331 return out, metadata, &smithy.SerializationError{Err: err} 2332 } 2333 2334 restEncoder.SetHeader("Content-Type").String("application/json") 2335 2336 jsonEncoder := smithyjson.NewEncoder() 2337 if err := awsRestjson1_serializeOpDocumentGetObjectAttributesInput(input, jsonEncoder.Value); err != nil { 2338 return out, metadata, &smithy.SerializationError{Err: err} 2339 } 2340 2341 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2342 return out, metadata, &smithy.SerializationError{Err: err} 2343 } 2344 2345 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2346 return out, metadata, &smithy.SerializationError{Err: err} 2347 } 2348 in.Request = request 2349 2350 return next.HandleSerialize(ctx, in) 2351} 2352func awsRestjson1_serializeOpHttpBindingsGetObjectAttributesInput(v *GetObjectAttributesInput, encoder *httpbinding.Encoder) error { 2353 if v == nil { 2354 return fmt.Errorf("unsupported serialization of nil %T", v) 2355 } 2356 2357 if len(v.ConsistencyLevel) > 0 { 2358 locationName := "X-Amz-Consistency-Level" 2359 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 2360 } 2361 2362 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 2363 locationName := "X-Amz-Data-Partition" 2364 encoder.SetHeader(locationName).String(*v.DirectoryArn) 2365 } 2366 2367 return nil 2368} 2369 2370func awsRestjson1_serializeOpDocumentGetObjectAttributesInput(v *GetObjectAttributesInput, value smithyjson.Value) error { 2371 object := value.Object() 2372 defer object.Close() 2373 2374 if v.AttributeNames != nil { 2375 ok := object.Key("AttributeNames") 2376 if err := awsRestjson1_serializeDocumentAttributeNameList(v.AttributeNames, ok); err != nil { 2377 return err 2378 } 2379 } 2380 2381 if v.ObjectReference != nil { 2382 ok := object.Key("ObjectReference") 2383 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 2384 return err 2385 } 2386 } 2387 2388 if v.SchemaFacet != nil { 2389 ok := object.Key("SchemaFacet") 2390 if err := awsRestjson1_serializeDocumentSchemaFacet(v.SchemaFacet, ok); err != nil { 2391 return err 2392 } 2393 } 2394 2395 return nil 2396} 2397 2398type awsRestjson1_serializeOpGetObjectInformation struct { 2399} 2400 2401func (*awsRestjson1_serializeOpGetObjectInformation) ID() string { 2402 return "OperationSerializer" 2403} 2404 2405func (m *awsRestjson1_serializeOpGetObjectInformation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2406 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2407) { 2408 request, ok := in.Request.(*smithyhttp.Request) 2409 if !ok { 2410 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2411 } 2412 2413 input, ok := in.Parameters.(*GetObjectInformationInput) 2414 _ = input 2415 if !ok { 2416 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2417 } 2418 2419 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/information") 2420 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2421 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2422 request.Method = "POST" 2423 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2424 if err != nil { 2425 return out, metadata, &smithy.SerializationError{Err: err} 2426 } 2427 2428 if err := awsRestjson1_serializeOpHttpBindingsGetObjectInformationInput(input, restEncoder); err != nil { 2429 return out, metadata, &smithy.SerializationError{Err: err} 2430 } 2431 2432 restEncoder.SetHeader("Content-Type").String("application/json") 2433 2434 jsonEncoder := smithyjson.NewEncoder() 2435 if err := awsRestjson1_serializeOpDocumentGetObjectInformationInput(input, jsonEncoder.Value); err != nil { 2436 return out, metadata, &smithy.SerializationError{Err: err} 2437 } 2438 2439 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2440 return out, metadata, &smithy.SerializationError{Err: err} 2441 } 2442 2443 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2444 return out, metadata, &smithy.SerializationError{Err: err} 2445 } 2446 in.Request = request 2447 2448 return next.HandleSerialize(ctx, in) 2449} 2450func awsRestjson1_serializeOpHttpBindingsGetObjectInformationInput(v *GetObjectInformationInput, encoder *httpbinding.Encoder) error { 2451 if v == nil { 2452 return fmt.Errorf("unsupported serialization of nil %T", v) 2453 } 2454 2455 if len(v.ConsistencyLevel) > 0 { 2456 locationName := "X-Amz-Consistency-Level" 2457 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 2458 } 2459 2460 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 2461 locationName := "X-Amz-Data-Partition" 2462 encoder.SetHeader(locationName).String(*v.DirectoryArn) 2463 } 2464 2465 return nil 2466} 2467 2468func awsRestjson1_serializeOpDocumentGetObjectInformationInput(v *GetObjectInformationInput, value smithyjson.Value) error { 2469 object := value.Object() 2470 defer object.Close() 2471 2472 if v.ObjectReference != nil { 2473 ok := object.Key("ObjectReference") 2474 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 2475 return err 2476 } 2477 } 2478 2479 return nil 2480} 2481 2482type awsRestjson1_serializeOpGetSchemaAsJson struct { 2483} 2484 2485func (*awsRestjson1_serializeOpGetSchemaAsJson) ID() string { 2486 return "OperationSerializer" 2487} 2488 2489func (m *awsRestjson1_serializeOpGetSchemaAsJson) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2490 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2491) { 2492 request, ok := in.Request.(*smithyhttp.Request) 2493 if !ok { 2494 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2495 } 2496 2497 input, ok := in.Parameters.(*GetSchemaAsJsonInput) 2498 _ = input 2499 if !ok { 2500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2501 } 2502 2503 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/json") 2504 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2505 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2506 request.Method = "POST" 2507 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2508 if err != nil { 2509 return out, metadata, &smithy.SerializationError{Err: err} 2510 } 2511 2512 if err := awsRestjson1_serializeOpHttpBindingsGetSchemaAsJsonInput(input, restEncoder); err != nil { 2513 return out, metadata, &smithy.SerializationError{Err: err} 2514 } 2515 2516 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2517 return out, metadata, &smithy.SerializationError{Err: err} 2518 } 2519 in.Request = request 2520 2521 return next.HandleSerialize(ctx, in) 2522} 2523func awsRestjson1_serializeOpHttpBindingsGetSchemaAsJsonInput(v *GetSchemaAsJsonInput, encoder *httpbinding.Encoder) error { 2524 if v == nil { 2525 return fmt.Errorf("unsupported serialization of nil %T", v) 2526 } 2527 2528 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 2529 locationName := "X-Amz-Data-Partition" 2530 encoder.SetHeader(locationName).String(*v.SchemaArn) 2531 } 2532 2533 return nil 2534} 2535 2536type awsRestjson1_serializeOpGetTypedLinkFacetInformation struct { 2537} 2538 2539func (*awsRestjson1_serializeOpGetTypedLinkFacetInformation) ID() string { 2540 return "OperationSerializer" 2541} 2542 2543func (m *awsRestjson1_serializeOpGetTypedLinkFacetInformation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2544 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2545) { 2546 request, ok := in.Request.(*smithyhttp.Request) 2547 if !ok { 2548 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2549 } 2550 2551 input, ok := in.Parameters.(*GetTypedLinkFacetInformationInput) 2552 _ = input 2553 if !ok { 2554 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2555 } 2556 2557 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/facet/get") 2558 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2559 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2560 request.Method = "POST" 2561 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2562 if err != nil { 2563 return out, metadata, &smithy.SerializationError{Err: err} 2564 } 2565 2566 if err := awsRestjson1_serializeOpHttpBindingsGetTypedLinkFacetInformationInput(input, restEncoder); err != nil { 2567 return out, metadata, &smithy.SerializationError{Err: err} 2568 } 2569 2570 restEncoder.SetHeader("Content-Type").String("application/json") 2571 2572 jsonEncoder := smithyjson.NewEncoder() 2573 if err := awsRestjson1_serializeOpDocumentGetTypedLinkFacetInformationInput(input, jsonEncoder.Value); err != nil { 2574 return out, metadata, &smithy.SerializationError{Err: err} 2575 } 2576 2577 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); 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_serializeOpHttpBindingsGetTypedLinkFacetInformationInput(v *GetTypedLinkFacetInformationInput, encoder *httpbinding.Encoder) error { 2589 if v == nil { 2590 return fmt.Errorf("unsupported serialization of nil %T", v) 2591 } 2592 2593 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 2594 locationName := "X-Amz-Data-Partition" 2595 encoder.SetHeader(locationName).String(*v.SchemaArn) 2596 } 2597 2598 return nil 2599} 2600 2601func awsRestjson1_serializeOpDocumentGetTypedLinkFacetInformationInput(v *GetTypedLinkFacetInformationInput, value smithyjson.Value) error { 2602 object := value.Object() 2603 defer object.Close() 2604 2605 if v.Name != nil { 2606 ok := object.Key("Name") 2607 ok.String(*v.Name) 2608 } 2609 2610 return nil 2611} 2612 2613type awsRestjson1_serializeOpListAppliedSchemaArns struct { 2614} 2615 2616func (*awsRestjson1_serializeOpListAppliedSchemaArns) ID() string { 2617 return "OperationSerializer" 2618} 2619 2620func (m *awsRestjson1_serializeOpListAppliedSchemaArns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2621 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2622) { 2623 request, ok := in.Request.(*smithyhttp.Request) 2624 if !ok { 2625 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2626 } 2627 2628 input, ok := in.Parameters.(*ListAppliedSchemaArnsInput) 2629 _ = input 2630 if !ok { 2631 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2632 } 2633 2634 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/applied") 2635 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2636 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2637 request.Method = "POST" 2638 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2639 if err != nil { 2640 return out, metadata, &smithy.SerializationError{Err: err} 2641 } 2642 2643 restEncoder.SetHeader("Content-Type").String("application/json") 2644 2645 jsonEncoder := smithyjson.NewEncoder() 2646 if err := awsRestjson1_serializeOpDocumentListAppliedSchemaArnsInput(input, jsonEncoder.Value); err != nil { 2647 return out, metadata, &smithy.SerializationError{Err: err} 2648 } 2649 2650 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2651 return out, metadata, &smithy.SerializationError{Err: err} 2652 } 2653 2654 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2655 return out, metadata, &smithy.SerializationError{Err: err} 2656 } 2657 in.Request = request 2658 2659 return next.HandleSerialize(ctx, in) 2660} 2661func awsRestjson1_serializeOpHttpBindingsListAppliedSchemaArnsInput(v *ListAppliedSchemaArnsInput, encoder *httpbinding.Encoder) error { 2662 if v == nil { 2663 return fmt.Errorf("unsupported serialization of nil %T", v) 2664 } 2665 2666 return nil 2667} 2668 2669func awsRestjson1_serializeOpDocumentListAppliedSchemaArnsInput(v *ListAppliedSchemaArnsInput, value smithyjson.Value) error { 2670 object := value.Object() 2671 defer object.Close() 2672 2673 if v.DirectoryArn != nil { 2674 ok := object.Key("DirectoryArn") 2675 ok.String(*v.DirectoryArn) 2676 } 2677 2678 if v.MaxResults != nil { 2679 ok := object.Key("MaxResults") 2680 ok.Integer(*v.MaxResults) 2681 } 2682 2683 if v.NextToken != nil { 2684 ok := object.Key("NextToken") 2685 ok.String(*v.NextToken) 2686 } 2687 2688 if v.SchemaArn != nil { 2689 ok := object.Key("SchemaArn") 2690 ok.String(*v.SchemaArn) 2691 } 2692 2693 return nil 2694} 2695 2696type awsRestjson1_serializeOpListAttachedIndices struct { 2697} 2698 2699func (*awsRestjson1_serializeOpListAttachedIndices) ID() string { 2700 return "OperationSerializer" 2701} 2702 2703func (m *awsRestjson1_serializeOpListAttachedIndices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2704 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2705) { 2706 request, ok := in.Request.(*smithyhttp.Request) 2707 if !ok { 2708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2709 } 2710 2711 input, ok := in.Parameters.(*ListAttachedIndicesInput) 2712 _ = input 2713 if !ok { 2714 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2715 } 2716 2717 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/indices") 2718 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2719 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2720 request.Method = "POST" 2721 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2722 if err != nil { 2723 return out, metadata, &smithy.SerializationError{Err: err} 2724 } 2725 2726 if err := awsRestjson1_serializeOpHttpBindingsListAttachedIndicesInput(input, restEncoder); err != nil { 2727 return out, metadata, &smithy.SerializationError{Err: err} 2728 } 2729 2730 restEncoder.SetHeader("Content-Type").String("application/json") 2731 2732 jsonEncoder := smithyjson.NewEncoder() 2733 if err := awsRestjson1_serializeOpDocumentListAttachedIndicesInput(input, jsonEncoder.Value); err != nil { 2734 return out, metadata, &smithy.SerializationError{Err: err} 2735 } 2736 2737 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2738 return out, metadata, &smithy.SerializationError{Err: err} 2739 } 2740 2741 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2742 return out, metadata, &smithy.SerializationError{Err: err} 2743 } 2744 in.Request = request 2745 2746 return next.HandleSerialize(ctx, in) 2747} 2748func awsRestjson1_serializeOpHttpBindingsListAttachedIndicesInput(v *ListAttachedIndicesInput, encoder *httpbinding.Encoder) error { 2749 if v == nil { 2750 return fmt.Errorf("unsupported serialization of nil %T", v) 2751 } 2752 2753 if len(v.ConsistencyLevel) > 0 { 2754 locationName := "X-Amz-Consistency-Level" 2755 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 2756 } 2757 2758 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 2759 locationName := "X-Amz-Data-Partition" 2760 encoder.SetHeader(locationName).String(*v.DirectoryArn) 2761 } 2762 2763 return nil 2764} 2765 2766func awsRestjson1_serializeOpDocumentListAttachedIndicesInput(v *ListAttachedIndicesInput, value smithyjson.Value) error { 2767 object := value.Object() 2768 defer object.Close() 2769 2770 if v.MaxResults != nil { 2771 ok := object.Key("MaxResults") 2772 ok.Integer(*v.MaxResults) 2773 } 2774 2775 if v.NextToken != nil { 2776 ok := object.Key("NextToken") 2777 ok.String(*v.NextToken) 2778 } 2779 2780 if v.TargetReference != nil { 2781 ok := object.Key("TargetReference") 2782 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetReference, ok); err != nil { 2783 return err 2784 } 2785 } 2786 2787 return nil 2788} 2789 2790type awsRestjson1_serializeOpListDevelopmentSchemaArns struct { 2791} 2792 2793func (*awsRestjson1_serializeOpListDevelopmentSchemaArns) ID() string { 2794 return "OperationSerializer" 2795} 2796 2797func (m *awsRestjson1_serializeOpListDevelopmentSchemaArns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2798 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2799) { 2800 request, ok := in.Request.(*smithyhttp.Request) 2801 if !ok { 2802 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2803 } 2804 2805 input, ok := in.Parameters.(*ListDevelopmentSchemaArnsInput) 2806 _ = input 2807 if !ok { 2808 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2809 } 2810 2811 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/development") 2812 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2813 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2814 request.Method = "POST" 2815 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2816 if err != nil { 2817 return out, metadata, &smithy.SerializationError{Err: err} 2818 } 2819 2820 restEncoder.SetHeader("Content-Type").String("application/json") 2821 2822 jsonEncoder := smithyjson.NewEncoder() 2823 if err := awsRestjson1_serializeOpDocumentListDevelopmentSchemaArnsInput(input, jsonEncoder.Value); err != nil { 2824 return out, metadata, &smithy.SerializationError{Err: err} 2825 } 2826 2827 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2828 return out, metadata, &smithy.SerializationError{Err: err} 2829 } 2830 2831 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2832 return out, metadata, &smithy.SerializationError{Err: err} 2833 } 2834 in.Request = request 2835 2836 return next.HandleSerialize(ctx, in) 2837} 2838func awsRestjson1_serializeOpHttpBindingsListDevelopmentSchemaArnsInput(v *ListDevelopmentSchemaArnsInput, encoder *httpbinding.Encoder) error { 2839 if v == nil { 2840 return fmt.Errorf("unsupported serialization of nil %T", v) 2841 } 2842 2843 return nil 2844} 2845 2846func awsRestjson1_serializeOpDocumentListDevelopmentSchemaArnsInput(v *ListDevelopmentSchemaArnsInput, value smithyjson.Value) error { 2847 object := value.Object() 2848 defer object.Close() 2849 2850 if v.MaxResults != nil { 2851 ok := object.Key("MaxResults") 2852 ok.Integer(*v.MaxResults) 2853 } 2854 2855 if v.NextToken != nil { 2856 ok := object.Key("NextToken") 2857 ok.String(*v.NextToken) 2858 } 2859 2860 return nil 2861} 2862 2863type awsRestjson1_serializeOpListDirectories struct { 2864} 2865 2866func (*awsRestjson1_serializeOpListDirectories) ID() string { 2867 return "OperationSerializer" 2868} 2869 2870func (m *awsRestjson1_serializeOpListDirectories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2871 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2872) { 2873 request, ok := in.Request.(*smithyhttp.Request) 2874 if !ok { 2875 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2876 } 2877 2878 input, ok := in.Parameters.(*ListDirectoriesInput) 2879 _ = input 2880 if !ok { 2881 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2882 } 2883 2884 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/directory/list") 2885 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2886 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2887 request.Method = "POST" 2888 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2889 if err != nil { 2890 return out, metadata, &smithy.SerializationError{Err: err} 2891 } 2892 2893 restEncoder.SetHeader("Content-Type").String("application/json") 2894 2895 jsonEncoder := smithyjson.NewEncoder() 2896 if err := awsRestjson1_serializeOpDocumentListDirectoriesInput(input, jsonEncoder.Value); err != nil { 2897 return out, metadata, &smithy.SerializationError{Err: err} 2898 } 2899 2900 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2901 return out, metadata, &smithy.SerializationError{Err: err} 2902 } 2903 2904 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2905 return out, metadata, &smithy.SerializationError{Err: err} 2906 } 2907 in.Request = request 2908 2909 return next.HandleSerialize(ctx, in) 2910} 2911func awsRestjson1_serializeOpHttpBindingsListDirectoriesInput(v *ListDirectoriesInput, encoder *httpbinding.Encoder) error { 2912 if v == nil { 2913 return fmt.Errorf("unsupported serialization of nil %T", v) 2914 } 2915 2916 return nil 2917} 2918 2919func awsRestjson1_serializeOpDocumentListDirectoriesInput(v *ListDirectoriesInput, value smithyjson.Value) error { 2920 object := value.Object() 2921 defer object.Close() 2922 2923 if v.MaxResults != nil { 2924 ok := object.Key("MaxResults") 2925 ok.Integer(*v.MaxResults) 2926 } 2927 2928 if v.NextToken != nil { 2929 ok := object.Key("NextToken") 2930 ok.String(*v.NextToken) 2931 } 2932 2933 if len(v.State) > 0 { 2934 ok := object.Key("state") 2935 ok.String(string(v.State)) 2936 } 2937 2938 return nil 2939} 2940 2941type awsRestjson1_serializeOpListFacetAttributes struct { 2942} 2943 2944func (*awsRestjson1_serializeOpListFacetAttributes) ID() string { 2945 return "OperationSerializer" 2946} 2947 2948func (m *awsRestjson1_serializeOpListFacetAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2949 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2950) { 2951 request, ok := in.Request.(*smithyhttp.Request) 2952 if !ok { 2953 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2954 } 2955 2956 input, ok := in.Parameters.(*ListFacetAttributesInput) 2957 _ = input 2958 if !ok { 2959 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2960 } 2961 2962 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/facet/attributes") 2963 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2964 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2965 request.Method = "POST" 2966 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2967 if err != nil { 2968 return out, metadata, &smithy.SerializationError{Err: err} 2969 } 2970 2971 if err := awsRestjson1_serializeOpHttpBindingsListFacetAttributesInput(input, restEncoder); err != nil { 2972 return out, metadata, &smithy.SerializationError{Err: err} 2973 } 2974 2975 restEncoder.SetHeader("Content-Type").String("application/json") 2976 2977 jsonEncoder := smithyjson.NewEncoder() 2978 if err := awsRestjson1_serializeOpDocumentListFacetAttributesInput(input, jsonEncoder.Value); err != nil { 2979 return out, metadata, &smithy.SerializationError{Err: err} 2980 } 2981 2982 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2983 return out, metadata, &smithy.SerializationError{Err: err} 2984 } 2985 2986 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2987 return out, metadata, &smithy.SerializationError{Err: err} 2988 } 2989 in.Request = request 2990 2991 return next.HandleSerialize(ctx, in) 2992} 2993func awsRestjson1_serializeOpHttpBindingsListFacetAttributesInput(v *ListFacetAttributesInput, encoder *httpbinding.Encoder) error { 2994 if v == nil { 2995 return fmt.Errorf("unsupported serialization of nil %T", v) 2996 } 2997 2998 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 2999 locationName := "X-Amz-Data-Partition" 3000 encoder.SetHeader(locationName).String(*v.SchemaArn) 3001 } 3002 3003 return nil 3004} 3005 3006func awsRestjson1_serializeOpDocumentListFacetAttributesInput(v *ListFacetAttributesInput, value smithyjson.Value) error { 3007 object := value.Object() 3008 defer object.Close() 3009 3010 if v.MaxResults != nil { 3011 ok := object.Key("MaxResults") 3012 ok.Integer(*v.MaxResults) 3013 } 3014 3015 if v.Name != nil { 3016 ok := object.Key("Name") 3017 ok.String(*v.Name) 3018 } 3019 3020 if v.NextToken != nil { 3021 ok := object.Key("NextToken") 3022 ok.String(*v.NextToken) 3023 } 3024 3025 return nil 3026} 3027 3028type awsRestjson1_serializeOpListFacetNames struct { 3029} 3030 3031func (*awsRestjson1_serializeOpListFacetNames) ID() string { 3032 return "OperationSerializer" 3033} 3034 3035func (m *awsRestjson1_serializeOpListFacetNames) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3036 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3037) { 3038 request, ok := in.Request.(*smithyhttp.Request) 3039 if !ok { 3040 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3041 } 3042 3043 input, ok := in.Parameters.(*ListFacetNamesInput) 3044 _ = input 3045 if !ok { 3046 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3047 } 3048 3049 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/facet/list") 3050 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3051 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3052 request.Method = "POST" 3053 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3054 if err != nil { 3055 return out, metadata, &smithy.SerializationError{Err: err} 3056 } 3057 3058 if err := awsRestjson1_serializeOpHttpBindingsListFacetNamesInput(input, restEncoder); err != nil { 3059 return out, metadata, &smithy.SerializationError{Err: err} 3060 } 3061 3062 restEncoder.SetHeader("Content-Type").String("application/json") 3063 3064 jsonEncoder := smithyjson.NewEncoder() 3065 if err := awsRestjson1_serializeOpDocumentListFacetNamesInput(input, jsonEncoder.Value); err != nil { 3066 return out, metadata, &smithy.SerializationError{Err: err} 3067 } 3068 3069 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3070 return out, metadata, &smithy.SerializationError{Err: err} 3071 } 3072 3073 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3074 return out, metadata, &smithy.SerializationError{Err: err} 3075 } 3076 in.Request = request 3077 3078 return next.HandleSerialize(ctx, in) 3079} 3080func awsRestjson1_serializeOpHttpBindingsListFacetNamesInput(v *ListFacetNamesInput, encoder *httpbinding.Encoder) error { 3081 if v == nil { 3082 return fmt.Errorf("unsupported serialization of nil %T", v) 3083 } 3084 3085 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 3086 locationName := "X-Amz-Data-Partition" 3087 encoder.SetHeader(locationName).String(*v.SchemaArn) 3088 } 3089 3090 return nil 3091} 3092 3093func awsRestjson1_serializeOpDocumentListFacetNamesInput(v *ListFacetNamesInput, value smithyjson.Value) error { 3094 object := value.Object() 3095 defer object.Close() 3096 3097 if v.MaxResults != nil { 3098 ok := object.Key("MaxResults") 3099 ok.Integer(*v.MaxResults) 3100 } 3101 3102 if v.NextToken != nil { 3103 ok := object.Key("NextToken") 3104 ok.String(*v.NextToken) 3105 } 3106 3107 return nil 3108} 3109 3110type awsRestjson1_serializeOpListIncomingTypedLinks struct { 3111} 3112 3113func (*awsRestjson1_serializeOpListIncomingTypedLinks) ID() string { 3114 return "OperationSerializer" 3115} 3116 3117func (m *awsRestjson1_serializeOpListIncomingTypedLinks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3118 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3119) { 3120 request, ok := in.Request.(*smithyhttp.Request) 3121 if !ok { 3122 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3123 } 3124 3125 input, ok := in.Parameters.(*ListIncomingTypedLinksInput) 3126 _ = input 3127 if !ok { 3128 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3129 } 3130 3131 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/incoming") 3132 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3133 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3134 request.Method = "POST" 3135 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3136 if err != nil { 3137 return out, metadata, &smithy.SerializationError{Err: err} 3138 } 3139 3140 if err := awsRestjson1_serializeOpHttpBindingsListIncomingTypedLinksInput(input, restEncoder); err != nil { 3141 return out, metadata, &smithy.SerializationError{Err: err} 3142 } 3143 3144 restEncoder.SetHeader("Content-Type").String("application/json") 3145 3146 jsonEncoder := smithyjson.NewEncoder() 3147 if err := awsRestjson1_serializeOpDocumentListIncomingTypedLinksInput(input, jsonEncoder.Value); err != nil { 3148 return out, metadata, &smithy.SerializationError{Err: err} 3149 } 3150 3151 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3152 return out, metadata, &smithy.SerializationError{Err: err} 3153 } 3154 3155 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3156 return out, metadata, &smithy.SerializationError{Err: err} 3157 } 3158 in.Request = request 3159 3160 return next.HandleSerialize(ctx, in) 3161} 3162func awsRestjson1_serializeOpHttpBindingsListIncomingTypedLinksInput(v *ListIncomingTypedLinksInput, encoder *httpbinding.Encoder) error { 3163 if v == nil { 3164 return fmt.Errorf("unsupported serialization of nil %T", v) 3165 } 3166 3167 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3168 locationName := "X-Amz-Data-Partition" 3169 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3170 } 3171 3172 return nil 3173} 3174 3175func awsRestjson1_serializeOpDocumentListIncomingTypedLinksInput(v *ListIncomingTypedLinksInput, value smithyjson.Value) error { 3176 object := value.Object() 3177 defer object.Close() 3178 3179 if len(v.ConsistencyLevel) > 0 { 3180 ok := object.Key("ConsistencyLevel") 3181 ok.String(string(v.ConsistencyLevel)) 3182 } 3183 3184 if v.FilterAttributeRanges != nil { 3185 ok := object.Key("FilterAttributeRanges") 3186 if err := awsRestjson1_serializeDocumentTypedLinkAttributeRangeList(v.FilterAttributeRanges, ok); err != nil { 3187 return err 3188 } 3189 } 3190 3191 if v.FilterTypedLink != nil { 3192 ok := object.Key("FilterTypedLink") 3193 if err := awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v.FilterTypedLink, ok); err != nil { 3194 return err 3195 } 3196 } 3197 3198 if v.MaxResults != nil { 3199 ok := object.Key("MaxResults") 3200 ok.Integer(*v.MaxResults) 3201 } 3202 3203 if v.NextToken != nil { 3204 ok := object.Key("NextToken") 3205 ok.String(*v.NextToken) 3206 } 3207 3208 if v.ObjectReference != nil { 3209 ok := object.Key("ObjectReference") 3210 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 3211 return err 3212 } 3213 } 3214 3215 return nil 3216} 3217 3218type awsRestjson1_serializeOpListIndex struct { 3219} 3220 3221func (*awsRestjson1_serializeOpListIndex) ID() string { 3222 return "OperationSerializer" 3223} 3224 3225func (m *awsRestjson1_serializeOpListIndex) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3226 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3227) { 3228 request, ok := in.Request.(*smithyhttp.Request) 3229 if !ok { 3230 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3231 } 3232 3233 input, ok := in.Parameters.(*ListIndexInput) 3234 _ = input 3235 if !ok { 3236 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3237 } 3238 3239 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/index/targets") 3240 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3241 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3242 request.Method = "POST" 3243 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3244 if err != nil { 3245 return out, metadata, &smithy.SerializationError{Err: err} 3246 } 3247 3248 if err := awsRestjson1_serializeOpHttpBindingsListIndexInput(input, restEncoder); err != nil { 3249 return out, metadata, &smithy.SerializationError{Err: err} 3250 } 3251 3252 restEncoder.SetHeader("Content-Type").String("application/json") 3253 3254 jsonEncoder := smithyjson.NewEncoder() 3255 if err := awsRestjson1_serializeOpDocumentListIndexInput(input, jsonEncoder.Value); err != nil { 3256 return out, metadata, &smithy.SerializationError{Err: err} 3257 } 3258 3259 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3260 return out, metadata, &smithy.SerializationError{Err: err} 3261 } 3262 3263 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3264 return out, metadata, &smithy.SerializationError{Err: err} 3265 } 3266 in.Request = request 3267 3268 return next.HandleSerialize(ctx, in) 3269} 3270func awsRestjson1_serializeOpHttpBindingsListIndexInput(v *ListIndexInput, encoder *httpbinding.Encoder) error { 3271 if v == nil { 3272 return fmt.Errorf("unsupported serialization of nil %T", v) 3273 } 3274 3275 if len(v.ConsistencyLevel) > 0 { 3276 locationName := "X-Amz-Consistency-Level" 3277 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 3278 } 3279 3280 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3281 locationName := "X-Amz-Data-Partition" 3282 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3283 } 3284 3285 return nil 3286} 3287 3288func awsRestjson1_serializeOpDocumentListIndexInput(v *ListIndexInput, value smithyjson.Value) error { 3289 object := value.Object() 3290 defer object.Close() 3291 3292 if v.IndexReference != nil { 3293 ok := object.Key("IndexReference") 3294 if err := awsRestjson1_serializeDocumentObjectReference(v.IndexReference, ok); err != nil { 3295 return err 3296 } 3297 } 3298 3299 if v.MaxResults != nil { 3300 ok := object.Key("MaxResults") 3301 ok.Integer(*v.MaxResults) 3302 } 3303 3304 if v.NextToken != nil { 3305 ok := object.Key("NextToken") 3306 ok.String(*v.NextToken) 3307 } 3308 3309 if v.RangesOnIndexedValues != nil { 3310 ok := object.Key("RangesOnIndexedValues") 3311 if err := awsRestjson1_serializeDocumentObjectAttributeRangeList(v.RangesOnIndexedValues, ok); err != nil { 3312 return err 3313 } 3314 } 3315 3316 return nil 3317} 3318 3319type awsRestjson1_serializeOpListManagedSchemaArns struct { 3320} 3321 3322func (*awsRestjson1_serializeOpListManagedSchemaArns) ID() string { 3323 return "OperationSerializer" 3324} 3325 3326func (m *awsRestjson1_serializeOpListManagedSchemaArns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3327 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3328) { 3329 request, ok := in.Request.(*smithyhttp.Request) 3330 if !ok { 3331 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3332 } 3333 3334 input, ok := in.Parameters.(*ListManagedSchemaArnsInput) 3335 _ = input 3336 if !ok { 3337 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3338 } 3339 3340 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/managed") 3341 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3342 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3343 request.Method = "POST" 3344 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3345 if err != nil { 3346 return out, metadata, &smithy.SerializationError{Err: err} 3347 } 3348 3349 restEncoder.SetHeader("Content-Type").String("application/json") 3350 3351 jsonEncoder := smithyjson.NewEncoder() 3352 if err := awsRestjson1_serializeOpDocumentListManagedSchemaArnsInput(input, jsonEncoder.Value); err != nil { 3353 return out, metadata, &smithy.SerializationError{Err: err} 3354 } 3355 3356 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3357 return out, metadata, &smithy.SerializationError{Err: err} 3358 } 3359 3360 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3361 return out, metadata, &smithy.SerializationError{Err: err} 3362 } 3363 in.Request = request 3364 3365 return next.HandleSerialize(ctx, in) 3366} 3367func awsRestjson1_serializeOpHttpBindingsListManagedSchemaArnsInput(v *ListManagedSchemaArnsInput, encoder *httpbinding.Encoder) error { 3368 if v == nil { 3369 return fmt.Errorf("unsupported serialization of nil %T", v) 3370 } 3371 3372 return nil 3373} 3374 3375func awsRestjson1_serializeOpDocumentListManagedSchemaArnsInput(v *ListManagedSchemaArnsInput, value smithyjson.Value) error { 3376 object := value.Object() 3377 defer object.Close() 3378 3379 if v.MaxResults != nil { 3380 ok := object.Key("MaxResults") 3381 ok.Integer(*v.MaxResults) 3382 } 3383 3384 if v.NextToken != nil { 3385 ok := object.Key("NextToken") 3386 ok.String(*v.NextToken) 3387 } 3388 3389 if v.SchemaArn != nil { 3390 ok := object.Key("SchemaArn") 3391 ok.String(*v.SchemaArn) 3392 } 3393 3394 return nil 3395} 3396 3397type awsRestjson1_serializeOpListObjectAttributes struct { 3398} 3399 3400func (*awsRestjson1_serializeOpListObjectAttributes) ID() string { 3401 return "OperationSerializer" 3402} 3403 3404func (m *awsRestjson1_serializeOpListObjectAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3405 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3406) { 3407 request, ok := in.Request.(*smithyhttp.Request) 3408 if !ok { 3409 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3410 } 3411 3412 input, ok := in.Parameters.(*ListObjectAttributesInput) 3413 _ = input 3414 if !ok { 3415 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3416 } 3417 3418 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/attributes") 3419 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3420 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3421 request.Method = "POST" 3422 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3423 if err != nil { 3424 return out, metadata, &smithy.SerializationError{Err: err} 3425 } 3426 3427 if err := awsRestjson1_serializeOpHttpBindingsListObjectAttributesInput(input, restEncoder); err != nil { 3428 return out, metadata, &smithy.SerializationError{Err: err} 3429 } 3430 3431 restEncoder.SetHeader("Content-Type").String("application/json") 3432 3433 jsonEncoder := smithyjson.NewEncoder() 3434 if err := awsRestjson1_serializeOpDocumentListObjectAttributesInput(input, jsonEncoder.Value); err != nil { 3435 return out, metadata, &smithy.SerializationError{Err: err} 3436 } 3437 3438 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3439 return out, metadata, &smithy.SerializationError{Err: err} 3440 } 3441 3442 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3443 return out, metadata, &smithy.SerializationError{Err: err} 3444 } 3445 in.Request = request 3446 3447 return next.HandleSerialize(ctx, in) 3448} 3449func awsRestjson1_serializeOpHttpBindingsListObjectAttributesInput(v *ListObjectAttributesInput, encoder *httpbinding.Encoder) error { 3450 if v == nil { 3451 return fmt.Errorf("unsupported serialization of nil %T", v) 3452 } 3453 3454 if len(v.ConsistencyLevel) > 0 { 3455 locationName := "X-Amz-Consistency-Level" 3456 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 3457 } 3458 3459 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3460 locationName := "X-Amz-Data-Partition" 3461 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3462 } 3463 3464 return nil 3465} 3466 3467func awsRestjson1_serializeOpDocumentListObjectAttributesInput(v *ListObjectAttributesInput, value smithyjson.Value) error { 3468 object := value.Object() 3469 defer object.Close() 3470 3471 if v.FacetFilter != nil { 3472 ok := object.Key("FacetFilter") 3473 if err := awsRestjson1_serializeDocumentSchemaFacet(v.FacetFilter, ok); err != nil { 3474 return err 3475 } 3476 } 3477 3478 if v.MaxResults != nil { 3479 ok := object.Key("MaxResults") 3480 ok.Integer(*v.MaxResults) 3481 } 3482 3483 if v.NextToken != nil { 3484 ok := object.Key("NextToken") 3485 ok.String(*v.NextToken) 3486 } 3487 3488 if v.ObjectReference != nil { 3489 ok := object.Key("ObjectReference") 3490 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 3491 return err 3492 } 3493 } 3494 3495 return nil 3496} 3497 3498type awsRestjson1_serializeOpListObjectChildren struct { 3499} 3500 3501func (*awsRestjson1_serializeOpListObjectChildren) ID() string { 3502 return "OperationSerializer" 3503} 3504 3505func (m *awsRestjson1_serializeOpListObjectChildren) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3506 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3507) { 3508 request, ok := in.Request.(*smithyhttp.Request) 3509 if !ok { 3510 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3511 } 3512 3513 input, ok := in.Parameters.(*ListObjectChildrenInput) 3514 _ = input 3515 if !ok { 3516 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3517 } 3518 3519 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/children") 3520 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3521 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3522 request.Method = "POST" 3523 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3524 if err != nil { 3525 return out, metadata, &smithy.SerializationError{Err: err} 3526 } 3527 3528 if err := awsRestjson1_serializeOpHttpBindingsListObjectChildrenInput(input, restEncoder); err != nil { 3529 return out, metadata, &smithy.SerializationError{Err: err} 3530 } 3531 3532 restEncoder.SetHeader("Content-Type").String("application/json") 3533 3534 jsonEncoder := smithyjson.NewEncoder() 3535 if err := awsRestjson1_serializeOpDocumentListObjectChildrenInput(input, jsonEncoder.Value); err != nil { 3536 return out, metadata, &smithy.SerializationError{Err: err} 3537 } 3538 3539 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3540 return out, metadata, &smithy.SerializationError{Err: err} 3541 } 3542 3543 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3544 return out, metadata, &smithy.SerializationError{Err: err} 3545 } 3546 in.Request = request 3547 3548 return next.HandleSerialize(ctx, in) 3549} 3550func awsRestjson1_serializeOpHttpBindingsListObjectChildrenInput(v *ListObjectChildrenInput, encoder *httpbinding.Encoder) error { 3551 if v == nil { 3552 return fmt.Errorf("unsupported serialization of nil %T", v) 3553 } 3554 3555 if len(v.ConsistencyLevel) > 0 { 3556 locationName := "X-Amz-Consistency-Level" 3557 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 3558 } 3559 3560 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3561 locationName := "X-Amz-Data-Partition" 3562 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3563 } 3564 3565 return nil 3566} 3567 3568func awsRestjson1_serializeOpDocumentListObjectChildrenInput(v *ListObjectChildrenInput, value smithyjson.Value) error { 3569 object := value.Object() 3570 defer object.Close() 3571 3572 if v.MaxResults != nil { 3573 ok := object.Key("MaxResults") 3574 ok.Integer(*v.MaxResults) 3575 } 3576 3577 if v.NextToken != nil { 3578 ok := object.Key("NextToken") 3579 ok.String(*v.NextToken) 3580 } 3581 3582 if v.ObjectReference != nil { 3583 ok := object.Key("ObjectReference") 3584 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 3585 return err 3586 } 3587 } 3588 3589 return nil 3590} 3591 3592type awsRestjson1_serializeOpListObjectParentPaths struct { 3593} 3594 3595func (*awsRestjson1_serializeOpListObjectParentPaths) ID() string { 3596 return "OperationSerializer" 3597} 3598 3599func (m *awsRestjson1_serializeOpListObjectParentPaths) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3600 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3601) { 3602 request, ok := in.Request.(*smithyhttp.Request) 3603 if !ok { 3604 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3605 } 3606 3607 input, ok := in.Parameters.(*ListObjectParentPathsInput) 3608 _ = input 3609 if !ok { 3610 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3611 } 3612 3613 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/parentpaths") 3614 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3615 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3616 request.Method = "POST" 3617 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3618 if err != nil { 3619 return out, metadata, &smithy.SerializationError{Err: err} 3620 } 3621 3622 if err := awsRestjson1_serializeOpHttpBindingsListObjectParentPathsInput(input, restEncoder); err != nil { 3623 return out, metadata, &smithy.SerializationError{Err: err} 3624 } 3625 3626 restEncoder.SetHeader("Content-Type").String("application/json") 3627 3628 jsonEncoder := smithyjson.NewEncoder() 3629 if err := awsRestjson1_serializeOpDocumentListObjectParentPathsInput(input, jsonEncoder.Value); err != nil { 3630 return out, metadata, &smithy.SerializationError{Err: err} 3631 } 3632 3633 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3634 return out, metadata, &smithy.SerializationError{Err: err} 3635 } 3636 3637 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3638 return out, metadata, &smithy.SerializationError{Err: err} 3639 } 3640 in.Request = request 3641 3642 return next.HandleSerialize(ctx, in) 3643} 3644func awsRestjson1_serializeOpHttpBindingsListObjectParentPathsInput(v *ListObjectParentPathsInput, encoder *httpbinding.Encoder) error { 3645 if v == nil { 3646 return fmt.Errorf("unsupported serialization of nil %T", v) 3647 } 3648 3649 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3650 locationName := "X-Amz-Data-Partition" 3651 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3652 } 3653 3654 return nil 3655} 3656 3657func awsRestjson1_serializeOpDocumentListObjectParentPathsInput(v *ListObjectParentPathsInput, value smithyjson.Value) error { 3658 object := value.Object() 3659 defer object.Close() 3660 3661 if v.MaxResults != nil { 3662 ok := object.Key("MaxResults") 3663 ok.Integer(*v.MaxResults) 3664 } 3665 3666 if v.NextToken != nil { 3667 ok := object.Key("NextToken") 3668 ok.String(*v.NextToken) 3669 } 3670 3671 if v.ObjectReference != nil { 3672 ok := object.Key("ObjectReference") 3673 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 3674 return err 3675 } 3676 } 3677 3678 return nil 3679} 3680 3681type awsRestjson1_serializeOpListObjectParents struct { 3682} 3683 3684func (*awsRestjson1_serializeOpListObjectParents) ID() string { 3685 return "OperationSerializer" 3686} 3687 3688func (m *awsRestjson1_serializeOpListObjectParents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3689 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3690) { 3691 request, ok := in.Request.(*smithyhttp.Request) 3692 if !ok { 3693 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3694 } 3695 3696 input, ok := in.Parameters.(*ListObjectParentsInput) 3697 _ = input 3698 if !ok { 3699 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3700 } 3701 3702 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/parent") 3703 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3704 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3705 request.Method = "POST" 3706 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3707 if err != nil { 3708 return out, metadata, &smithy.SerializationError{Err: err} 3709 } 3710 3711 if err := awsRestjson1_serializeOpHttpBindingsListObjectParentsInput(input, restEncoder); err != nil { 3712 return out, metadata, &smithy.SerializationError{Err: err} 3713 } 3714 3715 restEncoder.SetHeader("Content-Type").String("application/json") 3716 3717 jsonEncoder := smithyjson.NewEncoder() 3718 if err := awsRestjson1_serializeOpDocumentListObjectParentsInput(input, jsonEncoder.Value); err != nil { 3719 return out, metadata, &smithy.SerializationError{Err: err} 3720 } 3721 3722 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3723 return out, metadata, &smithy.SerializationError{Err: err} 3724 } 3725 3726 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3727 return out, metadata, &smithy.SerializationError{Err: err} 3728 } 3729 in.Request = request 3730 3731 return next.HandleSerialize(ctx, in) 3732} 3733func awsRestjson1_serializeOpHttpBindingsListObjectParentsInput(v *ListObjectParentsInput, encoder *httpbinding.Encoder) error { 3734 if v == nil { 3735 return fmt.Errorf("unsupported serialization of nil %T", v) 3736 } 3737 3738 if len(v.ConsistencyLevel) > 0 { 3739 locationName := "X-Amz-Consistency-Level" 3740 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 3741 } 3742 3743 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3744 locationName := "X-Amz-Data-Partition" 3745 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3746 } 3747 3748 return nil 3749} 3750 3751func awsRestjson1_serializeOpDocumentListObjectParentsInput(v *ListObjectParentsInput, value smithyjson.Value) error { 3752 object := value.Object() 3753 defer object.Close() 3754 3755 if v.IncludeAllLinksToEachParent { 3756 ok := object.Key("IncludeAllLinksToEachParent") 3757 ok.Boolean(v.IncludeAllLinksToEachParent) 3758 } 3759 3760 if v.MaxResults != nil { 3761 ok := object.Key("MaxResults") 3762 ok.Integer(*v.MaxResults) 3763 } 3764 3765 if v.NextToken != nil { 3766 ok := object.Key("NextToken") 3767 ok.String(*v.NextToken) 3768 } 3769 3770 if v.ObjectReference != nil { 3771 ok := object.Key("ObjectReference") 3772 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 3773 return err 3774 } 3775 } 3776 3777 return nil 3778} 3779 3780type awsRestjson1_serializeOpListObjectPolicies struct { 3781} 3782 3783func (*awsRestjson1_serializeOpListObjectPolicies) ID() string { 3784 return "OperationSerializer" 3785} 3786 3787func (m *awsRestjson1_serializeOpListObjectPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3788 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3789) { 3790 request, ok := in.Request.(*smithyhttp.Request) 3791 if !ok { 3792 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3793 } 3794 3795 input, ok := in.Parameters.(*ListObjectPoliciesInput) 3796 _ = input 3797 if !ok { 3798 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3799 } 3800 3801 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/policy") 3802 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3803 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3804 request.Method = "POST" 3805 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3806 if err != nil { 3807 return out, metadata, &smithy.SerializationError{Err: err} 3808 } 3809 3810 if err := awsRestjson1_serializeOpHttpBindingsListObjectPoliciesInput(input, restEncoder); err != nil { 3811 return out, metadata, &smithy.SerializationError{Err: err} 3812 } 3813 3814 restEncoder.SetHeader("Content-Type").String("application/json") 3815 3816 jsonEncoder := smithyjson.NewEncoder() 3817 if err := awsRestjson1_serializeOpDocumentListObjectPoliciesInput(input, jsonEncoder.Value); err != nil { 3818 return out, metadata, &smithy.SerializationError{Err: err} 3819 } 3820 3821 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3822 return out, metadata, &smithy.SerializationError{Err: err} 3823 } 3824 3825 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3826 return out, metadata, &smithy.SerializationError{Err: err} 3827 } 3828 in.Request = request 3829 3830 return next.HandleSerialize(ctx, in) 3831} 3832func awsRestjson1_serializeOpHttpBindingsListObjectPoliciesInput(v *ListObjectPoliciesInput, encoder *httpbinding.Encoder) error { 3833 if v == nil { 3834 return fmt.Errorf("unsupported serialization of nil %T", v) 3835 } 3836 3837 if len(v.ConsistencyLevel) > 0 { 3838 locationName := "X-Amz-Consistency-Level" 3839 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 3840 } 3841 3842 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3843 locationName := "X-Amz-Data-Partition" 3844 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3845 } 3846 3847 return nil 3848} 3849 3850func awsRestjson1_serializeOpDocumentListObjectPoliciesInput(v *ListObjectPoliciesInput, value smithyjson.Value) error { 3851 object := value.Object() 3852 defer object.Close() 3853 3854 if v.MaxResults != nil { 3855 ok := object.Key("MaxResults") 3856 ok.Integer(*v.MaxResults) 3857 } 3858 3859 if v.NextToken != nil { 3860 ok := object.Key("NextToken") 3861 ok.String(*v.NextToken) 3862 } 3863 3864 if v.ObjectReference != nil { 3865 ok := object.Key("ObjectReference") 3866 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 3867 return err 3868 } 3869 } 3870 3871 return nil 3872} 3873 3874type awsRestjson1_serializeOpListOutgoingTypedLinks struct { 3875} 3876 3877func (*awsRestjson1_serializeOpListOutgoingTypedLinks) ID() string { 3878 return "OperationSerializer" 3879} 3880 3881func (m *awsRestjson1_serializeOpListOutgoingTypedLinks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3882 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3883) { 3884 request, ok := in.Request.(*smithyhttp.Request) 3885 if !ok { 3886 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3887 } 3888 3889 input, ok := in.Parameters.(*ListOutgoingTypedLinksInput) 3890 _ = input 3891 if !ok { 3892 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3893 } 3894 3895 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/outgoing") 3896 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 3897 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 3898 request.Method = "POST" 3899 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3900 if err != nil { 3901 return out, metadata, &smithy.SerializationError{Err: err} 3902 } 3903 3904 if err := awsRestjson1_serializeOpHttpBindingsListOutgoingTypedLinksInput(input, restEncoder); err != nil { 3905 return out, metadata, &smithy.SerializationError{Err: err} 3906 } 3907 3908 restEncoder.SetHeader("Content-Type").String("application/json") 3909 3910 jsonEncoder := smithyjson.NewEncoder() 3911 if err := awsRestjson1_serializeOpDocumentListOutgoingTypedLinksInput(input, jsonEncoder.Value); err != nil { 3912 return out, metadata, &smithy.SerializationError{Err: err} 3913 } 3914 3915 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3916 return out, metadata, &smithy.SerializationError{Err: err} 3917 } 3918 3919 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3920 return out, metadata, &smithy.SerializationError{Err: err} 3921 } 3922 in.Request = request 3923 3924 return next.HandleSerialize(ctx, in) 3925} 3926func awsRestjson1_serializeOpHttpBindingsListOutgoingTypedLinksInput(v *ListOutgoingTypedLinksInput, encoder *httpbinding.Encoder) error { 3927 if v == nil { 3928 return fmt.Errorf("unsupported serialization of nil %T", v) 3929 } 3930 3931 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 3932 locationName := "X-Amz-Data-Partition" 3933 encoder.SetHeader(locationName).String(*v.DirectoryArn) 3934 } 3935 3936 return nil 3937} 3938 3939func awsRestjson1_serializeOpDocumentListOutgoingTypedLinksInput(v *ListOutgoingTypedLinksInput, value smithyjson.Value) error { 3940 object := value.Object() 3941 defer object.Close() 3942 3943 if len(v.ConsistencyLevel) > 0 { 3944 ok := object.Key("ConsistencyLevel") 3945 ok.String(string(v.ConsistencyLevel)) 3946 } 3947 3948 if v.FilterAttributeRanges != nil { 3949 ok := object.Key("FilterAttributeRanges") 3950 if err := awsRestjson1_serializeDocumentTypedLinkAttributeRangeList(v.FilterAttributeRanges, ok); err != nil { 3951 return err 3952 } 3953 } 3954 3955 if v.FilterTypedLink != nil { 3956 ok := object.Key("FilterTypedLink") 3957 if err := awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v.FilterTypedLink, ok); err != nil { 3958 return err 3959 } 3960 } 3961 3962 if v.MaxResults != nil { 3963 ok := object.Key("MaxResults") 3964 ok.Integer(*v.MaxResults) 3965 } 3966 3967 if v.NextToken != nil { 3968 ok := object.Key("NextToken") 3969 ok.String(*v.NextToken) 3970 } 3971 3972 if v.ObjectReference != nil { 3973 ok := object.Key("ObjectReference") 3974 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 3975 return err 3976 } 3977 } 3978 3979 return nil 3980} 3981 3982type awsRestjson1_serializeOpListPolicyAttachments struct { 3983} 3984 3985func (*awsRestjson1_serializeOpListPolicyAttachments) ID() string { 3986 return "OperationSerializer" 3987} 3988 3989func (m *awsRestjson1_serializeOpListPolicyAttachments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3990 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3991) { 3992 request, ok := in.Request.(*smithyhttp.Request) 3993 if !ok { 3994 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3995 } 3996 3997 input, ok := in.Parameters.(*ListPolicyAttachmentsInput) 3998 _ = input 3999 if !ok { 4000 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4001 } 4002 4003 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/policy/attachment") 4004 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4005 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4006 request.Method = "POST" 4007 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4008 if err != nil { 4009 return out, metadata, &smithy.SerializationError{Err: err} 4010 } 4011 4012 if err := awsRestjson1_serializeOpHttpBindingsListPolicyAttachmentsInput(input, restEncoder); err != nil { 4013 return out, metadata, &smithy.SerializationError{Err: err} 4014 } 4015 4016 restEncoder.SetHeader("Content-Type").String("application/json") 4017 4018 jsonEncoder := smithyjson.NewEncoder() 4019 if err := awsRestjson1_serializeOpDocumentListPolicyAttachmentsInput(input, jsonEncoder.Value); err != nil { 4020 return out, metadata, &smithy.SerializationError{Err: err} 4021 } 4022 4023 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4024 return out, metadata, &smithy.SerializationError{Err: err} 4025 } 4026 4027 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4028 return out, metadata, &smithy.SerializationError{Err: err} 4029 } 4030 in.Request = request 4031 4032 return next.HandleSerialize(ctx, in) 4033} 4034func awsRestjson1_serializeOpHttpBindingsListPolicyAttachmentsInput(v *ListPolicyAttachmentsInput, encoder *httpbinding.Encoder) error { 4035 if v == nil { 4036 return fmt.Errorf("unsupported serialization of nil %T", v) 4037 } 4038 4039 if len(v.ConsistencyLevel) > 0 { 4040 locationName := "X-Amz-Consistency-Level" 4041 encoder.SetHeader(locationName).String(string(v.ConsistencyLevel)) 4042 } 4043 4044 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 4045 locationName := "X-Amz-Data-Partition" 4046 encoder.SetHeader(locationName).String(*v.DirectoryArn) 4047 } 4048 4049 return nil 4050} 4051 4052func awsRestjson1_serializeOpDocumentListPolicyAttachmentsInput(v *ListPolicyAttachmentsInput, value smithyjson.Value) error { 4053 object := value.Object() 4054 defer object.Close() 4055 4056 if v.MaxResults != nil { 4057 ok := object.Key("MaxResults") 4058 ok.Integer(*v.MaxResults) 4059 } 4060 4061 if v.NextToken != nil { 4062 ok := object.Key("NextToken") 4063 ok.String(*v.NextToken) 4064 } 4065 4066 if v.PolicyReference != nil { 4067 ok := object.Key("PolicyReference") 4068 if err := awsRestjson1_serializeDocumentObjectReference(v.PolicyReference, ok); err != nil { 4069 return err 4070 } 4071 } 4072 4073 return nil 4074} 4075 4076type awsRestjson1_serializeOpListPublishedSchemaArns struct { 4077} 4078 4079func (*awsRestjson1_serializeOpListPublishedSchemaArns) ID() string { 4080 return "OperationSerializer" 4081} 4082 4083func (m *awsRestjson1_serializeOpListPublishedSchemaArns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4084 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4085) { 4086 request, ok := in.Request.(*smithyhttp.Request) 4087 if !ok { 4088 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4089 } 4090 4091 input, ok := in.Parameters.(*ListPublishedSchemaArnsInput) 4092 _ = input 4093 if !ok { 4094 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4095 } 4096 4097 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/published") 4098 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4099 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4100 request.Method = "POST" 4101 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4102 if err != nil { 4103 return out, metadata, &smithy.SerializationError{Err: err} 4104 } 4105 4106 restEncoder.SetHeader("Content-Type").String("application/json") 4107 4108 jsonEncoder := smithyjson.NewEncoder() 4109 if err := awsRestjson1_serializeOpDocumentListPublishedSchemaArnsInput(input, jsonEncoder.Value); err != nil { 4110 return out, metadata, &smithy.SerializationError{Err: err} 4111 } 4112 4113 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4114 return out, metadata, &smithy.SerializationError{Err: err} 4115 } 4116 4117 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4118 return out, metadata, &smithy.SerializationError{Err: err} 4119 } 4120 in.Request = request 4121 4122 return next.HandleSerialize(ctx, in) 4123} 4124func awsRestjson1_serializeOpHttpBindingsListPublishedSchemaArnsInput(v *ListPublishedSchemaArnsInput, encoder *httpbinding.Encoder) error { 4125 if v == nil { 4126 return fmt.Errorf("unsupported serialization of nil %T", v) 4127 } 4128 4129 return nil 4130} 4131 4132func awsRestjson1_serializeOpDocumentListPublishedSchemaArnsInput(v *ListPublishedSchemaArnsInput, value smithyjson.Value) error { 4133 object := value.Object() 4134 defer object.Close() 4135 4136 if v.MaxResults != nil { 4137 ok := object.Key("MaxResults") 4138 ok.Integer(*v.MaxResults) 4139 } 4140 4141 if v.NextToken != nil { 4142 ok := object.Key("NextToken") 4143 ok.String(*v.NextToken) 4144 } 4145 4146 if v.SchemaArn != nil { 4147 ok := object.Key("SchemaArn") 4148 ok.String(*v.SchemaArn) 4149 } 4150 4151 return nil 4152} 4153 4154type awsRestjson1_serializeOpListTagsForResource struct { 4155} 4156 4157func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 4158 return "OperationSerializer" 4159} 4160 4161func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4162 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4163) { 4164 request, ok := in.Request.(*smithyhttp.Request) 4165 if !ok { 4166 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4167 } 4168 4169 input, ok := in.Parameters.(*ListTagsForResourceInput) 4170 _ = input 4171 if !ok { 4172 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4173 } 4174 4175 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/tags") 4176 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4177 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4178 request.Method = "POST" 4179 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4180 if err != nil { 4181 return out, metadata, &smithy.SerializationError{Err: err} 4182 } 4183 4184 restEncoder.SetHeader("Content-Type").String("application/json") 4185 4186 jsonEncoder := smithyjson.NewEncoder() 4187 if err := awsRestjson1_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil { 4188 return out, metadata, &smithy.SerializationError{Err: err} 4189 } 4190 4191 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4192 return out, metadata, &smithy.SerializationError{Err: err} 4193 } 4194 4195 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4196 return out, metadata, &smithy.SerializationError{Err: err} 4197 } 4198 in.Request = request 4199 4200 return next.HandleSerialize(ctx, in) 4201} 4202func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 4203 if v == nil { 4204 return fmt.Errorf("unsupported serialization of nil %T", v) 4205 } 4206 4207 return nil 4208} 4209 4210func awsRestjson1_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error { 4211 object := value.Object() 4212 defer object.Close() 4213 4214 if v.MaxResults != nil { 4215 ok := object.Key("MaxResults") 4216 ok.Integer(*v.MaxResults) 4217 } 4218 4219 if v.NextToken != nil { 4220 ok := object.Key("NextToken") 4221 ok.String(*v.NextToken) 4222 } 4223 4224 if v.ResourceArn != nil { 4225 ok := object.Key("ResourceArn") 4226 ok.String(*v.ResourceArn) 4227 } 4228 4229 return nil 4230} 4231 4232type awsRestjson1_serializeOpListTypedLinkFacetAttributes struct { 4233} 4234 4235func (*awsRestjson1_serializeOpListTypedLinkFacetAttributes) ID() string { 4236 return "OperationSerializer" 4237} 4238 4239func (m *awsRestjson1_serializeOpListTypedLinkFacetAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4240 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4241) { 4242 request, ok := in.Request.(*smithyhttp.Request) 4243 if !ok { 4244 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4245 } 4246 4247 input, ok := in.Parameters.(*ListTypedLinkFacetAttributesInput) 4248 _ = input 4249 if !ok { 4250 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4251 } 4252 4253 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/facet/attributes") 4254 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4255 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4256 request.Method = "POST" 4257 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4258 if err != nil { 4259 return out, metadata, &smithy.SerializationError{Err: err} 4260 } 4261 4262 if err := awsRestjson1_serializeOpHttpBindingsListTypedLinkFacetAttributesInput(input, restEncoder); err != nil { 4263 return out, metadata, &smithy.SerializationError{Err: err} 4264 } 4265 4266 restEncoder.SetHeader("Content-Type").String("application/json") 4267 4268 jsonEncoder := smithyjson.NewEncoder() 4269 if err := awsRestjson1_serializeOpDocumentListTypedLinkFacetAttributesInput(input, jsonEncoder.Value); err != nil { 4270 return out, metadata, &smithy.SerializationError{Err: err} 4271 } 4272 4273 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4274 return out, metadata, &smithy.SerializationError{Err: err} 4275 } 4276 4277 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4278 return out, metadata, &smithy.SerializationError{Err: err} 4279 } 4280 in.Request = request 4281 4282 return next.HandleSerialize(ctx, in) 4283} 4284func awsRestjson1_serializeOpHttpBindingsListTypedLinkFacetAttributesInput(v *ListTypedLinkFacetAttributesInput, encoder *httpbinding.Encoder) error { 4285 if v == nil { 4286 return fmt.Errorf("unsupported serialization of nil %T", v) 4287 } 4288 4289 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 4290 locationName := "X-Amz-Data-Partition" 4291 encoder.SetHeader(locationName).String(*v.SchemaArn) 4292 } 4293 4294 return nil 4295} 4296 4297func awsRestjson1_serializeOpDocumentListTypedLinkFacetAttributesInput(v *ListTypedLinkFacetAttributesInput, value smithyjson.Value) error { 4298 object := value.Object() 4299 defer object.Close() 4300 4301 if v.MaxResults != nil { 4302 ok := object.Key("MaxResults") 4303 ok.Integer(*v.MaxResults) 4304 } 4305 4306 if v.Name != nil { 4307 ok := object.Key("Name") 4308 ok.String(*v.Name) 4309 } 4310 4311 if v.NextToken != nil { 4312 ok := object.Key("NextToken") 4313 ok.String(*v.NextToken) 4314 } 4315 4316 return nil 4317} 4318 4319type awsRestjson1_serializeOpListTypedLinkFacetNames struct { 4320} 4321 4322func (*awsRestjson1_serializeOpListTypedLinkFacetNames) ID() string { 4323 return "OperationSerializer" 4324} 4325 4326func (m *awsRestjson1_serializeOpListTypedLinkFacetNames) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4327 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4328) { 4329 request, ok := in.Request.(*smithyhttp.Request) 4330 if !ok { 4331 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4332 } 4333 4334 input, ok := in.Parameters.(*ListTypedLinkFacetNamesInput) 4335 _ = input 4336 if !ok { 4337 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4338 } 4339 4340 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/facet/list") 4341 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4342 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4343 request.Method = "POST" 4344 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4345 if err != nil { 4346 return out, metadata, &smithy.SerializationError{Err: err} 4347 } 4348 4349 if err := awsRestjson1_serializeOpHttpBindingsListTypedLinkFacetNamesInput(input, restEncoder); err != nil { 4350 return out, metadata, &smithy.SerializationError{Err: err} 4351 } 4352 4353 restEncoder.SetHeader("Content-Type").String("application/json") 4354 4355 jsonEncoder := smithyjson.NewEncoder() 4356 if err := awsRestjson1_serializeOpDocumentListTypedLinkFacetNamesInput(input, jsonEncoder.Value); err != nil { 4357 return out, metadata, &smithy.SerializationError{Err: err} 4358 } 4359 4360 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4361 return out, metadata, &smithy.SerializationError{Err: err} 4362 } 4363 4364 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4365 return out, metadata, &smithy.SerializationError{Err: err} 4366 } 4367 in.Request = request 4368 4369 return next.HandleSerialize(ctx, in) 4370} 4371func awsRestjson1_serializeOpHttpBindingsListTypedLinkFacetNamesInput(v *ListTypedLinkFacetNamesInput, encoder *httpbinding.Encoder) error { 4372 if v == nil { 4373 return fmt.Errorf("unsupported serialization of nil %T", v) 4374 } 4375 4376 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 4377 locationName := "X-Amz-Data-Partition" 4378 encoder.SetHeader(locationName).String(*v.SchemaArn) 4379 } 4380 4381 return nil 4382} 4383 4384func awsRestjson1_serializeOpDocumentListTypedLinkFacetNamesInput(v *ListTypedLinkFacetNamesInput, value smithyjson.Value) error { 4385 object := value.Object() 4386 defer object.Close() 4387 4388 if v.MaxResults != nil { 4389 ok := object.Key("MaxResults") 4390 ok.Integer(*v.MaxResults) 4391 } 4392 4393 if v.NextToken != nil { 4394 ok := object.Key("NextToken") 4395 ok.String(*v.NextToken) 4396 } 4397 4398 return nil 4399} 4400 4401type awsRestjson1_serializeOpLookupPolicy struct { 4402} 4403 4404func (*awsRestjson1_serializeOpLookupPolicy) ID() string { 4405 return "OperationSerializer" 4406} 4407 4408func (m *awsRestjson1_serializeOpLookupPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4409 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4410) { 4411 request, ok := in.Request.(*smithyhttp.Request) 4412 if !ok { 4413 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4414 } 4415 4416 input, ok := in.Parameters.(*LookupPolicyInput) 4417 _ = input 4418 if !ok { 4419 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4420 } 4421 4422 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/policy/lookup") 4423 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4424 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4425 request.Method = "POST" 4426 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4427 if err != nil { 4428 return out, metadata, &smithy.SerializationError{Err: err} 4429 } 4430 4431 if err := awsRestjson1_serializeOpHttpBindingsLookupPolicyInput(input, restEncoder); err != nil { 4432 return out, metadata, &smithy.SerializationError{Err: err} 4433 } 4434 4435 restEncoder.SetHeader("Content-Type").String("application/json") 4436 4437 jsonEncoder := smithyjson.NewEncoder() 4438 if err := awsRestjson1_serializeOpDocumentLookupPolicyInput(input, jsonEncoder.Value); err != nil { 4439 return out, metadata, &smithy.SerializationError{Err: err} 4440 } 4441 4442 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4443 return out, metadata, &smithy.SerializationError{Err: err} 4444 } 4445 4446 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4447 return out, metadata, &smithy.SerializationError{Err: err} 4448 } 4449 in.Request = request 4450 4451 return next.HandleSerialize(ctx, in) 4452} 4453func awsRestjson1_serializeOpHttpBindingsLookupPolicyInput(v *LookupPolicyInput, encoder *httpbinding.Encoder) error { 4454 if v == nil { 4455 return fmt.Errorf("unsupported serialization of nil %T", v) 4456 } 4457 4458 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 4459 locationName := "X-Amz-Data-Partition" 4460 encoder.SetHeader(locationName).String(*v.DirectoryArn) 4461 } 4462 4463 return nil 4464} 4465 4466func awsRestjson1_serializeOpDocumentLookupPolicyInput(v *LookupPolicyInput, value smithyjson.Value) error { 4467 object := value.Object() 4468 defer object.Close() 4469 4470 if v.MaxResults != nil { 4471 ok := object.Key("MaxResults") 4472 ok.Integer(*v.MaxResults) 4473 } 4474 4475 if v.NextToken != nil { 4476 ok := object.Key("NextToken") 4477 ok.String(*v.NextToken) 4478 } 4479 4480 if v.ObjectReference != nil { 4481 ok := object.Key("ObjectReference") 4482 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 4483 return err 4484 } 4485 } 4486 4487 return nil 4488} 4489 4490type awsRestjson1_serializeOpPublishSchema struct { 4491} 4492 4493func (*awsRestjson1_serializeOpPublishSchema) ID() string { 4494 return "OperationSerializer" 4495} 4496 4497func (m *awsRestjson1_serializeOpPublishSchema) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4498 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4499) { 4500 request, ok := in.Request.(*smithyhttp.Request) 4501 if !ok { 4502 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4503 } 4504 4505 input, ok := in.Parameters.(*PublishSchemaInput) 4506 _ = input 4507 if !ok { 4508 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4509 } 4510 4511 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/publish") 4512 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4513 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4514 request.Method = "PUT" 4515 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4516 if err != nil { 4517 return out, metadata, &smithy.SerializationError{Err: err} 4518 } 4519 4520 if err := awsRestjson1_serializeOpHttpBindingsPublishSchemaInput(input, restEncoder); err != nil { 4521 return out, metadata, &smithy.SerializationError{Err: err} 4522 } 4523 4524 restEncoder.SetHeader("Content-Type").String("application/json") 4525 4526 jsonEncoder := smithyjson.NewEncoder() 4527 if err := awsRestjson1_serializeOpDocumentPublishSchemaInput(input, jsonEncoder.Value); err != nil { 4528 return out, metadata, &smithy.SerializationError{Err: err} 4529 } 4530 4531 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4532 return out, metadata, &smithy.SerializationError{Err: err} 4533 } 4534 4535 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4536 return out, metadata, &smithy.SerializationError{Err: err} 4537 } 4538 in.Request = request 4539 4540 return next.HandleSerialize(ctx, in) 4541} 4542func awsRestjson1_serializeOpHttpBindingsPublishSchemaInput(v *PublishSchemaInput, encoder *httpbinding.Encoder) error { 4543 if v == nil { 4544 return fmt.Errorf("unsupported serialization of nil %T", v) 4545 } 4546 4547 if v.DevelopmentSchemaArn != nil && len(*v.DevelopmentSchemaArn) > 0 { 4548 locationName := "X-Amz-Data-Partition" 4549 encoder.SetHeader(locationName).String(*v.DevelopmentSchemaArn) 4550 } 4551 4552 return nil 4553} 4554 4555func awsRestjson1_serializeOpDocumentPublishSchemaInput(v *PublishSchemaInput, value smithyjson.Value) error { 4556 object := value.Object() 4557 defer object.Close() 4558 4559 if v.MinorVersion != nil { 4560 ok := object.Key("MinorVersion") 4561 ok.String(*v.MinorVersion) 4562 } 4563 4564 if v.Name != nil { 4565 ok := object.Key("Name") 4566 ok.String(*v.Name) 4567 } 4568 4569 if v.Version != nil { 4570 ok := object.Key("Version") 4571 ok.String(*v.Version) 4572 } 4573 4574 return nil 4575} 4576 4577type awsRestjson1_serializeOpPutSchemaFromJson struct { 4578} 4579 4580func (*awsRestjson1_serializeOpPutSchemaFromJson) ID() string { 4581 return "OperationSerializer" 4582} 4583 4584func (m *awsRestjson1_serializeOpPutSchemaFromJson) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4585 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4586) { 4587 request, ok := in.Request.(*smithyhttp.Request) 4588 if !ok { 4589 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4590 } 4591 4592 input, ok := in.Parameters.(*PutSchemaFromJsonInput) 4593 _ = input 4594 if !ok { 4595 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4596 } 4597 4598 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/json") 4599 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4600 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4601 request.Method = "PUT" 4602 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4603 if err != nil { 4604 return out, metadata, &smithy.SerializationError{Err: err} 4605 } 4606 4607 if err := awsRestjson1_serializeOpHttpBindingsPutSchemaFromJsonInput(input, restEncoder); err != nil { 4608 return out, metadata, &smithy.SerializationError{Err: err} 4609 } 4610 4611 restEncoder.SetHeader("Content-Type").String("application/json") 4612 4613 jsonEncoder := smithyjson.NewEncoder() 4614 if err := awsRestjson1_serializeOpDocumentPutSchemaFromJsonInput(input, jsonEncoder.Value); err != nil { 4615 return out, metadata, &smithy.SerializationError{Err: err} 4616 } 4617 4618 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4619 return out, metadata, &smithy.SerializationError{Err: err} 4620 } 4621 4622 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4623 return out, metadata, &smithy.SerializationError{Err: err} 4624 } 4625 in.Request = request 4626 4627 return next.HandleSerialize(ctx, in) 4628} 4629func awsRestjson1_serializeOpHttpBindingsPutSchemaFromJsonInput(v *PutSchemaFromJsonInput, encoder *httpbinding.Encoder) error { 4630 if v == nil { 4631 return fmt.Errorf("unsupported serialization of nil %T", v) 4632 } 4633 4634 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 4635 locationName := "X-Amz-Data-Partition" 4636 encoder.SetHeader(locationName).String(*v.SchemaArn) 4637 } 4638 4639 return nil 4640} 4641 4642func awsRestjson1_serializeOpDocumentPutSchemaFromJsonInput(v *PutSchemaFromJsonInput, value smithyjson.Value) error { 4643 object := value.Object() 4644 defer object.Close() 4645 4646 if v.Document != nil { 4647 ok := object.Key("Document") 4648 ok.String(*v.Document) 4649 } 4650 4651 return nil 4652} 4653 4654type awsRestjson1_serializeOpRemoveFacetFromObject struct { 4655} 4656 4657func (*awsRestjson1_serializeOpRemoveFacetFromObject) ID() string { 4658 return "OperationSerializer" 4659} 4660 4661func (m *awsRestjson1_serializeOpRemoveFacetFromObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4662 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4663) { 4664 request, ok := in.Request.(*smithyhttp.Request) 4665 if !ok { 4666 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4667 } 4668 4669 input, ok := in.Parameters.(*RemoveFacetFromObjectInput) 4670 _ = input 4671 if !ok { 4672 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4673 } 4674 4675 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/facets/delete") 4676 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4677 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4678 request.Method = "PUT" 4679 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4680 if err != nil { 4681 return out, metadata, &smithy.SerializationError{Err: err} 4682 } 4683 4684 if err := awsRestjson1_serializeOpHttpBindingsRemoveFacetFromObjectInput(input, restEncoder); err != nil { 4685 return out, metadata, &smithy.SerializationError{Err: err} 4686 } 4687 4688 restEncoder.SetHeader("Content-Type").String("application/json") 4689 4690 jsonEncoder := smithyjson.NewEncoder() 4691 if err := awsRestjson1_serializeOpDocumentRemoveFacetFromObjectInput(input, jsonEncoder.Value); err != nil { 4692 return out, metadata, &smithy.SerializationError{Err: err} 4693 } 4694 4695 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4696 return out, metadata, &smithy.SerializationError{Err: err} 4697 } 4698 4699 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4700 return out, metadata, &smithy.SerializationError{Err: err} 4701 } 4702 in.Request = request 4703 4704 return next.HandleSerialize(ctx, in) 4705} 4706func awsRestjson1_serializeOpHttpBindingsRemoveFacetFromObjectInput(v *RemoveFacetFromObjectInput, encoder *httpbinding.Encoder) error { 4707 if v == nil { 4708 return fmt.Errorf("unsupported serialization of nil %T", v) 4709 } 4710 4711 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 4712 locationName := "X-Amz-Data-Partition" 4713 encoder.SetHeader(locationName).String(*v.DirectoryArn) 4714 } 4715 4716 return nil 4717} 4718 4719func awsRestjson1_serializeOpDocumentRemoveFacetFromObjectInput(v *RemoveFacetFromObjectInput, value smithyjson.Value) error { 4720 object := value.Object() 4721 defer object.Close() 4722 4723 if v.ObjectReference != nil { 4724 ok := object.Key("ObjectReference") 4725 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 4726 return err 4727 } 4728 } 4729 4730 if v.SchemaFacet != nil { 4731 ok := object.Key("SchemaFacet") 4732 if err := awsRestjson1_serializeDocumentSchemaFacet(v.SchemaFacet, ok); err != nil { 4733 return err 4734 } 4735 } 4736 4737 return nil 4738} 4739 4740type awsRestjson1_serializeOpTagResource struct { 4741} 4742 4743func (*awsRestjson1_serializeOpTagResource) ID() string { 4744 return "OperationSerializer" 4745} 4746 4747func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4748 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4749) { 4750 request, ok := in.Request.(*smithyhttp.Request) 4751 if !ok { 4752 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4753 } 4754 4755 input, ok := in.Parameters.(*TagResourceInput) 4756 _ = input 4757 if !ok { 4758 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4759 } 4760 4761 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/tags/add") 4762 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4763 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4764 request.Method = "PUT" 4765 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4766 if err != nil { 4767 return out, metadata, &smithy.SerializationError{Err: err} 4768 } 4769 4770 restEncoder.SetHeader("Content-Type").String("application/json") 4771 4772 jsonEncoder := smithyjson.NewEncoder() 4773 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 4774 return out, metadata, &smithy.SerializationError{Err: err} 4775 } 4776 4777 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4778 return out, metadata, &smithy.SerializationError{Err: err} 4779 } 4780 4781 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4782 return out, metadata, &smithy.SerializationError{Err: err} 4783 } 4784 in.Request = request 4785 4786 return next.HandleSerialize(ctx, in) 4787} 4788func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 4789 if v == nil { 4790 return fmt.Errorf("unsupported serialization of nil %T", v) 4791 } 4792 4793 return nil 4794} 4795 4796func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 4797 object := value.Object() 4798 defer object.Close() 4799 4800 if v.ResourceArn != nil { 4801 ok := object.Key("ResourceArn") 4802 ok.String(*v.ResourceArn) 4803 } 4804 4805 if v.Tags != nil { 4806 ok := object.Key("Tags") 4807 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 4808 return err 4809 } 4810 } 4811 4812 return nil 4813} 4814 4815type awsRestjson1_serializeOpUntagResource struct { 4816} 4817 4818func (*awsRestjson1_serializeOpUntagResource) ID() string { 4819 return "OperationSerializer" 4820} 4821 4822func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4823 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4824) { 4825 request, ok := in.Request.(*smithyhttp.Request) 4826 if !ok { 4827 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4828 } 4829 4830 input, ok := in.Parameters.(*UntagResourceInput) 4831 _ = input 4832 if !ok { 4833 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4834 } 4835 4836 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/tags/remove") 4837 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4838 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4839 request.Method = "PUT" 4840 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4841 if err != nil { 4842 return out, metadata, &smithy.SerializationError{Err: err} 4843 } 4844 4845 restEncoder.SetHeader("Content-Type").String("application/json") 4846 4847 jsonEncoder := smithyjson.NewEncoder() 4848 if err := awsRestjson1_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil { 4849 return out, metadata, &smithy.SerializationError{Err: err} 4850 } 4851 4852 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); 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_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 4864 if v == nil { 4865 return fmt.Errorf("unsupported serialization of nil %T", v) 4866 } 4867 4868 return nil 4869} 4870 4871func awsRestjson1_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error { 4872 object := value.Object() 4873 defer object.Close() 4874 4875 if v.ResourceArn != nil { 4876 ok := object.Key("ResourceArn") 4877 ok.String(*v.ResourceArn) 4878 } 4879 4880 if v.TagKeys != nil { 4881 ok := object.Key("TagKeys") 4882 if err := awsRestjson1_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil { 4883 return err 4884 } 4885 } 4886 4887 return nil 4888} 4889 4890type awsRestjson1_serializeOpUpdateFacet struct { 4891} 4892 4893func (*awsRestjson1_serializeOpUpdateFacet) ID() string { 4894 return "OperationSerializer" 4895} 4896 4897func (m *awsRestjson1_serializeOpUpdateFacet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4898 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4899) { 4900 request, ok := in.Request.(*smithyhttp.Request) 4901 if !ok { 4902 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4903 } 4904 4905 input, ok := in.Parameters.(*UpdateFacetInput) 4906 _ = input 4907 if !ok { 4908 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4909 } 4910 4911 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/facet") 4912 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 4913 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 4914 request.Method = "PUT" 4915 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4916 if err != nil { 4917 return out, metadata, &smithy.SerializationError{Err: err} 4918 } 4919 4920 if err := awsRestjson1_serializeOpHttpBindingsUpdateFacetInput(input, restEncoder); err != nil { 4921 return out, metadata, &smithy.SerializationError{Err: err} 4922 } 4923 4924 restEncoder.SetHeader("Content-Type").String("application/json") 4925 4926 jsonEncoder := smithyjson.NewEncoder() 4927 if err := awsRestjson1_serializeOpDocumentUpdateFacetInput(input, jsonEncoder.Value); err != nil { 4928 return out, metadata, &smithy.SerializationError{Err: err} 4929 } 4930 4931 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4932 return out, metadata, &smithy.SerializationError{Err: err} 4933 } 4934 4935 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4936 return out, metadata, &smithy.SerializationError{Err: err} 4937 } 4938 in.Request = request 4939 4940 return next.HandleSerialize(ctx, in) 4941} 4942func awsRestjson1_serializeOpHttpBindingsUpdateFacetInput(v *UpdateFacetInput, encoder *httpbinding.Encoder) error { 4943 if v == nil { 4944 return fmt.Errorf("unsupported serialization of nil %T", v) 4945 } 4946 4947 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 4948 locationName := "X-Amz-Data-Partition" 4949 encoder.SetHeader(locationName).String(*v.SchemaArn) 4950 } 4951 4952 return nil 4953} 4954 4955func awsRestjson1_serializeOpDocumentUpdateFacetInput(v *UpdateFacetInput, value smithyjson.Value) error { 4956 object := value.Object() 4957 defer object.Close() 4958 4959 if v.AttributeUpdates != nil { 4960 ok := object.Key("AttributeUpdates") 4961 if err := awsRestjson1_serializeDocumentFacetAttributeUpdateList(v.AttributeUpdates, ok); err != nil { 4962 return err 4963 } 4964 } 4965 4966 if v.Name != nil { 4967 ok := object.Key("Name") 4968 ok.String(*v.Name) 4969 } 4970 4971 if len(v.ObjectType) > 0 { 4972 ok := object.Key("ObjectType") 4973 ok.String(string(v.ObjectType)) 4974 } 4975 4976 return nil 4977} 4978 4979type awsRestjson1_serializeOpUpdateLinkAttributes struct { 4980} 4981 4982func (*awsRestjson1_serializeOpUpdateLinkAttributes) ID() string { 4983 return "OperationSerializer" 4984} 4985 4986func (m *awsRestjson1_serializeOpUpdateLinkAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4987 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4988) { 4989 request, ok := in.Request.(*smithyhttp.Request) 4990 if !ok { 4991 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4992 } 4993 4994 input, ok := in.Parameters.(*UpdateLinkAttributesInput) 4995 _ = input 4996 if !ok { 4997 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4998 } 4999 5000 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/attributes/update") 5001 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5002 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5003 request.Method = "POST" 5004 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5005 if err != nil { 5006 return out, metadata, &smithy.SerializationError{Err: err} 5007 } 5008 5009 if err := awsRestjson1_serializeOpHttpBindingsUpdateLinkAttributesInput(input, restEncoder); err != nil { 5010 return out, metadata, &smithy.SerializationError{Err: err} 5011 } 5012 5013 restEncoder.SetHeader("Content-Type").String("application/json") 5014 5015 jsonEncoder := smithyjson.NewEncoder() 5016 if err := awsRestjson1_serializeOpDocumentUpdateLinkAttributesInput(input, jsonEncoder.Value); err != nil { 5017 return out, metadata, &smithy.SerializationError{Err: err} 5018 } 5019 5020 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5021 return out, metadata, &smithy.SerializationError{Err: err} 5022 } 5023 5024 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5025 return out, metadata, &smithy.SerializationError{Err: err} 5026 } 5027 in.Request = request 5028 5029 return next.HandleSerialize(ctx, in) 5030} 5031func awsRestjson1_serializeOpHttpBindingsUpdateLinkAttributesInput(v *UpdateLinkAttributesInput, encoder *httpbinding.Encoder) error { 5032 if v == nil { 5033 return fmt.Errorf("unsupported serialization of nil %T", v) 5034 } 5035 5036 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 5037 locationName := "X-Amz-Data-Partition" 5038 encoder.SetHeader(locationName).String(*v.DirectoryArn) 5039 } 5040 5041 return nil 5042} 5043 5044func awsRestjson1_serializeOpDocumentUpdateLinkAttributesInput(v *UpdateLinkAttributesInput, value smithyjson.Value) error { 5045 object := value.Object() 5046 defer object.Close() 5047 5048 if v.AttributeUpdates != nil { 5049 ok := object.Key("AttributeUpdates") 5050 if err := awsRestjson1_serializeDocumentLinkAttributeUpdateList(v.AttributeUpdates, ok); err != nil { 5051 return err 5052 } 5053 } 5054 5055 if v.TypedLinkSpecifier != nil { 5056 ok := object.Key("TypedLinkSpecifier") 5057 if err := awsRestjson1_serializeDocumentTypedLinkSpecifier(v.TypedLinkSpecifier, ok); err != nil { 5058 return err 5059 } 5060 } 5061 5062 return nil 5063} 5064 5065type awsRestjson1_serializeOpUpdateObjectAttributes struct { 5066} 5067 5068func (*awsRestjson1_serializeOpUpdateObjectAttributes) ID() string { 5069 return "OperationSerializer" 5070} 5071 5072func (m *awsRestjson1_serializeOpUpdateObjectAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5073 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5074) { 5075 request, ok := in.Request.(*smithyhttp.Request) 5076 if !ok { 5077 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5078 } 5079 5080 input, ok := in.Parameters.(*UpdateObjectAttributesInput) 5081 _ = input 5082 if !ok { 5083 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5084 } 5085 5086 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/object/update") 5087 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5088 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5089 request.Method = "PUT" 5090 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5091 if err != nil { 5092 return out, metadata, &smithy.SerializationError{Err: err} 5093 } 5094 5095 if err := awsRestjson1_serializeOpHttpBindingsUpdateObjectAttributesInput(input, restEncoder); err != nil { 5096 return out, metadata, &smithy.SerializationError{Err: err} 5097 } 5098 5099 restEncoder.SetHeader("Content-Type").String("application/json") 5100 5101 jsonEncoder := smithyjson.NewEncoder() 5102 if err := awsRestjson1_serializeOpDocumentUpdateObjectAttributesInput(input, jsonEncoder.Value); err != nil { 5103 return out, metadata, &smithy.SerializationError{Err: err} 5104 } 5105 5106 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5107 return out, metadata, &smithy.SerializationError{Err: err} 5108 } 5109 5110 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5111 return out, metadata, &smithy.SerializationError{Err: err} 5112 } 5113 in.Request = request 5114 5115 return next.HandleSerialize(ctx, in) 5116} 5117func awsRestjson1_serializeOpHttpBindingsUpdateObjectAttributesInput(v *UpdateObjectAttributesInput, encoder *httpbinding.Encoder) error { 5118 if v == nil { 5119 return fmt.Errorf("unsupported serialization of nil %T", v) 5120 } 5121 5122 if v.DirectoryArn != nil && len(*v.DirectoryArn) > 0 { 5123 locationName := "X-Amz-Data-Partition" 5124 encoder.SetHeader(locationName).String(*v.DirectoryArn) 5125 } 5126 5127 return nil 5128} 5129 5130func awsRestjson1_serializeOpDocumentUpdateObjectAttributesInput(v *UpdateObjectAttributesInput, value smithyjson.Value) error { 5131 object := value.Object() 5132 defer object.Close() 5133 5134 if v.AttributeUpdates != nil { 5135 ok := object.Key("AttributeUpdates") 5136 if err := awsRestjson1_serializeDocumentObjectAttributeUpdateList(v.AttributeUpdates, ok); err != nil { 5137 return err 5138 } 5139 } 5140 5141 if v.ObjectReference != nil { 5142 ok := object.Key("ObjectReference") 5143 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 5144 return err 5145 } 5146 } 5147 5148 return nil 5149} 5150 5151type awsRestjson1_serializeOpUpdateSchema struct { 5152} 5153 5154func (*awsRestjson1_serializeOpUpdateSchema) ID() string { 5155 return "OperationSerializer" 5156} 5157 5158func (m *awsRestjson1_serializeOpUpdateSchema) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5159 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5160) { 5161 request, ok := in.Request.(*smithyhttp.Request) 5162 if !ok { 5163 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5164 } 5165 5166 input, ok := in.Parameters.(*UpdateSchemaInput) 5167 _ = input 5168 if !ok { 5169 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5170 } 5171 5172 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/update") 5173 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5174 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5175 request.Method = "PUT" 5176 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5177 if err != nil { 5178 return out, metadata, &smithy.SerializationError{Err: err} 5179 } 5180 5181 if err := awsRestjson1_serializeOpHttpBindingsUpdateSchemaInput(input, restEncoder); err != nil { 5182 return out, metadata, &smithy.SerializationError{Err: err} 5183 } 5184 5185 restEncoder.SetHeader("Content-Type").String("application/json") 5186 5187 jsonEncoder := smithyjson.NewEncoder() 5188 if err := awsRestjson1_serializeOpDocumentUpdateSchemaInput(input, jsonEncoder.Value); err != nil { 5189 return out, metadata, &smithy.SerializationError{Err: err} 5190 } 5191 5192 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5193 return out, metadata, &smithy.SerializationError{Err: err} 5194 } 5195 5196 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5197 return out, metadata, &smithy.SerializationError{Err: err} 5198 } 5199 in.Request = request 5200 5201 return next.HandleSerialize(ctx, in) 5202} 5203func awsRestjson1_serializeOpHttpBindingsUpdateSchemaInput(v *UpdateSchemaInput, encoder *httpbinding.Encoder) error { 5204 if v == nil { 5205 return fmt.Errorf("unsupported serialization of nil %T", v) 5206 } 5207 5208 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 5209 locationName := "X-Amz-Data-Partition" 5210 encoder.SetHeader(locationName).String(*v.SchemaArn) 5211 } 5212 5213 return nil 5214} 5215 5216func awsRestjson1_serializeOpDocumentUpdateSchemaInput(v *UpdateSchemaInput, value smithyjson.Value) error { 5217 object := value.Object() 5218 defer object.Close() 5219 5220 if v.Name != nil { 5221 ok := object.Key("Name") 5222 ok.String(*v.Name) 5223 } 5224 5225 return nil 5226} 5227 5228type awsRestjson1_serializeOpUpdateTypedLinkFacet struct { 5229} 5230 5231func (*awsRestjson1_serializeOpUpdateTypedLinkFacet) ID() string { 5232 return "OperationSerializer" 5233} 5234 5235func (m *awsRestjson1_serializeOpUpdateTypedLinkFacet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5236 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5237) { 5238 request, ok := in.Request.(*smithyhttp.Request) 5239 if !ok { 5240 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5241 } 5242 5243 input, ok := in.Parameters.(*UpdateTypedLinkFacetInput) 5244 _ = input 5245 if !ok { 5246 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5247 } 5248 5249 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/typedlink/facet") 5250 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5251 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5252 request.Method = "PUT" 5253 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5254 if err != nil { 5255 return out, metadata, &smithy.SerializationError{Err: err} 5256 } 5257 5258 if err := awsRestjson1_serializeOpHttpBindingsUpdateTypedLinkFacetInput(input, restEncoder); err != nil { 5259 return out, metadata, &smithy.SerializationError{Err: err} 5260 } 5261 5262 restEncoder.SetHeader("Content-Type").String("application/json") 5263 5264 jsonEncoder := smithyjson.NewEncoder() 5265 if err := awsRestjson1_serializeOpDocumentUpdateTypedLinkFacetInput(input, jsonEncoder.Value); err != nil { 5266 return out, metadata, &smithy.SerializationError{Err: err} 5267 } 5268 5269 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5270 return out, metadata, &smithy.SerializationError{Err: err} 5271 } 5272 5273 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5274 return out, metadata, &smithy.SerializationError{Err: err} 5275 } 5276 in.Request = request 5277 5278 return next.HandleSerialize(ctx, in) 5279} 5280func awsRestjson1_serializeOpHttpBindingsUpdateTypedLinkFacetInput(v *UpdateTypedLinkFacetInput, encoder *httpbinding.Encoder) error { 5281 if v == nil { 5282 return fmt.Errorf("unsupported serialization of nil %T", v) 5283 } 5284 5285 if v.SchemaArn != nil && len(*v.SchemaArn) > 0 { 5286 locationName := "X-Amz-Data-Partition" 5287 encoder.SetHeader(locationName).String(*v.SchemaArn) 5288 } 5289 5290 return nil 5291} 5292 5293func awsRestjson1_serializeOpDocumentUpdateTypedLinkFacetInput(v *UpdateTypedLinkFacetInput, value smithyjson.Value) error { 5294 object := value.Object() 5295 defer object.Close() 5296 5297 if v.AttributeUpdates != nil { 5298 ok := object.Key("AttributeUpdates") 5299 if err := awsRestjson1_serializeDocumentTypedLinkFacetAttributeUpdateList(v.AttributeUpdates, ok); err != nil { 5300 return err 5301 } 5302 } 5303 5304 if v.IdentityAttributeOrder != nil { 5305 ok := object.Key("IdentityAttributeOrder") 5306 if err := awsRestjson1_serializeDocumentAttributeNameList(v.IdentityAttributeOrder, ok); err != nil { 5307 return err 5308 } 5309 } 5310 5311 if v.Name != nil { 5312 ok := object.Key("Name") 5313 ok.String(*v.Name) 5314 } 5315 5316 return nil 5317} 5318 5319type awsRestjson1_serializeOpUpgradeAppliedSchema struct { 5320} 5321 5322func (*awsRestjson1_serializeOpUpgradeAppliedSchema) ID() string { 5323 return "OperationSerializer" 5324} 5325 5326func (m *awsRestjson1_serializeOpUpgradeAppliedSchema) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5327 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5328) { 5329 request, ok := in.Request.(*smithyhttp.Request) 5330 if !ok { 5331 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5332 } 5333 5334 input, ok := in.Parameters.(*UpgradeAppliedSchemaInput) 5335 _ = input 5336 if !ok { 5337 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5338 } 5339 5340 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/upgradeapplied") 5341 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5342 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5343 request.Method = "PUT" 5344 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5345 if err != nil { 5346 return out, metadata, &smithy.SerializationError{Err: err} 5347 } 5348 5349 restEncoder.SetHeader("Content-Type").String("application/json") 5350 5351 jsonEncoder := smithyjson.NewEncoder() 5352 if err := awsRestjson1_serializeOpDocumentUpgradeAppliedSchemaInput(input, jsonEncoder.Value); err != nil { 5353 return out, metadata, &smithy.SerializationError{Err: err} 5354 } 5355 5356 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5357 return out, metadata, &smithy.SerializationError{Err: err} 5358 } 5359 5360 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5361 return out, metadata, &smithy.SerializationError{Err: err} 5362 } 5363 in.Request = request 5364 5365 return next.HandleSerialize(ctx, in) 5366} 5367func awsRestjson1_serializeOpHttpBindingsUpgradeAppliedSchemaInput(v *UpgradeAppliedSchemaInput, encoder *httpbinding.Encoder) error { 5368 if v == nil { 5369 return fmt.Errorf("unsupported serialization of nil %T", v) 5370 } 5371 5372 return nil 5373} 5374 5375func awsRestjson1_serializeOpDocumentUpgradeAppliedSchemaInput(v *UpgradeAppliedSchemaInput, value smithyjson.Value) error { 5376 object := value.Object() 5377 defer object.Close() 5378 5379 if v.DirectoryArn != nil { 5380 ok := object.Key("DirectoryArn") 5381 ok.String(*v.DirectoryArn) 5382 } 5383 5384 if v.DryRun { 5385 ok := object.Key("DryRun") 5386 ok.Boolean(v.DryRun) 5387 } 5388 5389 if v.PublishedSchemaArn != nil { 5390 ok := object.Key("PublishedSchemaArn") 5391 ok.String(*v.PublishedSchemaArn) 5392 } 5393 5394 return nil 5395} 5396 5397type awsRestjson1_serializeOpUpgradePublishedSchema struct { 5398} 5399 5400func (*awsRestjson1_serializeOpUpgradePublishedSchema) ID() string { 5401 return "OperationSerializer" 5402} 5403 5404func (m *awsRestjson1_serializeOpUpgradePublishedSchema) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5405 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5406) { 5407 request, ok := in.Request.(*smithyhttp.Request) 5408 if !ok { 5409 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5410 } 5411 5412 input, ok := in.Parameters.(*UpgradePublishedSchemaInput) 5413 _ = input 5414 if !ok { 5415 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5416 } 5417 5418 opPath, opQuery := httpbinding.SplitURI("/amazonclouddirectory/2017-01-11/schema/upgradepublished") 5419 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 5420 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 5421 request.Method = "PUT" 5422 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5423 if err != nil { 5424 return out, metadata, &smithy.SerializationError{Err: err} 5425 } 5426 5427 restEncoder.SetHeader("Content-Type").String("application/json") 5428 5429 jsonEncoder := smithyjson.NewEncoder() 5430 if err := awsRestjson1_serializeOpDocumentUpgradePublishedSchemaInput(input, jsonEncoder.Value); err != nil { 5431 return out, metadata, &smithy.SerializationError{Err: err} 5432 } 5433 5434 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5435 return out, metadata, &smithy.SerializationError{Err: err} 5436 } 5437 5438 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5439 return out, metadata, &smithy.SerializationError{Err: err} 5440 } 5441 in.Request = request 5442 5443 return next.HandleSerialize(ctx, in) 5444} 5445func awsRestjson1_serializeOpHttpBindingsUpgradePublishedSchemaInput(v *UpgradePublishedSchemaInput, encoder *httpbinding.Encoder) error { 5446 if v == nil { 5447 return fmt.Errorf("unsupported serialization of nil %T", v) 5448 } 5449 5450 return nil 5451} 5452 5453func awsRestjson1_serializeOpDocumentUpgradePublishedSchemaInput(v *UpgradePublishedSchemaInput, value smithyjson.Value) error { 5454 object := value.Object() 5455 defer object.Close() 5456 5457 if v.DevelopmentSchemaArn != nil { 5458 ok := object.Key("DevelopmentSchemaArn") 5459 ok.String(*v.DevelopmentSchemaArn) 5460 } 5461 5462 if v.DryRun { 5463 ok := object.Key("DryRun") 5464 ok.Boolean(v.DryRun) 5465 } 5466 5467 if v.MinorVersion != nil { 5468 ok := object.Key("MinorVersion") 5469 ok.String(*v.MinorVersion) 5470 } 5471 5472 if v.PublishedSchemaArn != nil { 5473 ok := object.Key("PublishedSchemaArn") 5474 ok.String(*v.PublishedSchemaArn) 5475 } 5476 5477 return nil 5478} 5479 5480func awsRestjson1_serializeDocumentAttributeKey(v *types.AttributeKey, value smithyjson.Value) error { 5481 object := value.Object() 5482 defer object.Close() 5483 5484 if v.FacetName != nil { 5485 ok := object.Key("FacetName") 5486 ok.String(*v.FacetName) 5487 } 5488 5489 if v.Name != nil { 5490 ok := object.Key("Name") 5491 ok.String(*v.Name) 5492 } 5493 5494 if v.SchemaArn != nil { 5495 ok := object.Key("SchemaArn") 5496 ok.String(*v.SchemaArn) 5497 } 5498 5499 return nil 5500} 5501 5502func awsRestjson1_serializeDocumentAttributeKeyAndValue(v *types.AttributeKeyAndValue, value smithyjson.Value) error { 5503 object := value.Object() 5504 defer object.Close() 5505 5506 if v.Key != nil { 5507 ok := object.Key("Key") 5508 if err := awsRestjson1_serializeDocumentAttributeKey(v.Key, ok); err != nil { 5509 return err 5510 } 5511 } 5512 5513 if v.Value != nil { 5514 ok := object.Key("Value") 5515 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.Value, ok); err != nil { 5516 return err 5517 } 5518 } 5519 5520 return nil 5521} 5522 5523func awsRestjson1_serializeDocumentAttributeKeyAndValueList(v []types.AttributeKeyAndValue, value smithyjson.Value) error { 5524 array := value.Array() 5525 defer array.Close() 5526 5527 for i := range v { 5528 av := array.Value() 5529 if err := awsRestjson1_serializeDocumentAttributeKeyAndValue(&v[i], av); err != nil { 5530 return err 5531 } 5532 } 5533 return nil 5534} 5535 5536func awsRestjson1_serializeDocumentAttributeKeyList(v []types.AttributeKey, value smithyjson.Value) error { 5537 array := value.Array() 5538 defer array.Close() 5539 5540 for i := range v { 5541 av := array.Value() 5542 if err := awsRestjson1_serializeDocumentAttributeKey(&v[i], av); err != nil { 5543 return err 5544 } 5545 } 5546 return nil 5547} 5548 5549func awsRestjson1_serializeDocumentAttributeNameAndValue(v *types.AttributeNameAndValue, value smithyjson.Value) error { 5550 object := value.Object() 5551 defer object.Close() 5552 5553 if v.AttributeName != nil { 5554 ok := object.Key("AttributeName") 5555 ok.String(*v.AttributeName) 5556 } 5557 5558 if v.Value != nil { 5559 ok := object.Key("Value") 5560 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.Value, ok); err != nil { 5561 return err 5562 } 5563 } 5564 5565 return nil 5566} 5567 5568func awsRestjson1_serializeDocumentAttributeNameAndValueList(v []types.AttributeNameAndValue, value smithyjson.Value) error { 5569 array := value.Array() 5570 defer array.Close() 5571 5572 for i := range v { 5573 av := array.Value() 5574 if err := awsRestjson1_serializeDocumentAttributeNameAndValue(&v[i], av); err != nil { 5575 return err 5576 } 5577 } 5578 return nil 5579} 5580 5581func awsRestjson1_serializeDocumentAttributeNameList(v []string, value smithyjson.Value) error { 5582 array := value.Array() 5583 defer array.Close() 5584 5585 for i := range v { 5586 av := array.Value() 5587 av.String(v[i]) 5588 } 5589 return nil 5590} 5591 5592func awsRestjson1_serializeDocumentBatchAddFacetToObject(v *types.BatchAddFacetToObject, value smithyjson.Value) error { 5593 object := value.Object() 5594 defer object.Close() 5595 5596 if v.ObjectAttributeList != nil { 5597 ok := object.Key("ObjectAttributeList") 5598 if err := awsRestjson1_serializeDocumentAttributeKeyAndValueList(v.ObjectAttributeList, ok); err != nil { 5599 return err 5600 } 5601 } 5602 5603 if v.ObjectReference != nil { 5604 ok := object.Key("ObjectReference") 5605 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 5606 return err 5607 } 5608 } 5609 5610 if v.SchemaFacet != nil { 5611 ok := object.Key("SchemaFacet") 5612 if err := awsRestjson1_serializeDocumentSchemaFacet(v.SchemaFacet, ok); err != nil { 5613 return err 5614 } 5615 } 5616 5617 return nil 5618} 5619 5620func awsRestjson1_serializeDocumentBatchAttachObject(v *types.BatchAttachObject, value smithyjson.Value) error { 5621 object := value.Object() 5622 defer object.Close() 5623 5624 if v.ChildReference != nil { 5625 ok := object.Key("ChildReference") 5626 if err := awsRestjson1_serializeDocumentObjectReference(v.ChildReference, ok); err != nil { 5627 return err 5628 } 5629 } 5630 5631 if v.LinkName != nil { 5632 ok := object.Key("LinkName") 5633 ok.String(*v.LinkName) 5634 } 5635 5636 if v.ParentReference != nil { 5637 ok := object.Key("ParentReference") 5638 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 5639 return err 5640 } 5641 } 5642 5643 return nil 5644} 5645 5646func awsRestjson1_serializeDocumentBatchAttachPolicy(v *types.BatchAttachPolicy, value smithyjson.Value) error { 5647 object := value.Object() 5648 defer object.Close() 5649 5650 if v.ObjectReference != nil { 5651 ok := object.Key("ObjectReference") 5652 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 5653 return err 5654 } 5655 } 5656 5657 if v.PolicyReference != nil { 5658 ok := object.Key("PolicyReference") 5659 if err := awsRestjson1_serializeDocumentObjectReference(v.PolicyReference, ok); err != nil { 5660 return err 5661 } 5662 } 5663 5664 return nil 5665} 5666 5667func awsRestjson1_serializeDocumentBatchAttachToIndex(v *types.BatchAttachToIndex, value smithyjson.Value) error { 5668 object := value.Object() 5669 defer object.Close() 5670 5671 if v.IndexReference != nil { 5672 ok := object.Key("IndexReference") 5673 if err := awsRestjson1_serializeDocumentObjectReference(v.IndexReference, ok); err != nil { 5674 return err 5675 } 5676 } 5677 5678 if v.TargetReference != nil { 5679 ok := object.Key("TargetReference") 5680 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetReference, ok); err != nil { 5681 return err 5682 } 5683 } 5684 5685 return nil 5686} 5687 5688func awsRestjson1_serializeDocumentBatchAttachTypedLink(v *types.BatchAttachTypedLink, value smithyjson.Value) error { 5689 object := value.Object() 5690 defer object.Close() 5691 5692 if v.Attributes != nil { 5693 ok := object.Key("Attributes") 5694 if err := awsRestjson1_serializeDocumentAttributeNameAndValueList(v.Attributes, ok); err != nil { 5695 return err 5696 } 5697 } 5698 5699 if v.SourceObjectReference != nil { 5700 ok := object.Key("SourceObjectReference") 5701 if err := awsRestjson1_serializeDocumentObjectReference(v.SourceObjectReference, ok); err != nil { 5702 return err 5703 } 5704 } 5705 5706 if v.TargetObjectReference != nil { 5707 ok := object.Key("TargetObjectReference") 5708 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetObjectReference, ok); err != nil { 5709 return err 5710 } 5711 } 5712 5713 if v.TypedLinkFacet != nil { 5714 ok := object.Key("TypedLinkFacet") 5715 if err := awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v.TypedLinkFacet, ok); err != nil { 5716 return err 5717 } 5718 } 5719 5720 return nil 5721} 5722 5723func awsRestjson1_serializeDocumentBatchCreateIndex(v *types.BatchCreateIndex, value smithyjson.Value) error { 5724 object := value.Object() 5725 defer object.Close() 5726 5727 if v.BatchReferenceName != nil { 5728 ok := object.Key("BatchReferenceName") 5729 ok.String(*v.BatchReferenceName) 5730 } 5731 5732 { 5733 ok := object.Key("IsUnique") 5734 ok.Boolean(v.IsUnique) 5735 } 5736 5737 if v.LinkName != nil { 5738 ok := object.Key("LinkName") 5739 ok.String(*v.LinkName) 5740 } 5741 5742 if v.OrderedIndexedAttributeList != nil { 5743 ok := object.Key("OrderedIndexedAttributeList") 5744 if err := awsRestjson1_serializeDocumentAttributeKeyList(v.OrderedIndexedAttributeList, ok); err != nil { 5745 return err 5746 } 5747 } 5748 5749 if v.ParentReference != nil { 5750 ok := object.Key("ParentReference") 5751 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 5752 return err 5753 } 5754 } 5755 5756 return nil 5757} 5758 5759func awsRestjson1_serializeDocumentBatchCreateObject(v *types.BatchCreateObject, value smithyjson.Value) error { 5760 object := value.Object() 5761 defer object.Close() 5762 5763 if v.BatchReferenceName != nil { 5764 ok := object.Key("BatchReferenceName") 5765 ok.String(*v.BatchReferenceName) 5766 } 5767 5768 if v.LinkName != nil { 5769 ok := object.Key("LinkName") 5770 ok.String(*v.LinkName) 5771 } 5772 5773 if v.ObjectAttributeList != nil { 5774 ok := object.Key("ObjectAttributeList") 5775 if err := awsRestjson1_serializeDocumentAttributeKeyAndValueList(v.ObjectAttributeList, ok); err != nil { 5776 return err 5777 } 5778 } 5779 5780 if v.ParentReference != nil { 5781 ok := object.Key("ParentReference") 5782 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 5783 return err 5784 } 5785 } 5786 5787 if v.SchemaFacet != nil { 5788 ok := object.Key("SchemaFacet") 5789 if err := awsRestjson1_serializeDocumentSchemaFacetList(v.SchemaFacet, ok); err != nil { 5790 return err 5791 } 5792 } 5793 5794 return nil 5795} 5796 5797func awsRestjson1_serializeDocumentBatchDeleteObject(v *types.BatchDeleteObject, value smithyjson.Value) error { 5798 object := value.Object() 5799 defer object.Close() 5800 5801 if v.ObjectReference != nil { 5802 ok := object.Key("ObjectReference") 5803 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 5804 return err 5805 } 5806 } 5807 5808 return nil 5809} 5810 5811func awsRestjson1_serializeDocumentBatchDetachFromIndex(v *types.BatchDetachFromIndex, value smithyjson.Value) error { 5812 object := value.Object() 5813 defer object.Close() 5814 5815 if v.IndexReference != nil { 5816 ok := object.Key("IndexReference") 5817 if err := awsRestjson1_serializeDocumentObjectReference(v.IndexReference, ok); err != nil { 5818 return err 5819 } 5820 } 5821 5822 if v.TargetReference != nil { 5823 ok := object.Key("TargetReference") 5824 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetReference, ok); err != nil { 5825 return err 5826 } 5827 } 5828 5829 return nil 5830} 5831 5832func awsRestjson1_serializeDocumentBatchDetachObject(v *types.BatchDetachObject, value smithyjson.Value) error { 5833 object := value.Object() 5834 defer object.Close() 5835 5836 if v.BatchReferenceName != nil { 5837 ok := object.Key("BatchReferenceName") 5838 ok.String(*v.BatchReferenceName) 5839 } 5840 5841 if v.LinkName != nil { 5842 ok := object.Key("LinkName") 5843 ok.String(*v.LinkName) 5844 } 5845 5846 if v.ParentReference != nil { 5847 ok := object.Key("ParentReference") 5848 if err := awsRestjson1_serializeDocumentObjectReference(v.ParentReference, ok); err != nil { 5849 return err 5850 } 5851 } 5852 5853 return nil 5854} 5855 5856func awsRestjson1_serializeDocumentBatchDetachPolicy(v *types.BatchDetachPolicy, value smithyjson.Value) error { 5857 object := value.Object() 5858 defer object.Close() 5859 5860 if v.ObjectReference != nil { 5861 ok := object.Key("ObjectReference") 5862 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 5863 return err 5864 } 5865 } 5866 5867 if v.PolicyReference != nil { 5868 ok := object.Key("PolicyReference") 5869 if err := awsRestjson1_serializeDocumentObjectReference(v.PolicyReference, ok); err != nil { 5870 return err 5871 } 5872 } 5873 5874 return nil 5875} 5876 5877func awsRestjson1_serializeDocumentBatchDetachTypedLink(v *types.BatchDetachTypedLink, value smithyjson.Value) error { 5878 object := value.Object() 5879 defer object.Close() 5880 5881 if v.TypedLinkSpecifier != nil { 5882 ok := object.Key("TypedLinkSpecifier") 5883 if err := awsRestjson1_serializeDocumentTypedLinkSpecifier(v.TypedLinkSpecifier, ok); err != nil { 5884 return err 5885 } 5886 } 5887 5888 return nil 5889} 5890 5891func awsRestjson1_serializeDocumentBatchGetLinkAttributes(v *types.BatchGetLinkAttributes, value smithyjson.Value) error { 5892 object := value.Object() 5893 defer object.Close() 5894 5895 if v.AttributeNames != nil { 5896 ok := object.Key("AttributeNames") 5897 if err := awsRestjson1_serializeDocumentAttributeNameList(v.AttributeNames, ok); err != nil { 5898 return err 5899 } 5900 } 5901 5902 if v.TypedLinkSpecifier != nil { 5903 ok := object.Key("TypedLinkSpecifier") 5904 if err := awsRestjson1_serializeDocumentTypedLinkSpecifier(v.TypedLinkSpecifier, ok); err != nil { 5905 return err 5906 } 5907 } 5908 5909 return nil 5910} 5911 5912func awsRestjson1_serializeDocumentBatchGetObjectAttributes(v *types.BatchGetObjectAttributes, value smithyjson.Value) error { 5913 object := value.Object() 5914 defer object.Close() 5915 5916 if v.AttributeNames != nil { 5917 ok := object.Key("AttributeNames") 5918 if err := awsRestjson1_serializeDocumentAttributeNameList(v.AttributeNames, ok); err != nil { 5919 return err 5920 } 5921 } 5922 5923 if v.ObjectReference != nil { 5924 ok := object.Key("ObjectReference") 5925 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 5926 return err 5927 } 5928 } 5929 5930 if v.SchemaFacet != nil { 5931 ok := object.Key("SchemaFacet") 5932 if err := awsRestjson1_serializeDocumentSchemaFacet(v.SchemaFacet, ok); err != nil { 5933 return err 5934 } 5935 } 5936 5937 return nil 5938} 5939 5940func awsRestjson1_serializeDocumentBatchGetObjectInformation(v *types.BatchGetObjectInformation, value smithyjson.Value) error { 5941 object := value.Object() 5942 defer object.Close() 5943 5944 if v.ObjectReference != nil { 5945 ok := object.Key("ObjectReference") 5946 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 5947 return err 5948 } 5949 } 5950 5951 return nil 5952} 5953 5954func awsRestjson1_serializeDocumentBatchListAttachedIndices(v *types.BatchListAttachedIndices, value smithyjson.Value) error { 5955 object := value.Object() 5956 defer object.Close() 5957 5958 if v.MaxResults != nil { 5959 ok := object.Key("MaxResults") 5960 ok.Integer(*v.MaxResults) 5961 } 5962 5963 if v.NextToken != nil { 5964 ok := object.Key("NextToken") 5965 ok.String(*v.NextToken) 5966 } 5967 5968 if v.TargetReference != nil { 5969 ok := object.Key("TargetReference") 5970 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetReference, ok); err != nil { 5971 return err 5972 } 5973 } 5974 5975 return nil 5976} 5977 5978func awsRestjson1_serializeDocumentBatchListIncomingTypedLinks(v *types.BatchListIncomingTypedLinks, value smithyjson.Value) error { 5979 object := value.Object() 5980 defer object.Close() 5981 5982 if v.FilterAttributeRanges != nil { 5983 ok := object.Key("FilterAttributeRanges") 5984 if err := awsRestjson1_serializeDocumentTypedLinkAttributeRangeList(v.FilterAttributeRanges, ok); err != nil { 5985 return err 5986 } 5987 } 5988 5989 if v.FilterTypedLink != nil { 5990 ok := object.Key("FilterTypedLink") 5991 if err := awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v.FilterTypedLink, ok); err != nil { 5992 return err 5993 } 5994 } 5995 5996 if v.MaxResults != nil { 5997 ok := object.Key("MaxResults") 5998 ok.Integer(*v.MaxResults) 5999 } 6000 6001 if v.NextToken != nil { 6002 ok := object.Key("NextToken") 6003 ok.String(*v.NextToken) 6004 } 6005 6006 if v.ObjectReference != nil { 6007 ok := object.Key("ObjectReference") 6008 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6009 return err 6010 } 6011 } 6012 6013 return nil 6014} 6015 6016func awsRestjson1_serializeDocumentBatchListIndex(v *types.BatchListIndex, value smithyjson.Value) error { 6017 object := value.Object() 6018 defer object.Close() 6019 6020 if v.IndexReference != nil { 6021 ok := object.Key("IndexReference") 6022 if err := awsRestjson1_serializeDocumentObjectReference(v.IndexReference, ok); err != nil { 6023 return err 6024 } 6025 } 6026 6027 if v.MaxResults != nil { 6028 ok := object.Key("MaxResults") 6029 ok.Integer(*v.MaxResults) 6030 } 6031 6032 if v.NextToken != nil { 6033 ok := object.Key("NextToken") 6034 ok.String(*v.NextToken) 6035 } 6036 6037 if v.RangesOnIndexedValues != nil { 6038 ok := object.Key("RangesOnIndexedValues") 6039 if err := awsRestjson1_serializeDocumentObjectAttributeRangeList(v.RangesOnIndexedValues, ok); err != nil { 6040 return err 6041 } 6042 } 6043 6044 return nil 6045} 6046 6047func awsRestjson1_serializeDocumentBatchListObjectAttributes(v *types.BatchListObjectAttributes, value smithyjson.Value) error { 6048 object := value.Object() 6049 defer object.Close() 6050 6051 if v.FacetFilter != nil { 6052 ok := object.Key("FacetFilter") 6053 if err := awsRestjson1_serializeDocumentSchemaFacet(v.FacetFilter, ok); err != nil { 6054 return err 6055 } 6056 } 6057 6058 if v.MaxResults != nil { 6059 ok := object.Key("MaxResults") 6060 ok.Integer(*v.MaxResults) 6061 } 6062 6063 if v.NextToken != nil { 6064 ok := object.Key("NextToken") 6065 ok.String(*v.NextToken) 6066 } 6067 6068 if v.ObjectReference != nil { 6069 ok := object.Key("ObjectReference") 6070 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6071 return err 6072 } 6073 } 6074 6075 return nil 6076} 6077 6078func awsRestjson1_serializeDocumentBatchListObjectChildren(v *types.BatchListObjectChildren, value smithyjson.Value) error { 6079 object := value.Object() 6080 defer object.Close() 6081 6082 if v.MaxResults != nil { 6083 ok := object.Key("MaxResults") 6084 ok.Integer(*v.MaxResults) 6085 } 6086 6087 if v.NextToken != nil { 6088 ok := object.Key("NextToken") 6089 ok.String(*v.NextToken) 6090 } 6091 6092 if v.ObjectReference != nil { 6093 ok := object.Key("ObjectReference") 6094 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6095 return err 6096 } 6097 } 6098 6099 return nil 6100} 6101 6102func awsRestjson1_serializeDocumentBatchListObjectParentPaths(v *types.BatchListObjectParentPaths, value smithyjson.Value) error { 6103 object := value.Object() 6104 defer object.Close() 6105 6106 if v.MaxResults != nil { 6107 ok := object.Key("MaxResults") 6108 ok.Integer(*v.MaxResults) 6109 } 6110 6111 if v.NextToken != nil { 6112 ok := object.Key("NextToken") 6113 ok.String(*v.NextToken) 6114 } 6115 6116 if v.ObjectReference != nil { 6117 ok := object.Key("ObjectReference") 6118 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6119 return err 6120 } 6121 } 6122 6123 return nil 6124} 6125 6126func awsRestjson1_serializeDocumentBatchListObjectParents(v *types.BatchListObjectParents, value smithyjson.Value) error { 6127 object := value.Object() 6128 defer object.Close() 6129 6130 if v.MaxResults != nil { 6131 ok := object.Key("MaxResults") 6132 ok.Integer(*v.MaxResults) 6133 } 6134 6135 if v.NextToken != nil { 6136 ok := object.Key("NextToken") 6137 ok.String(*v.NextToken) 6138 } 6139 6140 if v.ObjectReference != nil { 6141 ok := object.Key("ObjectReference") 6142 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6143 return err 6144 } 6145 } 6146 6147 return nil 6148} 6149 6150func awsRestjson1_serializeDocumentBatchListObjectPolicies(v *types.BatchListObjectPolicies, value smithyjson.Value) error { 6151 object := value.Object() 6152 defer object.Close() 6153 6154 if v.MaxResults != nil { 6155 ok := object.Key("MaxResults") 6156 ok.Integer(*v.MaxResults) 6157 } 6158 6159 if v.NextToken != nil { 6160 ok := object.Key("NextToken") 6161 ok.String(*v.NextToken) 6162 } 6163 6164 if v.ObjectReference != nil { 6165 ok := object.Key("ObjectReference") 6166 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6167 return err 6168 } 6169 } 6170 6171 return nil 6172} 6173 6174func awsRestjson1_serializeDocumentBatchListOutgoingTypedLinks(v *types.BatchListOutgoingTypedLinks, value smithyjson.Value) error { 6175 object := value.Object() 6176 defer object.Close() 6177 6178 if v.FilterAttributeRanges != nil { 6179 ok := object.Key("FilterAttributeRanges") 6180 if err := awsRestjson1_serializeDocumentTypedLinkAttributeRangeList(v.FilterAttributeRanges, ok); err != nil { 6181 return err 6182 } 6183 } 6184 6185 if v.FilterTypedLink != nil { 6186 ok := object.Key("FilterTypedLink") 6187 if err := awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v.FilterTypedLink, ok); err != nil { 6188 return err 6189 } 6190 } 6191 6192 if v.MaxResults != nil { 6193 ok := object.Key("MaxResults") 6194 ok.Integer(*v.MaxResults) 6195 } 6196 6197 if v.NextToken != nil { 6198 ok := object.Key("NextToken") 6199 ok.String(*v.NextToken) 6200 } 6201 6202 if v.ObjectReference != nil { 6203 ok := object.Key("ObjectReference") 6204 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6205 return err 6206 } 6207 } 6208 6209 return nil 6210} 6211 6212func awsRestjson1_serializeDocumentBatchListPolicyAttachments(v *types.BatchListPolicyAttachments, value smithyjson.Value) error { 6213 object := value.Object() 6214 defer object.Close() 6215 6216 if v.MaxResults != nil { 6217 ok := object.Key("MaxResults") 6218 ok.Integer(*v.MaxResults) 6219 } 6220 6221 if v.NextToken != nil { 6222 ok := object.Key("NextToken") 6223 ok.String(*v.NextToken) 6224 } 6225 6226 if v.PolicyReference != nil { 6227 ok := object.Key("PolicyReference") 6228 if err := awsRestjson1_serializeDocumentObjectReference(v.PolicyReference, ok); err != nil { 6229 return err 6230 } 6231 } 6232 6233 return nil 6234} 6235 6236func awsRestjson1_serializeDocumentBatchLookupPolicy(v *types.BatchLookupPolicy, value smithyjson.Value) error { 6237 object := value.Object() 6238 defer object.Close() 6239 6240 if v.MaxResults != nil { 6241 ok := object.Key("MaxResults") 6242 ok.Integer(*v.MaxResults) 6243 } 6244 6245 if v.NextToken != nil { 6246 ok := object.Key("NextToken") 6247 ok.String(*v.NextToken) 6248 } 6249 6250 if v.ObjectReference != nil { 6251 ok := object.Key("ObjectReference") 6252 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6253 return err 6254 } 6255 } 6256 6257 return nil 6258} 6259 6260func awsRestjson1_serializeDocumentBatchReadOperation(v *types.BatchReadOperation, value smithyjson.Value) error { 6261 object := value.Object() 6262 defer object.Close() 6263 6264 if v.GetLinkAttributes != nil { 6265 ok := object.Key("GetLinkAttributes") 6266 if err := awsRestjson1_serializeDocumentBatchGetLinkAttributes(v.GetLinkAttributes, ok); err != nil { 6267 return err 6268 } 6269 } 6270 6271 if v.GetObjectAttributes != nil { 6272 ok := object.Key("GetObjectAttributes") 6273 if err := awsRestjson1_serializeDocumentBatchGetObjectAttributes(v.GetObjectAttributes, ok); err != nil { 6274 return err 6275 } 6276 } 6277 6278 if v.GetObjectInformation != nil { 6279 ok := object.Key("GetObjectInformation") 6280 if err := awsRestjson1_serializeDocumentBatchGetObjectInformation(v.GetObjectInformation, ok); err != nil { 6281 return err 6282 } 6283 } 6284 6285 if v.ListAttachedIndices != nil { 6286 ok := object.Key("ListAttachedIndices") 6287 if err := awsRestjson1_serializeDocumentBatchListAttachedIndices(v.ListAttachedIndices, ok); err != nil { 6288 return err 6289 } 6290 } 6291 6292 if v.ListIncomingTypedLinks != nil { 6293 ok := object.Key("ListIncomingTypedLinks") 6294 if err := awsRestjson1_serializeDocumentBatchListIncomingTypedLinks(v.ListIncomingTypedLinks, ok); err != nil { 6295 return err 6296 } 6297 } 6298 6299 if v.ListIndex != nil { 6300 ok := object.Key("ListIndex") 6301 if err := awsRestjson1_serializeDocumentBatchListIndex(v.ListIndex, ok); err != nil { 6302 return err 6303 } 6304 } 6305 6306 if v.ListObjectAttributes != nil { 6307 ok := object.Key("ListObjectAttributes") 6308 if err := awsRestjson1_serializeDocumentBatchListObjectAttributes(v.ListObjectAttributes, ok); err != nil { 6309 return err 6310 } 6311 } 6312 6313 if v.ListObjectChildren != nil { 6314 ok := object.Key("ListObjectChildren") 6315 if err := awsRestjson1_serializeDocumentBatchListObjectChildren(v.ListObjectChildren, ok); err != nil { 6316 return err 6317 } 6318 } 6319 6320 if v.ListObjectParentPaths != nil { 6321 ok := object.Key("ListObjectParentPaths") 6322 if err := awsRestjson1_serializeDocumentBatchListObjectParentPaths(v.ListObjectParentPaths, ok); err != nil { 6323 return err 6324 } 6325 } 6326 6327 if v.ListObjectParents != nil { 6328 ok := object.Key("ListObjectParents") 6329 if err := awsRestjson1_serializeDocumentBatchListObjectParents(v.ListObjectParents, ok); err != nil { 6330 return err 6331 } 6332 } 6333 6334 if v.ListObjectPolicies != nil { 6335 ok := object.Key("ListObjectPolicies") 6336 if err := awsRestjson1_serializeDocumentBatchListObjectPolicies(v.ListObjectPolicies, ok); err != nil { 6337 return err 6338 } 6339 } 6340 6341 if v.ListOutgoingTypedLinks != nil { 6342 ok := object.Key("ListOutgoingTypedLinks") 6343 if err := awsRestjson1_serializeDocumentBatchListOutgoingTypedLinks(v.ListOutgoingTypedLinks, ok); err != nil { 6344 return err 6345 } 6346 } 6347 6348 if v.ListPolicyAttachments != nil { 6349 ok := object.Key("ListPolicyAttachments") 6350 if err := awsRestjson1_serializeDocumentBatchListPolicyAttachments(v.ListPolicyAttachments, ok); err != nil { 6351 return err 6352 } 6353 } 6354 6355 if v.LookupPolicy != nil { 6356 ok := object.Key("LookupPolicy") 6357 if err := awsRestjson1_serializeDocumentBatchLookupPolicy(v.LookupPolicy, ok); err != nil { 6358 return err 6359 } 6360 } 6361 6362 return nil 6363} 6364 6365func awsRestjson1_serializeDocumentBatchReadOperationList(v []types.BatchReadOperation, value smithyjson.Value) error { 6366 array := value.Array() 6367 defer array.Close() 6368 6369 for i := range v { 6370 av := array.Value() 6371 if err := awsRestjson1_serializeDocumentBatchReadOperation(&v[i], av); err != nil { 6372 return err 6373 } 6374 } 6375 return nil 6376} 6377 6378func awsRestjson1_serializeDocumentBatchRemoveFacetFromObject(v *types.BatchRemoveFacetFromObject, value smithyjson.Value) error { 6379 object := value.Object() 6380 defer object.Close() 6381 6382 if v.ObjectReference != nil { 6383 ok := object.Key("ObjectReference") 6384 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6385 return err 6386 } 6387 } 6388 6389 if v.SchemaFacet != nil { 6390 ok := object.Key("SchemaFacet") 6391 if err := awsRestjson1_serializeDocumentSchemaFacet(v.SchemaFacet, ok); err != nil { 6392 return err 6393 } 6394 } 6395 6396 return nil 6397} 6398 6399func awsRestjson1_serializeDocumentBatchUpdateLinkAttributes(v *types.BatchUpdateLinkAttributes, value smithyjson.Value) error { 6400 object := value.Object() 6401 defer object.Close() 6402 6403 if v.AttributeUpdates != nil { 6404 ok := object.Key("AttributeUpdates") 6405 if err := awsRestjson1_serializeDocumentLinkAttributeUpdateList(v.AttributeUpdates, ok); err != nil { 6406 return err 6407 } 6408 } 6409 6410 if v.TypedLinkSpecifier != nil { 6411 ok := object.Key("TypedLinkSpecifier") 6412 if err := awsRestjson1_serializeDocumentTypedLinkSpecifier(v.TypedLinkSpecifier, ok); err != nil { 6413 return err 6414 } 6415 } 6416 6417 return nil 6418} 6419 6420func awsRestjson1_serializeDocumentBatchUpdateObjectAttributes(v *types.BatchUpdateObjectAttributes, value smithyjson.Value) error { 6421 object := value.Object() 6422 defer object.Close() 6423 6424 if v.AttributeUpdates != nil { 6425 ok := object.Key("AttributeUpdates") 6426 if err := awsRestjson1_serializeDocumentObjectAttributeUpdateList(v.AttributeUpdates, ok); err != nil { 6427 return err 6428 } 6429 } 6430 6431 if v.ObjectReference != nil { 6432 ok := object.Key("ObjectReference") 6433 if err := awsRestjson1_serializeDocumentObjectReference(v.ObjectReference, ok); err != nil { 6434 return err 6435 } 6436 } 6437 6438 return nil 6439} 6440 6441func awsRestjson1_serializeDocumentBatchWriteOperation(v *types.BatchWriteOperation, value smithyjson.Value) error { 6442 object := value.Object() 6443 defer object.Close() 6444 6445 if v.AddFacetToObject != nil { 6446 ok := object.Key("AddFacetToObject") 6447 if err := awsRestjson1_serializeDocumentBatchAddFacetToObject(v.AddFacetToObject, ok); err != nil { 6448 return err 6449 } 6450 } 6451 6452 if v.AttachObject != nil { 6453 ok := object.Key("AttachObject") 6454 if err := awsRestjson1_serializeDocumentBatchAttachObject(v.AttachObject, ok); err != nil { 6455 return err 6456 } 6457 } 6458 6459 if v.AttachPolicy != nil { 6460 ok := object.Key("AttachPolicy") 6461 if err := awsRestjson1_serializeDocumentBatchAttachPolicy(v.AttachPolicy, ok); err != nil { 6462 return err 6463 } 6464 } 6465 6466 if v.AttachToIndex != nil { 6467 ok := object.Key("AttachToIndex") 6468 if err := awsRestjson1_serializeDocumentBatchAttachToIndex(v.AttachToIndex, ok); err != nil { 6469 return err 6470 } 6471 } 6472 6473 if v.AttachTypedLink != nil { 6474 ok := object.Key("AttachTypedLink") 6475 if err := awsRestjson1_serializeDocumentBatchAttachTypedLink(v.AttachTypedLink, ok); err != nil { 6476 return err 6477 } 6478 } 6479 6480 if v.CreateIndex != nil { 6481 ok := object.Key("CreateIndex") 6482 if err := awsRestjson1_serializeDocumentBatchCreateIndex(v.CreateIndex, ok); err != nil { 6483 return err 6484 } 6485 } 6486 6487 if v.CreateObject != nil { 6488 ok := object.Key("CreateObject") 6489 if err := awsRestjson1_serializeDocumentBatchCreateObject(v.CreateObject, ok); err != nil { 6490 return err 6491 } 6492 } 6493 6494 if v.DeleteObject != nil { 6495 ok := object.Key("DeleteObject") 6496 if err := awsRestjson1_serializeDocumentBatchDeleteObject(v.DeleteObject, ok); err != nil { 6497 return err 6498 } 6499 } 6500 6501 if v.DetachFromIndex != nil { 6502 ok := object.Key("DetachFromIndex") 6503 if err := awsRestjson1_serializeDocumentBatchDetachFromIndex(v.DetachFromIndex, ok); err != nil { 6504 return err 6505 } 6506 } 6507 6508 if v.DetachObject != nil { 6509 ok := object.Key("DetachObject") 6510 if err := awsRestjson1_serializeDocumentBatchDetachObject(v.DetachObject, ok); err != nil { 6511 return err 6512 } 6513 } 6514 6515 if v.DetachPolicy != nil { 6516 ok := object.Key("DetachPolicy") 6517 if err := awsRestjson1_serializeDocumentBatchDetachPolicy(v.DetachPolicy, ok); err != nil { 6518 return err 6519 } 6520 } 6521 6522 if v.DetachTypedLink != nil { 6523 ok := object.Key("DetachTypedLink") 6524 if err := awsRestjson1_serializeDocumentBatchDetachTypedLink(v.DetachTypedLink, ok); err != nil { 6525 return err 6526 } 6527 } 6528 6529 if v.RemoveFacetFromObject != nil { 6530 ok := object.Key("RemoveFacetFromObject") 6531 if err := awsRestjson1_serializeDocumentBatchRemoveFacetFromObject(v.RemoveFacetFromObject, ok); err != nil { 6532 return err 6533 } 6534 } 6535 6536 if v.UpdateLinkAttributes != nil { 6537 ok := object.Key("UpdateLinkAttributes") 6538 if err := awsRestjson1_serializeDocumentBatchUpdateLinkAttributes(v.UpdateLinkAttributes, ok); err != nil { 6539 return err 6540 } 6541 } 6542 6543 if v.UpdateObjectAttributes != nil { 6544 ok := object.Key("UpdateObjectAttributes") 6545 if err := awsRestjson1_serializeDocumentBatchUpdateObjectAttributes(v.UpdateObjectAttributes, ok); err != nil { 6546 return err 6547 } 6548 } 6549 6550 return nil 6551} 6552 6553func awsRestjson1_serializeDocumentBatchWriteOperationList(v []types.BatchWriteOperation, value smithyjson.Value) error { 6554 array := value.Array() 6555 defer array.Close() 6556 6557 for i := range v { 6558 av := array.Value() 6559 if err := awsRestjson1_serializeDocumentBatchWriteOperation(&v[i], av); err != nil { 6560 return err 6561 } 6562 } 6563 return nil 6564} 6565 6566func awsRestjson1_serializeDocumentFacetAttribute(v *types.FacetAttribute, value smithyjson.Value) error { 6567 object := value.Object() 6568 defer object.Close() 6569 6570 if v.AttributeDefinition != nil { 6571 ok := object.Key("AttributeDefinition") 6572 if err := awsRestjson1_serializeDocumentFacetAttributeDefinition(v.AttributeDefinition, ok); err != nil { 6573 return err 6574 } 6575 } 6576 6577 if v.AttributeReference != nil { 6578 ok := object.Key("AttributeReference") 6579 if err := awsRestjson1_serializeDocumentFacetAttributeReference(v.AttributeReference, ok); err != nil { 6580 return err 6581 } 6582 } 6583 6584 if v.Name != nil { 6585 ok := object.Key("Name") 6586 ok.String(*v.Name) 6587 } 6588 6589 if len(v.RequiredBehavior) > 0 { 6590 ok := object.Key("RequiredBehavior") 6591 ok.String(string(v.RequiredBehavior)) 6592 } 6593 6594 return nil 6595} 6596 6597func awsRestjson1_serializeDocumentFacetAttributeDefinition(v *types.FacetAttributeDefinition, value smithyjson.Value) error { 6598 object := value.Object() 6599 defer object.Close() 6600 6601 if v.DefaultValue != nil { 6602 ok := object.Key("DefaultValue") 6603 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.DefaultValue, ok); err != nil { 6604 return err 6605 } 6606 } 6607 6608 if v.IsImmutable { 6609 ok := object.Key("IsImmutable") 6610 ok.Boolean(v.IsImmutable) 6611 } 6612 6613 if v.Rules != nil { 6614 ok := object.Key("Rules") 6615 if err := awsRestjson1_serializeDocumentRuleMap(v.Rules, ok); err != nil { 6616 return err 6617 } 6618 } 6619 6620 if len(v.Type) > 0 { 6621 ok := object.Key("Type") 6622 ok.String(string(v.Type)) 6623 } 6624 6625 return nil 6626} 6627 6628func awsRestjson1_serializeDocumentFacetAttributeList(v []types.FacetAttribute, value smithyjson.Value) error { 6629 array := value.Array() 6630 defer array.Close() 6631 6632 for i := range v { 6633 av := array.Value() 6634 if err := awsRestjson1_serializeDocumentFacetAttribute(&v[i], av); err != nil { 6635 return err 6636 } 6637 } 6638 return nil 6639} 6640 6641func awsRestjson1_serializeDocumentFacetAttributeReference(v *types.FacetAttributeReference, value smithyjson.Value) error { 6642 object := value.Object() 6643 defer object.Close() 6644 6645 if v.TargetAttributeName != nil { 6646 ok := object.Key("TargetAttributeName") 6647 ok.String(*v.TargetAttributeName) 6648 } 6649 6650 if v.TargetFacetName != nil { 6651 ok := object.Key("TargetFacetName") 6652 ok.String(*v.TargetFacetName) 6653 } 6654 6655 return nil 6656} 6657 6658func awsRestjson1_serializeDocumentFacetAttributeUpdate(v *types.FacetAttributeUpdate, value smithyjson.Value) error { 6659 object := value.Object() 6660 defer object.Close() 6661 6662 if len(v.Action) > 0 { 6663 ok := object.Key("Action") 6664 ok.String(string(v.Action)) 6665 } 6666 6667 if v.Attribute != nil { 6668 ok := object.Key("Attribute") 6669 if err := awsRestjson1_serializeDocumentFacetAttribute(v.Attribute, ok); err != nil { 6670 return err 6671 } 6672 } 6673 6674 return nil 6675} 6676 6677func awsRestjson1_serializeDocumentFacetAttributeUpdateList(v []types.FacetAttributeUpdate, value smithyjson.Value) error { 6678 array := value.Array() 6679 defer array.Close() 6680 6681 for i := range v { 6682 av := array.Value() 6683 if err := awsRestjson1_serializeDocumentFacetAttributeUpdate(&v[i], av); err != nil { 6684 return err 6685 } 6686 } 6687 return nil 6688} 6689 6690func awsRestjson1_serializeDocumentLinkAttributeAction(v *types.LinkAttributeAction, value smithyjson.Value) error { 6691 object := value.Object() 6692 defer object.Close() 6693 6694 if len(v.AttributeActionType) > 0 { 6695 ok := object.Key("AttributeActionType") 6696 ok.String(string(v.AttributeActionType)) 6697 } 6698 6699 if v.AttributeUpdateValue != nil { 6700 ok := object.Key("AttributeUpdateValue") 6701 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.AttributeUpdateValue, ok); err != nil { 6702 return err 6703 } 6704 } 6705 6706 return nil 6707} 6708 6709func awsRestjson1_serializeDocumentLinkAttributeUpdate(v *types.LinkAttributeUpdate, value smithyjson.Value) error { 6710 object := value.Object() 6711 defer object.Close() 6712 6713 if v.AttributeAction != nil { 6714 ok := object.Key("AttributeAction") 6715 if err := awsRestjson1_serializeDocumentLinkAttributeAction(v.AttributeAction, ok); err != nil { 6716 return err 6717 } 6718 } 6719 6720 if v.AttributeKey != nil { 6721 ok := object.Key("AttributeKey") 6722 if err := awsRestjson1_serializeDocumentAttributeKey(v.AttributeKey, ok); err != nil { 6723 return err 6724 } 6725 } 6726 6727 return nil 6728} 6729 6730func awsRestjson1_serializeDocumentLinkAttributeUpdateList(v []types.LinkAttributeUpdate, value smithyjson.Value) error { 6731 array := value.Array() 6732 defer array.Close() 6733 6734 for i := range v { 6735 av := array.Value() 6736 if err := awsRestjson1_serializeDocumentLinkAttributeUpdate(&v[i], av); err != nil { 6737 return err 6738 } 6739 } 6740 return nil 6741} 6742 6743func awsRestjson1_serializeDocumentObjectAttributeAction(v *types.ObjectAttributeAction, value smithyjson.Value) error { 6744 object := value.Object() 6745 defer object.Close() 6746 6747 if len(v.ObjectAttributeActionType) > 0 { 6748 ok := object.Key("ObjectAttributeActionType") 6749 ok.String(string(v.ObjectAttributeActionType)) 6750 } 6751 6752 if v.ObjectAttributeUpdateValue != nil { 6753 ok := object.Key("ObjectAttributeUpdateValue") 6754 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.ObjectAttributeUpdateValue, ok); err != nil { 6755 return err 6756 } 6757 } 6758 6759 return nil 6760} 6761 6762func awsRestjson1_serializeDocumentObjectAttributeRange(v *types.ObjectAttributeRange, value smithyjson.Value) error { 6763 object := value.Object() 6764 defer object.Close() 6765 6766 if v.AttributeKey != nil { 6767 ok := object.Key("AttributeKey") 6768 if err := awsRestjson1_serializeDocumentAttributeKey(v.AttributeKey, ok); err != nil { 6769 return err 6770 } 6771 } 6772 6773 if v.Range != nil { 6774 ok := object.Key("Range") 6775 if err := awsRestjson1_serializeDocumentTypedAttributeValueRange(v.Range, ok); err != nil { 6776 return err 6777 } 6778 } 6779 6780 return nil 6781} 6782 6783func awsRestjson1_serializeDocumentObjectAttributeRangeList(v []types.ObjectAttributeRange, value smithyjson.Value) error { 6784 array := value.Array() 6785 defer array.Close() 6786 6787 for i := range v { 6788 av := array.Value() 6789 if err := awsRestjson1_serializeDocumentObjectAttributeRange(&v[i], av); err != nil { 6790 return err 6791 } 6792 } 6793 return nil 6794} 6795 6796func awsRestjson1_serializeDocumentObjectAttributeUpdate(v *types.ObjectAttributeUpdate, value smithyjson.Value) error { 6797 object := value.Object() 6798 defer object.Close() 6799 6800 if v.ObjectAttributeAction != nil { 6801 ok := object.Key("ObjectAttributeAction") 6802 if err := awsRestjson1_serializeDocumentObjectAttributeAction(v.ObjectAttributeAction, ok); err != nil { 6803 return err 6804 } 6805 } 6806 6807 if v.ObjectAttributeKey != nil { 6808 ok := object.Key("ObjectAttributeKey") 6809 if err := awsRestjson1_serializeDocumentAttributeKey(v.ObjectAttributeKey, ok); err != nil { 6810 return err 6811 } 6812 } 6813 6814 return nil 6815} 6816 6817func awsRestjson1_serializeDocumentObjectAttributeUpdateList(v []types.ObjectAttributeUpdate, value smithyjson.Value) error { 6818 array := value.Array() 6819 defer array.Close() 6820 6821 for i := range v { 6822 av := array.Value() 6823 if err := awsRestjson1_serializeDocumentObjectAttributeUpdate(&v[i], av); err != nil { 6824 return err 6825 } 6826 } 6827 return nil 6828} 6829 6830func awsRestjson1_serializeDocumentObjectReference(v *types.ObjectReference, value smithyjson.Value) error { 6831 object := value.Object() 6832 defer object.Close() 6833 6834 if v.Selector != nil { 6835 ok := object.Key("Selector") 6836 ok.String(*v.Selector) 6837 } 6838 6839 return nil 6840} 6841 6842func awsRestjson1_serializeDocumentRule(v *types.Rule, value smithyjson.Value) error { 6843 object := value.Object() 6844 defer object.Close() 6845 6846 if v.Parameters != nil { 6847 ok := object.Key("Parameters") 6848 if err := awsRestjson1_serializeDocumentRuleParameterMap(v.Parameters, ok); err != nil { 6849 return err 6850 } 6851 } 6852 6853 if len(v.Type) > 0 { 6854 ok := object.Key("Type") 6855 ok.String(string(v.Type)) 6856 } 6857 6858 return nil 6859} 6860 6861func awsRestjson1_serializeDocumentRuleMap(v map[string]types.Rule, value smithyjson.Value) error { 6862 object := value.Object() 6863 defer object.Close() 6864 6865 for key := range v { 6866 om := object.Key(key) 6867 mapVar := v[key] 6868 if err := awsRestjson1_serializeDocumentRule(&mapVar, om); err != nil { 6869 return err 6870 } 6871 } 6872 return nil 6873} 6874 6875func awsRestjson1_serializeDocumentRuleParameterMap(v map[string]string, value smithyjson.Value) error { 6876 object := value.Object() 6877 defer object.Close() 6878 6879 for key := range v { 6880 om := object.Key(key) 6881 om.String(v[key]) 6882 } 6883 return nil 6884} 6885 6886func awsRestjson1_serializeDocumentSchemaFacet(v *types.SchemaFacet, value smithyjson.Value) error { 6887 object := value.Object() 6888 defer object.Close() 6889 6890 if v.FacetName != nil { 6891 ok := object.Key("FacetName") 6892 ok.String(*v.FacetName) 6893 } 6894 6895 if v.SchemaArn != nil { 6896 ok := object.Key("SchemaArn") 6897 ok.String(*v.SchemaArn) 6898 } 6899 6900 return nil 6901} 6902 6903func awsRestjson1_serializeDocumentSchemaFacetList(v []types.SchemaFacet, value smithyjson.Value) error { 6904 array := value.Array() 6905 defer array.Close() 6906 6907 for i := range v { 6908 av := array.Value() 6909 if err := awsRestjson1_serializeDocumentSchemaFacet(&v[i], av); err != nil { 6910 return err 6911 } 6912 } 6913 return nil 6914} 6915 6916func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 6917 object := value.Object() 6918 defer object.Close() 6919 6920 if v.Key != nil { 6921 ok := object.Key("Key") 6922 ok.String(*v.Key) 6923 } 6924 6925 if v.Value != nil { 6926 ok := object.Key("Value") 6927 ok.String(*v.Value) 6928 } 6929 6930 return nil 6931} 6932 6933func awsRestjson1_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error { 6934 array := value.Array() 6935 defer array.Close() 6936 6937 for i := range v { 6938 av := array.Value() 6939 av.String(v[i]) 6940 } 6941 return nil 6942} 6943 6944func awsRestjson1_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error { 6945 array := value.Array() 6946 defer array.Close() 6947 6948 for i := range v { 6949 av := array.Value() 6950 if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil { 6951 return err 6952 } 6953 } 6954 return nil 6955} 6956 6957func awsRestjson1_serializeDocumentTypedAttributeValue(v types.TypedAttributeValue, value smithyjson.Value) error { 6958 object := value.Object() 6959 defer object.Close() 6960 6961 switch uv := v.(type) { 6962 case *types.TypedAttributeValueMemberBinaryValue: 6963 av := object.Key("BinaryValue") 6964 av.Base64EncodeBytes(uv.Value) 6965 6966 case *types.TypedAttributeValueMemberBooleanValue: 6967 av := object.Key("BooleanValue") 6968 av.Boolean(uv.Value) 6969 6970 case *types.TypedAttributeValueMemberDatetimeValue: 6971 av := object.Key("DatetimeValue") 6972 av.Double(smithytime.FormatEpochSeconds(uv.Value)) 6973 6974 case *types.TypedAttributeValueMemberNumberValue: 6975 av := object.Key("NumberValue") 6976 av.String(uv.Value) 6977 6978 case *types.TypedAttributeValueMemberStringValue: 6979 av := object.Key("StringValue") 6980 av.String(uv.Value) 6981 6982 default: 6983 return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v) 6984 6985 } 6986 return nil 6987} 6988 6989func awsRestjson1_serializeDocumentTypedAttributeValueRange(v *types.TypedAttributeValueRange, value smithyjson.Value) error { 6990 object := value.Object() 6991 defer object.Close() 6992 6993 if len(v.EndMode) > 0 { 6994 ok := object.Key("EndMode") 6995 ok.String(string(v.EndMode)) 6996 } 6997 6998 if v.EndValue != nil { 6999 ok := object.Key("EndValue") 7000 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.EndValue, ok); err != nil { 7001 return err 7002 } 7003 } 7004 7005 if len(v.StartMode) > 0 { 7006 ok := object.Key("StartMode") 7007 ok.String(string(v.StartMode)) 7008 } 7009 7010 if v.StartValue != nil { 7011 ok := object.Key("StartValue") 7012 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.StartValue, ok); err != nil { 7013 return err 7014 } 7015 } 7016 7017 return nil 7018} 7019 7020func awsRestjson1_serializeDocumentTypedLinkAttributeDefinition(v *types.TypedLinkAttributeDefinition, value smithyjson.Value) error { 7021 object := value.Object() 7022 defer object.Close() 7023 7024 if v.DefaultValue != nil { 7025 ok := object.Key("DefaultValue") 7026 if err := awsRestjson1_serializeDocumentTypedAttributeValue(v.DefaultValue, ok); err != nil { 7027 return err 7028 } 7029 } 7030 7031 if v.IsImmutable { 7032 ok := object.Key("IsImmutable") 7033 ok.Boolean(v.IsImmutable) 7034 } 7035 7036 if v.Name != nil { 7037 ok := object.Key("Name") 7038 ok.String(*v.Name) 7039 } 7040 7041 if len(v.RequiredBehavior) > 0 { 7042 ok := object.Key("RequiredBehavior") 7043 ok.String(string(v.RequiredBehavior)) 7044 } 7045 7046 if v.Rules != nil { 7047 ok := object.Key("Rules") 7048 if err := awsRestjson1_serializeDocumentRuleMap(v.Rules, ok); err != nil { 7049 return err 7050 } 7051 } 7052 7053 if len(v.Type) > 0 { 7054 ok := object.Key("Type") 7055 ok.String(string(v.Type)) 7056 } 7057 7058 return nil 7059} 7060 7061func awsRestjson1_serializeDocumentTypedLinkAttributeDefinitionList(v []types.TypedLinkAttributeDefinition, value smithyjson.Value) error { 7062 array := value.Array() 7063 defer array.Close() 7064 7065 for i := range v { 7066 av := array.Value() 7067 if err := awsRestjson1_serializeDocumentTypedLinkAttributeDefinition(&v[i], av); err != nil { 7068 return err 7069 } 7070 } 7071 return nil 7072} 7073 7074func awsRestjson1_serializeDocumentTypedLinkAttributeRange(v *types.TypedLinkAttributeRange, value smithyjson.Value) error { 7075 object := value.Object() 7076 defer object.Close() 7077 7078 if v.AttributeName != nil { 7079 ok := object.Key("AttributeName") 7080 ok.String(*v.AttributeName) 7081 } 7082 7083 if v.Range != nil { 7084 ok := object.Key("Range") 7085 if err := awsRestjson1_serializeDocumentTypedAttributeValueRange(v.Range, ok); err != nil { 7086 return err 7087 } 7088 } 7089 7090 return nil 7091} 7092 7093func awsRestjson1_serializeDocumentTypedLinkAttributeRangeList(v []types.TypedLinkAttributeRange, value smithyjson.Value) error { 7094 array := value.Array() 7095 defer array.Close() 7096 7097 for i := range v { 7098 av := array.Value() 7099 if err := awsRestjson1_serializeDocumentTypedLinkAttributeRange(&v[i], av); err != nil { 7100 return err 7101 } 7102 } 7103 return nil 7104} 7105 7106func awsRestjson1_serializeDocumentTypedLinkFacet(v *types.TypedLinkFacet, value smithyjson.Value) error { 7107 object := value.Object() 7108 defer object.Close() 7109 7110 if v.Attributes != nil { 7111 ok := object.Key("Attributes") 7112 if err := awsRestjson1_serializeDocumentTypedLinkAttributeDefinitionList(v.Attributes, ok); err != nil { 7113 return err 7114 } 7115 } 7116 7117 if v.IdentityAttributeOrder != nil { 7118 ok := object.Key("IdentityAttributeOrder") 7119 if err := awsRestjson1_serializeDocumentAttributeNameList(v.IdentityAttributeOrder, ok); err != nil { 7120 return err 7121 } 7122 } 7123 7124 if v.Name != nil { 7125 ok := object.Key("Name") 7126 ok.String(*v.Name) 7127 } 7128 7129 return nil 7130} 7131 7132func awsRestjson1_serializeDocumentTypedLinkFacetAttributeUpdate(v *types.TypedLinkFacetAttributeUpdate, value smithyjson.Value) error { 7133 object := value.Object() 7134 defer object.Close() 7135 7136 if len(v.Action) > 0 { 7137 ok := object.Key("Action") 7138 ok.String(string(v.Action)) 7139 } 7140 7141 if v.Attribute != nil { 7142 ok := object.Key("Attribute") 7143 if err := awsRestjson1_serializeDocumentTypedLinkAttributeDefinition(v.Attribute, ok); err != nil { 7144 return err 7145 } 7146 } 7147 7148 return nil 7149} 7150 7151func awsRestjson1_serializeDocumentTypedLinkFacetAttributeUpdateList(v []types.TypedLinkFacetAttributeUpdate, value smithyjson.Value) error { 7152 array := value.Array() 7153 defer array.Close() 7154 7155 for i := range v { 7156 av := array.Value() 7157 if err := awsRestjson1_serializeDocumentTypedLinkFacetAttributeUpdate(&v[i], av); err != nil { 7158 return err 7159 } 7160 } 7161 return nil 7162} 7163 7164func awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v *types.TypedLinkSchemaAndFacetName, value smithyjson.Value) error { 7165 object := value.Object() 7166 defer object.Close() 7167 7168 if v.SchemaArn != nil { 7169 ok := object.Key("SchemaArn") 7170 ok.String(*v.SchemaArn) 7171 } 7172 7173 if v.TypedLinkName != nil { 7174 ok := object.Key("TypedLinkName") 7175 ok.String(*v.TypedLinkName) 7176 } 7177 7178 return nil 7179} 7180 7181func awsRestjson1_serializeDocumentTypedLinkSpecifier(v *types.TypedLinkSpecifier, value smithyjson.Value) error { 7182 object := value.Object() 7183 defer object.Close() 7184 7185 if v.IdentityAttributeValues != nil { 7186 ok := object.Key("IdentityAttributeValues") 7187 if err := awsRestjson1_serializeDocumentAttributeNameAndValueList(v.IdentityAttributeValues, ok); err != nil { 7188 return err 7189 } 7190 } 7191 7192 if v.SourceObjectReference != nil { 7193 ok := object.Key("SourceObjectReference") 7194 if err := awsRestjson1_serializeDocumentObjectReference(v.SourceObjectReference, ok); err != nil { 7195 return err 7196 } 7197 } 7198 7199 if v.TargetObjectReference != nil { 7200 ok := object.Key("TargetObjectReference") 7201 if err := awsRestjson1_serializeDocumentObjectReference(v.TargetObjectReference, ok); err != nil { 7202 return err 7203 } 7204 } 7205 7206 if v.TypedLinkFacet != nil { 7207 ok := object.Key("TypedLinkFacet") 7208 if err := awsRestjson1_serializeDocumentTypedLinkSchemaAndFacetName(v.TypedLinkFacet, ok); err != nil { 7209 return err 7210 } 7211 } 7212 7213 return nil 7214} 7215