1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package codestarconnections 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/codestarconnections/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCreateConnection struct { 14} 15 16func (*validateOpCreateConnection) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCreateConnection) 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.(*CreateConnectionInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCreateConnectionInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateHost struct { 34} 35 36func (*validateOpCreateHost) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateHost) 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.(*CreateHostInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateHostInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpDeleteConnection struct { 54} 55 56func (*validateOpDeleteConnection) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpDeleteConnection) 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.(*DeleteConnectionInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpDeleteConnectionInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpDeleteHost struct { 74} 75 76func (*validateOpDeleteHost) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpDeleteHost) 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.(*DeleteHostInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpDeleteHostInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpGetConnection struct { 94} 95 96func (*validateOpGetConnection) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpGetConnection) 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.(*GetConnectionInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpGetConnectionInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpGetHost struct { 114} 115 116func (*validateOpGetHost) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpGetHost) 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.(*GetHostInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpGetHostInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpListTagsForResource struct { 134} 135 136func (*validateOpListTagsForResource) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpListTagsForResourceInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpTagResource struct { 154} 155 156func (*validateOpTagResource) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 162) { 163 input, ok := in.Parameters.(*TagResourceInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpTagResourceInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpUntagResource struct { 174} 175 176func (*validateOpUntagResource) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 182) { 183 input, ok := in.Parameters.(*UntagResourceInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpUntagResourceInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpUpdateHost struct { 194} 195 196func (*validateOpUpdateHost) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpUpdateHost) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 202) { 203 input, ok := in.Parameters.(*UpdateHostInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpUpdateHostInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213func addOpCreateConnectionValidationMiddleware(stack *middleware.Stack) error { 214 return stack.Initialize.Add(&validateOpCreateConnection{}, middleware.After) 215} 216 217func addOpCreateHostValidationMiddleware(stack *middleware.Stack) error { 218 return stack.Initialize.Add(&validateOpCreateHost{}, middleware.After) 219} 220 221func addOpDeleteConnectionValidationMiddleware(stack *middleware.Stack) error { 222 return stack.Initialize.Add(&validateOpDeleteConnection{}, middleware.After) 223} 224 225func addOpDeleteHostValidationMiddleware(stack *middleware.Stack) error { 226 return stack.Initialize.Add(&validateOpDeleteHost{}, middleware.After) 227} 228 229func addOpGetConnectionValidationMiddleware(stack *middleware.Stack) error { 230 return stack.Initialize.Add(&validateOpGetConnection{}, middleware.After) 231} 232 233func addOpGetHostValidationMiddleware(stack *middleware.Stack) error { 234 return stack.Initialize.Add(&validateOpGetHost{}, middleware.After) 235} 236 237func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 238 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 239} 240 241func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 242 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 243} 244 245func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 246 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 247} 248 249func addOpUpdateHostValidationMiddleware(stack *middleware.Stack) error { 250 return stack.Initialize.Add(&validateOpUpdateHost{}, middleware.After) 251} 252 253func validateTag(v *types.Tag) error { 254 if v == nil { 255 return nil 256 } 257 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 258 if v.Key == nil { 259 invalidParams.Add(smithy.NewErrParamRequired("Key")) 260 } 261 if v.Value == nil { 262 invalidParams.Add(smithy.NewErrParamRequired("Value")) 263 } 264 if invalidParams.Len() > 0 { 265 return invalidParams 266 } else { 267 return nil 268 } 269} 270 271func validateTagList(v []types.Tag) error { 272 if v == nil { 273 return nil 274 } 275 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 276 for i := range v { 277 if err := validateTag(&v[i]); err != nil { 278 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 279 } 280 } 281 if invalidParams.Len() > 0 { 282 return invalidParams 283 } else { 284 return nil 285 } 286} 287 288func validateVpcConfiguration(v *types.VpcConfiguration) error { 289 if v == nil { 290 return nil 291 } 292 invalidParams := smithy.InvalidParamsError{Context: "VpcConfiguration"} 293 if v.VpcId == nil { 294 invalidParams.Add(smithy.NewErrParamRequired("VpcId")) 295 } 296 if v.SubnetIds == nil { 297 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 298 } 299 if v.SecurityGroupIds == nil { 300 invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds")) 301 } 302 if invalidParams.Len() > 0 { 303 return invalidParams 304 } else { 305 return nil 306 } 307} 308 309func validateOpCreateConnectionInput(v *CreateConnectionInput) error { 310 if v == nil { 311 return nil 312 } 313 invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"} 314 if v.ConnectionName == nil { 315 invalidParams.Add(smithy.NewErrParamRequired("ConnectionName")) 316 } 317 if v.Tags != nil { 318 if err := validateTagList(v.Tags); err != nil { 319 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 320 } 321 } 322 if invalidParams.Len() > 0 { 323 return invalidParams 324 } else { 325 return nil 326 } 327} 328 329func validateOpCreateHostInput(v *CreateHostInput) error { 330 if v == nil { 331 return nil 332 } 333 invalidParams := smithy.InvalidParamsError{Context: "CreateHostInput"} 334 if v.Name == nil { 335 invalidParams.Add(smithy.NewErrParamRequired("Name")) 336 } 337 if len(v.ProviderType) == 0 { 338 invalidParams.Add(smithy.NewErrParamRequired("ProviderType")) 339 } 340 if v.ProviderEndpoint == nil { 341 invalidParams.Add(smithy.NewErrParamRequired("ProviderEndpoint")) 342 } 343 if v.VpcConfiguration != nil { 344 if err := validateVpcConfiguration(v.VpcConfiguration); err != nil { 345 invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError)) 346 } 347 } 348 if invalidParams.Len() > 0 { 349 return invalidParams 350 } else { 351 return nil 352 } 353} 354 355func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error { 356 if v == nil { 357 return nil 358 } 359 invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"} 360 if v.ConnectionArn == nil { 361 invalidParams.Add(smithy.NewErrParamRequired("ConnectionArn")) 362 } 363 if invalidParams.Len() > 0 { 364 return invalidParams 365 } else { 366 return nil 367 } 368} 369 370func validateOpDeleteHostInput(v *DeleteHostInput) error { 371 if v == nil { 372 return nil 373 } 374 invalidParams := smithy.InvalidParamsError{Context: "DeleteHostInput"} 375 if v.HostArn == nil { 376 invalidParams.Add(smithy.NewErrParamRequired("HostArn")) 377 } 378 if invalidParams.Len() > 0 { 379 return invalidParams 380 } else { 381 return nil 382 } 383} 384 385func validateOpGetConnectionInput(v *GetConnectionInput) error { 386 if v == nil { 387 return nil 388 } 389 invalidParams := smithy.InvalidParamsError{Context: "GetConnectionInput"} 390 if v.ConnectionArn == nil { 391 invalidParams.Add(smithy.NewErrParamRequired("ConnectionArn")) 392 } 393 if invalidParams.Len() > 0 { 394 return invalidParams 395 } else { 396 return nil 397 } 398} 399 400func validateOpGetHostInput(v *GetHostInput) error { 401 if v == nil { 402 return nil 403 } 404 invalidParams := smithy.InvalidParamsError{Context: "GetHostInput"} 405 if v.HostArn == nil { 406 invalidParams.Add(smithy.NewErrParamRequired("HostArn")) 407 } 408 if invalidParams.Len() > 0 { 409 return invalidParams 410 } else { 411 return nil 412 } 413} 414 415func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 416 if v == nil { 417 return nil 418 } 419 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 420 if v.ResourceArn == nil { 421 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 422 } 423 if invalidParams.Len() > 0 { 424 return invalidParams 425 } else { 426 return nil 427 } 428} 429 430func validateOpTagResourceInput(v *TagResourceInput) error { 431 if v == nil { 432 return nil 433 } 434 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 435 if v.ResourceArn == nil { 436 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 437 } 438 if v.Tags == nil { 439 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 440 } else if v.Tags != nil { 441 if err := validateTagList(v.Tags); err != nil { 442 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 443 } 444 } 445 if invalidParams.Len() > 0 { 446 return invalidParams 447 } else { 448 return nil 449 } 450} 451 452func validateOpUntagResourceInput(v *UntagResourceInput) error { 453 if v == nil { 454 return nil 455 } 456 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 457 if v.ResourceArn == nil { 458 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 459 } 460 if v.TagKeys == nil { 461 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 462 } 463 if invalidParams.Len() > 0 { 464 return invalidParams 465 } else { 466 return nil 467 } 468} 469 470func validateOpUpdateHostInput(v *UpdateHostInput) error { 471 if v == nil { 472 return nil 473 } 474 invalidParams := smithy.InvalidParamsError{Context: "UpdateHostInput"} 475 if v.HostArn == nil { 476 invalidParams.Add(smithy.NewErrParamRequired("HostArn")) 477 } 478 if v.VpcConfiguration != nil { 479 if err := validateVpcConfiguration(v.VpcConfiguration); err != nil { 480 invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError)) 481 } 482 } 483 if invalidParams.Len() > 0 { 484 return invalidParams 485 } else { 486 return nil 487 } 488} 489