978 lines
33 KiB
Go
978 lines
33 KiB
Go
// Code generated by smithy-go-codegen DO NOT EDIT.
|
|
|
|
package signin
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"github.com/aws/aws-sdk-go-v2/service/signin/types"
|
|
smithy "github.com/aws/smithy-go"
|
|
"github.com/aws/smithy-go/encoding/httpbinding"
|
|
smithyjson "github.com/aws/smithy-go/encoding/json"
|
|
"github.com/aws/smithy-go/middleware"
|
|
"github.com/aws/smithy-go/tracing"
|
|
smithyhttp "github.com/aws/smithy-go/transport/http"
|
|
)
|
|
|
|
type awsRestjson1_serializeOpCreateOAuth2Token struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpCreateOAuth2Token) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpCreateOAuth2Token) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*CreateOAuth2TokenInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/v1/token")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if !restEncoder.HasHeader("Content-Type") {
|
|
ctx = smithyhttp.SetIsContentTypeDefaultValue(ctx, true)
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
}
|
|
|
|
if input.TokenInput != nil {
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeDocumentCreateOAuth2TokenRequestBody(input.TokenInput, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
payload := bytes.NewReader(jsonEncoder.Bytes())
|
|
if request, err = request.SetStream(payload); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
} else {
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
jsonEncoder.Value.Object().Close()
|
|
payload := bytes.NewReader(jsonEncoder.Bytes())
|
|
if request, err = request.SetStream(payload); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsCreateOAuth2TokenInput(v *CreateOAuth2TokenInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpCreateOAuth2TokenWithIAM struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpCreateOAuth2TokenWithIAM) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpCreateOAuth2TokenWithIAM) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*CreateOAuth2TokenWithIAMInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/v1/token?x-amz-client-auth-method=iam")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentCreateOAuth2TokenWithIAMInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsCreateOAuth2TokenWithIAMInput(v *CreateOAuth2TokenWithIAMInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentCreateOAuth2TokenWithIAMInput(v *CreateOAuth2TokenWithIAMInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.GrantType != nil {
|
|
ok := object.Key("grant_type")
|
|
ok.String(*v.GrantType)
|
|
}
|
|
|
|
if v.Resource != nil {
|
|
ok := object.Key("resource")
|
|
ok.String(*v.Resource)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpDeleteConsoleAuthorizationConfiguration struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpDeleteConsoleAuthorizationConfiguration) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpDeleteConsoleAuthorizationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DeleteConsoleAuthorizationConfigurationInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/delete-console-authorization-configuration")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentDeleteConsoleAuthorizationConfigurationInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsDeleteConsoleAuthorizationConfigurationInput(v *DeleteConsoleAuthorizationConfigurationInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentDeleteConsoleAuthorizationConfigurationInput(v *DeleteConsoleAuthorizationConfigurationInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.TargetId != nil {
|
|
ok := object.Key("targetId")
|
|
ok.String(*v.TargetId)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpDeleteResourcePermissionStatement struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpDeleteResourcePermissionStatement) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpDeleteResourcePermissionStatement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*DeleteResourcePermissionStatementInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/delete-resource-permission-statement")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentDeleteResourcePermissionStatementInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsDeleteResourcePermissionStatementInput(v *DeleteResourcePermissionStatementInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentDeleteResourcePermissionStatementInput(v *DeleteResourcePermissionStatementInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ClientToken != nil {
|
|
ok := object.Key("clientToken")
|
|
ok.String(*v.ClientToken)
|
|
}
|
|
|
|
if v.StatementId != nil {
|
|
ok := object.Key("statementId")
|
|
ok.String(*v.StatementId)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpGetConsoleAuthorizationConfiguration struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpGetConsoleAuthorizationConfiguration) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpGetConsoleAuthorizationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*GetConsoleAuthorizationConfigurationInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/get-console-authorization-configuration")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentGetConsoleAuthorizationConfigurationInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsGetConsoleAuthorizationConfigurationInput(v *GetConsoleAuthorizationConfigurationInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentGetConsoleAuthorizationConfigurationInput(v *GetConsoleAuthorizationConfigurationInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.TargetId != nil {
|
|
ok := object.Key("targetId")
|
|
ok.String(*v.TargetId)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpGetResourcePolicy struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpGetResourcePolicy) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpGetResourcePolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*GetResourcePolicyInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/get-resource-policy")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsGetResourcePolicyInput(v *GetResourcePolicyInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpIntrospectOAuth2TokenWithIAM struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpIntrospectOAuth2TokenWithIAM) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpIntrospectOAuth2TokenWithIAM) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*IntrospectOAuth2TokenWithIAMInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/v1/introspect?x-amz-client-auth-method=iam")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentIntrospectOAuth2TokenWithIAMInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsIntrospectOAuth2TokenWithIAMInput(v *IntrospectOAuth2TokenWithIAMInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentIntrospectOAuth2TokenWithIAMInput(v *IntrospectOAuth2TokenWithIAMInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Token != nil {
|
|
ok := object.Key("token")
|
|
ok.String(*v.Token)
|
|
}
|
|
|
|
if v.TokenTypeHint != nil {
|
|
ok := object.Key("token_type_hint")
|
|
ok.String(*v.TokenTypeHint)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpListResourcePermissionStatements struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpListResourcePermissionStatements) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpListResourcePermissionStatements) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*ListResourcePermissionStatementsInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/list-resource-permission-statements")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentListResourcePermissionStatementsInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsListResourcePermissionStatementsInput(v *ListResourcePermissionStatementsInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentListResourcePermissionStatementsInput(v *ListResourcePermissionStatementsInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.MaxResults != nil {
|
|
ok := object.Key("maxResults")
|
|
ok.Integer(*v.MaxResults)
|
|
}
|
|
|
|
if v.NextToken != nil {
|
|
ok := object.Key("nextToken")
|
|
ok.String(*v.NextToken)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpPutConsoleAuthorizationConfiguration struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpPutConsoleAuthorizationConfiguration) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpPutConsoleAuthorizationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*PutConsoleAuthorizationConfigurationInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/put-console-authorization-configuration")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentPutConsoleAuthorizationConfigurationInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsPutConsoleAuthorizationConfigurationInput(v *PutConsoleAuthorizationConfigurationInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentPutConsoleAuthorizationConfigurationInput(v *PutConsoleAuthorizationConfigurationInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.TargetId != nil {
|
|
ok := object.Key("targetId")
|
|
ok.String(*v.TargetId)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpPutResourcePermissionStatement struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpPutResourcePermissionStatement) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpPutResourcePermissionStatement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*PutResourcePermissionStatementInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/put-resource-permission-statement")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentPutResourcePermissionStatementInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsPutResourcePermissionStatementInput(v *PutResourcePermissionStatementInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentPutResourcePermissionStatementInput(v *PutResourcePermissionStatementInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ClientToken != nil {
|
|
ok := object.Key("clientToken")
|
|
ok.String(*v.ClientToken)
|
|
}
|
|
|
|
if v.ConsoleSourceVpce != nil {
|
|
ok := object.Key("consoleSourceVpce")
|
|
ok.String(*v.ConsoleSourceVpce)
|
|
}
|
|
|
|
if v.ExcludedPrincipal != nil {
|
|
ok := object.Key("excludedPrincipal")
|
|
ok.String(*v.ExcludedPrincipal)
|
|
}
|
|
|
|
if v.RequestedRegion != nil {
|
|
ok := object.Key("requestedRegion")
|
|
ok.String(*v.RequestedRegion)
|
|
}
|
|
|
|
if v.SigninSourceVpce != nil {
|
|
ok := object.Key("signinSourceVpce")
|
|
ok.String(*v.SigninSourceVpce)
|
|
}
|
|
|
|
if v.SourceIp != nil {
|
|
ok := object.Key("sourceIp")
|
|
ok.String(*v.SourceIp)
|
|
}
|
|
|
|
if v.SourceVpc != nil {
|
|
ok := object.Key("sourceVpc")
|
|
ok.String(*v.SourceVpc)
|
|
}
|
|
|
|
if v.VpcSourceIp != nil {
|
|
ok := object.Key("vpcSourceIp")
|
|
ok.String(*v.VpcSourceIp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type awsRestjson1_serializeOpRevokeOAuth2TokenWithIAM struct {
|
|
}
|
|
|
|
func (*awsRestjson1_serializeOpRevokeOAuth2TokenWithIAM) ID() string {
|
|
return "OperationSerializer"
|
|
}
|
|
|
|
func (m *awsRestjson1_serializeOpRevokeOAuth2TokenWithIAM) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "OperationSerializer")
|
|
endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
|
|
defer endTimer()
|
|
defer span.End()
|
|
request, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
|
|
}
|
|
|
|
input, ok := in.Parameters.(*RevokeOAuth2TokenWithIAMInput)
|
|
_ = input
|
|
if !ok {
|
|
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
|
|
}
|
|
|
|
opPath, opQuery := httpbinding.SplitURI("/v1/revoke?x-amz-client-auth-method=iam")
|
|
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
|
|
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
|
|
request.Method = "POST"
|
|
var restEncoder *httpbinding.Encoder
|
|
if request.URL.RawPath == "" {
|
|
restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
|
|
} else {
|
|
request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
|
|
restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
|
|
}
|
|
|
|
if err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
restEncoder.SetHeader("Content-Type").String("application/json")
|
|
|
|
jsonEncoder := smithyjson.NewEncoder()
|
|
if err := awsRestjson1_serializeOpDocumentRevokeOAuth2TokenWithIAMInput(input, jsonEncoder.Value); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
|
|
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
|
|
return out, metadata, &smithy.SerializationError{Err: err}
|
|
}
|
|
in.Request = request
|
|
|
|
endTimer()
|
|
span.End()
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func awsRestjson1_serializeOpHttpBindingsRevokeOAuth2TokenWithIAMInput(v *RevokeOAuth2TokenWithIAMInput, encoder *httpbinding.Encoder) error {
|
|
if v == nil {
|
|
return fmt.Errorf("unsupported serialization of nil %T", v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeOpDocumentRevokeOAuth2TokenWithIAMInput(v *RevokeOAuth2TokenWithIAMInput, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.Token != nil {
|
|
ok := object.Key("token")
|
|
ok.String(*v.Token)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func awsRestjson1_serializeDocumentCreateOAuth2TokenRequestBody(v *types.CreateOAuth2TokenRequestBody, value smithyjson.Value) error {
|
|
object := value.Object()
|
|
defer object.Close()
|
|
|
|
if v.ClientId != nil {
|
|
ok := object.Key("clientId")
|
|
ok.String(*v.ClientId)
|
|
}
|
|
|
|
if v.Code != nil {
|
|
ok := object.Key("code")
|
|
ok.String(*v.Code)
|
|
}
|
|
|
|
if v.CodeVerifier != nil {
|
|
ok := object.Key("codeVerifier")
|
|
ok.String(*v.CodeVerifier)
|
|
}
|
|
|
|
if v.GrantType != nil {
|
|
ok := object.Key("grantType")
|
|
ok.String(*v.GrantType)
|
|
}
|
|
|
|
if v.RedirectUri != nil {
|
|
ok := object.Key("redirectUri")
|
|
ok.String(*v.RedirectUri)
|
|
}
|
|
|
|
if v.RefreshToken != nil {
|
|
ok := object.Key("refreshToken")
|
|
ok.String(*v.RefreshToken)
|
|
}
|
|
|
|
return nil
|
|
}
|