src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

validators.go (10058B)

      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package sts
      4 
      5 import (
      6 	"context"
      7 	"fmt"
      8 	"github.com/aws/aws-sdk-go-v2/service/sts/types"
      9 	smithy "github.com/aws/smithy-go"
     10 	"github.com/aws/smithy-go/middleware"
     11 )
     12 
     13 type validateOpAssumeRole struct {
     14 }
     15 
     16 func (*validateOpAssumeRole) ID() string {
     17 	return "OperationInputValidation"
     18 }
     19 
     20 func (m *validateOpAssumeRole) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
     21 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
     22 ) {
     23 	input, ok := in.Parameters.(*AssumeRoleInput)
     24 	if !ok {
     25 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
     26 	}
     27 	if err := validateOpAssumeRoleInput(input); err != nil {
     28 		return out, metadata, err
     29 	}
     30 	return next.HandleInitialize(ctx, in)
     31 }
     32 
     33 type validateOpAssumeRoleWithSAML struct {
     34 }
     35 
     36 func (*validateOpAssumeRoleWithSAML) ID() string {
     37 	return "OperationInputValidation"
     38 }
     39 
     40 func (m *validateOpAssumeRoleWithSAML) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
     41 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
     42 ) {
     43 	input, ok := in.Parameters.(*AssumeRoleWithSAMLInput)
     44 	if !ok {
     45 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
     46 	}
     47 	if err := validateOpAssumeRoleWithSAMLInput(input); err != nil {
     48 		return out, metadata, err
     49 	}
     50 	return next.HandleInitialize(ctx, in)
     51 }
     52 
     53 type validateOpAssumeRoleWithWebIdentity struct {
     54 }
     55 
     56 func (*validateOpAssumeRoleWithWebIdentity) ID() string {
     57 	return "OperationInputValidation"
     58 }
     59 
     60 func (m *validateOpAssumeRoleWithWebIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
     61 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
     62 ) {
     63 	input, ok := in.Parameters.(*AssumeRoleWithWebIdentityInput)
     64 	if !ok {
     65 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
     66 	}
     67 	if err := validateOpAssumeRoleWithWebIdentityInput(input); err != nil {
     68 		return out, metadata, err
     69 	}
     70 	return next.HandleInitialize(ctx, in)
     71 }
     72 
     73 type validateOpAssumeRoot struct {
     74 }
     75 
     76 func (*validateOpAssumeRoot) ID() string {
     77 	return "OperationInputValidation"
     78 }
     79 
     80 func (m *validateOpAssumeRoot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
     81 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
     82 ) {
     83 	input, ok := in.Parameters.(*AssumeRootInput)
     84 	if !ok {
     85 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
     86 	}
     87 	if err := validateOpAssumeRootInput(input); err != nil {
     88 		return out, metadata, err
     89 	}
     90 	return next.HandleInitialize(ctx, in)
     91 }
     92 
     93 type validateOpDecodeAuthorizationMessage struct {
     94 }
     95 
     96 func (*validateOpDecodeAuthorizationMessage) ID() string {
     97 	return "OperationInputValidation"
     98 }
     99 
    100 func (m *validateOpDecodeAuthorizationMessage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    101 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
    102 ) {
    103 	input, ok := in.Parameters.(*DecodeAuthorizationMessageInput)
    104 	if !ok {
    105 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
    106 	}
    107 	if err := validateOpDecodeAuthorizationMessageInput(input); err != nil {
    108 		return out, metadata, err
    109 	}
    110 	return next.HandleInitialize(ctx, in)
    111 }
    112 
    113 type validateOpGetAccessKeyInfo struct {
    114 }
    115 
    116 func (*validateOpGetAccessKeyInfo) ID() string {
    117 	return "OperationInputValidation"
    118 }
    119 
    120 func (m *validateOpGetAccessKeyInfo) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    121 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
    122 ) {
    123 	input, ok := in.Parameters.(*GetAccessKeyInfoInput)
    124 	if !ok {
    125 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
    126 	}
    127 	if err := validateOpGetAccessKeyInfoInput(input); err != nil {
    128 		return out, metadata, err
    129 	}
    130 	return next.HandleInitialize(ctx, in)
    131 }
    132 
    133 type validateOpGetFederationToken struct {
    134 }
    135 
    136 func (*validateOpGetFederationToken) ID() string {
    137 	return "OperationInputValidation"
    138 }
    139 
    140 func (m *validateOpGetFederationToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    141 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
    142 ) {
    143 	input, ok := in.Parameters.(*GetFederationTokenInput)
    144 	if !ok {
    145 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
    146 	}
    147 	if err := validateOpGetFederationTokenInput(input); err != nil {
    148 		return out, metadata, err
    149 	}
    150 	return next.HandleInitialize(ctx, in)
    151 }
    152 
    153 func addOpAssumeRoleValidationMiddleware(stack *middleware.Stack) error {
    154 	return stack.Initialize.Add(&validateOpAssumeRole{}, middleware.After)
    155 }
    156 
    157 func addOpAssumeRoleWithSAMLValidationMiddleware(stack *middleware.Stack) error {
    158 	return stack.Initialize.Add(&validateOpAssumeRoleWithSAML{}, middleware.After)
    159 }
    160 
    161 func addOpAssumeRoleWithWebIdentityValidationMiddleware(stack *middleware.Stack) error {
    162 	return stack.Initialize.Add(&validateOpAssumeRoleWithWebIdentity{}, middleware.After)
    163 }
    164 
    165 func addOpAssumeRootValidationMiddleware(stack *middleware.Stack) error {
    166 	return stack.Initialize.Add(&validateOpAssumeRoot{}, middleware.After)
    167 }
    168 
    169 func addOpDecodeAuthorizationMessageValidationMiddleware(stack *middleware.Stack) error {
    170 	return stack.Initialize.Add(&validateOpDecodeAuthorizationMessage{}, middleware.After)
    171 }
    172 
    173 func addOpGetAccessKeyInfoValidationMiddleware(stack *middleware.Stack) error {
    174 	return stack.Initialize.Add(&validateOpGetAccessKeyInfo{}, middleware.After)
    175 }
    176 
    177 func addOpGetFederationTokenValidationMiddleware(stack *middleware.Stack) error {
    178 	return stack.Initialize.Add(&validateOpGetFederationToken{}, middleware.After)
    179 }
    180 
    181 func validateTag(v *types.Tag) error {
    182 	if v == nil {
    183 		return nil
    184 	}
    185 	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
    186 	if v.Key == nil {
    187 		invalidParams.Add(smithy.NewErrParamRequired("Key"))
    188 	}
    189 	if v.Value == nil {
    190 		invalidParams.Add(smithy.NewErrParamRequired("Value"))
    191 	}
    192 	if invalidParams.Len() > 0 {
    193 		return invalidParams
    194 	} else {
    195 		return nil
    196 	}
    197 }
    198 
    199 func validateTagListType(v []types.Tag) error {
    200 	if v == nil {
    201 		return nil
    202 	}
    203 	invalidParams := smithy.InvalidParamsError{Context: "TagListType"}
    204 	for i := range v {
    205 		if err := validateTag(&v[i]); err != nil {
    206 			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
    207 		}
    208 	}
    209 	if invalidParams.Len() > 0 {
    210 		return invalidParams
    211 	} else {
    212 		return nil
    213 	}
    214 }
    215 
    216 func validateOpAssumeRoleInput(v *AssumeRoleInput) error {
    217 	if v == nil {
    218 		return nil
    219 	}
    220 	invalidParams := smithy.InvalidParamsError{Context: "AssumeRoleInput"}
    221 	if v.RoleArn == nil {
    222 		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
    223 	}
    224 	if v.RoleSessionName == nil {
    225 		invalidParams.Add(smithy.NewErrParamRequired("RoleSessionName"))
    226 	}
    227 	if v.Tags != nil {
    228 		if err := validateTagListType(v.Tags); err != nil {
    229 			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
    230 		}
    231 	}
    232 	if invalidParams.Len() > 0 {
    233 		return invalidParams
    234 	} else {
    235 		return nil
    236 	}
    237 }
    238 
    239 func validateOpAssumeRoleWithSAMLInput(v *AssumeRoleWithSAMLInput) error {
    240 	if v == nil {
    241 		return nil
    242 	}
    243 	invalidParams := smithy.InvalidParamsError{Context: "AssumeRoleWithSAMLInput"}
    244 	if v.RoleArn == nil {
    245 		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
    246 	}
    247 	if v.PrincipalArn == nil {
    248 		invalidParams.Add(smithy.NewErrParamRequired("PrincipalArn"))
    249 	}
    250 	if v.SAMLAssertion == nil {
    251 		invalidParams.Add(smithy.NewErrParamRequired("SAMLAssertion"))
    252 	}
    253 	if invalidParams.Len() > 0 {
    254 		return invalidParams
    255 	} else {
    256 		return nil
    257 	}
    258 }
    259 
    260 func validateOpAssumeRoleWithWebIdentityInput(v *AssumeRoleWithWebIdentityInput) error {
    261 	if v == nil {
    262 		return nil
    263 	}
    264 	invalidParams := smithy.InvalidParamsError{Context: "AssumeRoleWithWebIdentityInput"}
    265 	if v.RoleArn == nil {
    266 		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
    267 	}
    268 	if v.RoleSessionName == nil {
    269 		invalidParams.Add(smithy.NewErrParamRequired("RoleSessionName"))
    270 	}
    271 	if v.WebIdentityToken == nil {
    272 		invalidParams.Add(smithy.NewErrParamRequired("WebIdentityToken"))
    273 	}
    274 	if invalidParams.Len() > 0 {
    275 		return invalidParams
    276 	} else {
    277 		return nil
    278 	}
    279 }
    280 
    281 func validateOpAssumeRootInput(v *AssumeRootInput) error {
    282 	if v == nil {
    283 		return nil
    284 	}
    285 	invalidParams := smithy.InvalidParamsError{Context: "AssumeRootInput"}
    286 	if v.TargetPrincipal == nil {
    287 		invalidParams.Add(smithy.NewErrParamRequired("TargetPrincipal"))
    288 	}
    289 	if v.TaskPolicyArn == nil {
    290 		invalidParams.Add(smithy.NewErrParamRequired("TaskPolicyArn"))
    291 	}
    292 	if invalidParams.Len() > 0 {
    293 		return invalidParams
    294 	} else {
    295 		return nil
    296 	}
    297 }
    298 
    299 func validateOpDecodeAuthorizationMessageInput(v *DecodeAuthorizationMessageInput) error {
    300 	if v == nil {
    301 		return nil
    302 	}
    303 	invalidParams := smithy.InvalidParamsError{Context: "DecodeAuthorizationMessageInput"}
    304 	if v.EncodedMessage == nil {
    305 		invalidParams.Add(smithy.NewErrParamRequired("EncodedMessage"))
    306 	}
    307 	if invalidParams.Len() > 0 {
    308 		return invalidParams
    309 	} else {
    310 		return nil
    311 	}
    312 }
    313 
    314 func validateOpGetAccessKeyInfoInput(v *GetAccessKeyInfoInput) error {
    315 	if v == nil {
    316 		return nil
    317 	}
    318 	invalidParams := smithy.InvalidParamsError{Context: "GetAccessKeyInfoInput"}
    319 	if v.AccessKeyId == nil {
    320 		invalidParams.Add(smithy.NewErrParamRequired("AccessKeyId"))
    321 	}
    322 	if invalidParams.Len() > 0 {
    323 		return invalidParams
    324 	} else {
    325 		return nil
    326 	}
    327 }
    328 
    329 func validateOpGetFederationTokenInput(v *GetFederationTokenInput) error {
    330 	if v == nil {
    331 		return nil
    332 	}
    333 	invalidParams := smithy.InvalidParamsError{Context: "GetFederationTokenInput"}
    334 	if v.Name == nil {
    335 		invalidParams.Add(smithy.NewErrParamRequired("Name"))
    336 	}
    337 	if v.Tags != nil {
    338 		if err := validateTagListType(v.Tags); err != nil {
    339 			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
    340 		}
    341 	}
    342 	if invalidParams.Len() > 0 {
    343 		return invalidParams
    344 	} else {
    345 		return nil
    346 	}
    347 }