src

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

validators.go (12723B)

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