github.com/aavshr/aws-sdk-go@v1.41.3/service/route53recoverycontrolconfig/api.go (about)

     1  // Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
     2  
     3  package route53recoverycontrolconfig
     4  
     5  import (
     6  	"fmt"
     7  
     8  	"github.com/aavshr/aws-sdk-go/aws"
     9  	"github.com/aavshr/aws-sdk-go/aws/awsutil"
    10  	"github.com/aavshr/aws-sdk-go/aws/request"
    11  	"github.com/aavshr/aws-sdk-go/private/protocol"
    12  	"github.com/aavshr/aws-sdk-go/private/protocol/restjson"
    13  )
    14  
    15  const opCreateCluster = "CreateCluster"
    16  
    17  // CreateClusterRequest generates a "aws/request.Request" representing the
    18  // client's request for the CreateCluster operation. The "output" return
    19  // value will be populated with the request's response once the request completes
    20  // successfully.
    21  //
    22  // Use "Send" method on the returned Request to send the API call to the service.
    23  // the "output" return value is not valid until after Send returns without error.
    24  //
    25  // See CreateCluster for more information on using the CreateCluster
    26  // API call, and error handling.
    27  //
    28  // This method is useful when you want to inject custom logic or configuration
    29  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
    30  //
    31  //
    32  //    // Example sending a request using the CreateClusterRequest method.
    33  //    req, resp := client.CreateClusterRequest(params)
    34  //
    35  //    err := req.Send()
    36  //    if err == nil { // resp is now filled
    37  //        fmt.Println(resp)
    38  //    }
    39  //
    40  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateCluster
    41  func (c *Route53RecoveryControlConfig) CreateClusterRequest(input *CreateClusterInput) (req *request.Request, output *CreateClusterOutput) {
    42  	op := &request.Operation{
    43  		Name:       opCreateCluster,
    44  		HTTPMethod: "POST",
    45  		HTTPPath:   "/cluster",
    46  	}
    47  
    48  	if input == nil {
    49  		input = &CreateClusterInput{}
    50  	}
    51  
    52  	output = &CreateClusterOutput{}
    53  	req = c.newRequest(op, input, output)
    54  	return
    55  }
    56  
    57  // CreateCluster API operation for AWS Route53 Recovery Control Config.
    58  //
    59  // Create a new cluster. A cluster is a set of redundant Regional endpoints
    60  // against which you can run API calls to update or get the state of one or
    61  // more routing controls. Each cluster has a name, status, Amazon Resource Name
    62  // (ARN), and an array of the five cluster endpoints (one for each supported
    63  // Amazon Web Services Region) that you can use with API calls to the Amazon
    64  // Route 53 Application Recovery Controller cluster data plane.
    65  //
    66  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
    67  // with awserr.Error's Code and Message methods to get detailed information about
    68  // the error.
    69  //
    70  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
    71  // API operation CreateCluster for usage and error information.
    72  //
    73  // Returned Error Types:
    74  //   * ValidationException
    75  //   400 response - Multiple causes. For example, you might have a malformed query
    76  //   string and input parameter might be out of range, or you used parameters
    77  //   together incorrectly.
    78  //
    79  //   * InternalServerException
    80  //   500 response - InternalServiceError. Temporary service error. Retry the request.
    81  //
    82  //   * ServiceQuotaExceededException
    83  //   402 response
    84  //
    85  //   * AccessDeniedException
    86  //   403 response - AccessDeniedException. You do not have sufficient access to
    87  //   perform this action.
    88  //
    89  //   * ResourceNotFoundException
    90  //   404 response - The query string contains a syntax error or resource not found.
    91  //
    92  //   * ThrottlingException
    93  //   429 response - ThrottlingException.
    94  //
    95  //   * ConflictException
    96  //   409 response - ConflictException.
    97  //
    98  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateCluster
    99  func (c *Route53RecoveryControlConfig) CreateCluster(input *CreateClusterInput) (*CreateClusterOutput, error) {
   100  	req, out := c.CreateClusterRequest(input)
   101  	return out, req.Send()
   102  }
   103  
   104  // CreateClusterWithContext is the same as CreateCluster with the addition of
   105  // the ability to pass a context and additional request options.
   106  //
   107  // See CreateCluster for details on how to use this API operation.
   108  //
   109  // The context must be non-nil and will be used for request cancellation. If
   110  // the context is nil a panic will occur. In the future the SDK may create
   111  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   112  // for more information on using Contexts.
   113  func (c *Route53RecoveryControlConfig) CreateClusterWithContext(ctx aws.Context, input *CreateClusterInput, opts ...request.Option) (*CreateClusterOutput, error) {
   114  	req, out := c.CreateClusterRequest(input)
   115  	req.SetContext(ctx)
   116  	req.ApplyOptions(opts...)
   117  	return out, req.Send()
   118  }
   119  
   120  const opCreateControlPanel = "CreateControlPanel"
   121  
   122  // CreateControlPanelRequest generates a "aws/request.Request" representing the
   123  // client's request for the CreateControlPanel operation. The "output" return
   124  // value will be populated with the request's response once the request completes
   125  // successfully.
   126  //
   127  // Use "Send" method on the returned Request to send the API call to the service.
   128  // the "output" return value is not valid until after Send returns without error.
   129  //
   130  // See CreateControlPanel for more information on using the CreateControlPanel
   131  // API call, and error handling.
   132  //
   133  // This method is useful when you want to inject custom logic or configuration
   134  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   135  //
   136  //
   137  //    // Example sending a request using the CreateControlPanelRequest method.
   138  //    req, resp := client.CreateControlPanelRequest(params)
   139  //
   140  //    err := req.Send()
   141  //    if err == nil { // resp is now filled
   142  //        fmt.Println(resp)
   143  //    }
   144  //
   145  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateControlPanel
   146  func (c *Route53RecoveryControlConfig) CreateControlPanelRequest(input *CreateControlPanelInput) (req *request.Request, output *CreateControlPanelOutput) {
   147  	op := &request.Operation{
   148  		Name:       opCreateControlPanel,
   149  		HTTPMethod: "POST",
   150  		HTTPPath:   "/controlpanel",
   151  	}
   152  
   153  	if input == nil {
   154  		input = &CreateControlPanelInput{}
   155  	}
   156  
   157  	output = &CreateControlPanelOutput{}
   158  	req = c.newRequest(op, input, output)
   159  	return
   160  }
   161  
   162  // CreateControlPanel API operation for AWS Route53 Recovery Control Config.
   163  //
   164  // Creates a new control panel. A control panel represents a group of routing
   165  // controls that can be changed together in a single transaction. You can use
   166  // a control panel to centrally view the operational status of applications
   167  // across your organization, and trigger multi-app failovers in a single transaction,
   168  // for example, to fail over an Availability Zone or AWS Region.
   169  //
   170  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   171  // with awserr.Error's Code and Message methods to get detailed information about
   172  // the error.
   173  //
   174  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   175  // API operation CreateControlPanel for usage and error information.
   176  //
   177  // Returned Error Types:
   178  //   * ValidationException
   179  //   400 response - Multiple causes. For example, you might have a malformed query
   180  //   string and input parameter might be out of range, or you used parameters
   181  //   together incorrectly.
   182  //
   183  //   * InternalServerException
   184  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   185  //
   186  //   * ServiceQuotaExceededException
   187  //   402 response
   188  //
   189  //   * AccessDeniedException
   190  //   403 response - AccessDeniedException. You do not have sufficient access to
   191  //   perform this action.
   192  //
   193  //   * ResourceNotFoundException
   194  //   404 response - The query string contains a syntax error or resource not found.
   195  //
   196  //   * ThrottlingException
   197  //   429 response - ThrottlingException.
   198  //
   199  //   * ConflictException
   200  //   409 response - ConflictException.
   201  //
   202  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateControlPanel
   203  func (c *Route53RecoveryControlConfig) CreateControlPanel(input *CreateControlPanelInput) (*CreateControlPanelOutput, error) {
   204  	req, out := c.CreateControlPanelRequest(input)
   205  	return out, req.Send()
   206  }
   207  
   208  // CreateControlPanelWithContext is the same as CreateControlPanel with the addition of
   209  // the ability to pass a context and additional request options.
   210  //
   211  // See CreateControlPanel for details on how to use this API operation.
   212  //
   213  // The context must be non-nil and will be used for request cancellation. If
   214  // the context is nil a panic will occur. In the future the SDK may create
   215  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   216  // for more information on using Contexts.
   217  func (c *Route53RecoveryControlConfig) CreateControlPanelWithContext(ctx aws.Context, input *CreateControlPanelInput, opts ...request.Option) (*CreateControlPanelOutput, error) {
   218  	req, out := c.CreateControlPanelRequest(input)
   219  	req.SetContext(ctx)
   220  	req.ApplyOptions(opts...)
   221  	return out, req.Send()
   222  }
   223  
   224  const opCreateRoutingControl = "CreateRoutingControl"
   225  
   226  // CreateRoutingControlRequest generates a "aws/request.Request" representing the
   227  // client's request for the CreateRoutingControl operation. The "output" return
   228  // value will be populated with the request's response once the request completes
   229  // successfully.
   230  //
   231  // Use "Send" method on the returned Request to send the API call to the service.
   232  // the "output" return value is not valid until after Send returns without error.
   233  //
   234  // See CreateRoutingControl for more information on using the CreateRoutingControl
   235  // API call, and error handling.
   236  //
   237  // This method is useful when you want to inject custom logic or configuration
   238  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   239  //
   240  //
   241  //    // Example sending a request using the CreateRoutingControlRequest method.
   242  //    req, resp := client.CreateRoutingControlRequest(params)
   243  //
   244  //    err := req.Send()
   245  //    if err == nil { // resp is now filled
   246  //        fmt.Println(resp)
   247  //    }
   248  //
   249  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateRoutingControl
   250  func (c *Route53RecoveryControlConfig) CreateRoutingControlRequest(input *CreateRoutingControlInput) (req *request.Request, output *CreateRoutingControlOutput) {
   251  	op := &request.Operation{
   252  		Name:       opCreateRoutingControl,
   253  		HTTPMethod: "POST",
   254  		HTTPPath:   "/routingcontrol",
   255  	}
   256  
   257  	if input == nil {
   258  		input = &CreateRoutingControlInput{}
   259  	}
   260  
   261  	output = &CreateRoutingControlOutput{}
   262  	req = c.newRequest(op, input, output)
   263  	return
   264  }
   265  
   266  // CreateRoutingControl API operation for AWS Route53 Recovery Control Config.
   267  //
   268  // Creates a new routing control.
   269  //
   270  // A routing control has one of two states: ON and OFF. You can map the routing
   271  // control state to the state of an Amazon Route 53 health check, which can
   272  // be used to control traffic routing.
   273  //
   274  // To get or update the routing control state, see the Recovery Cluster (data
   275  // plane) API actions for Amazon Route 53 Application Recovery Controller.
   276  //
   277  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   278  // with awserr.Error's Code and Message methods to get detailed information about
   279  // the error.
   280  //
   281  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   282  // API operation CreateRoutingControl for usage and error information.
   283  //
   284  // Returned Error Types:
   285  //   * ValidationException
   286  //   400 response - Multiple causes. For example, you might have a malformed query
   287  //   string and input parameter might be out of range, or you used parameters
   288  //   together incorrectly.
   289  //
   290  //   * InternalServerException
   291  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   292  //
   293  //   * ServiceQuotaExceededException
   294  //   402 response
   295  //
   296  //   * AccessDeniedException
   297  //   403 response - AccessDeniedException. You do not have sufficient access to
   298  //   perform this action.
   299  //
   300  //   * ResourceNotFoundException
   301  //   404 response - The query string contains a syntax error or resource not found.
   302  //
   303  //   * ThrottlingException
   304  //   429 response - ThrottlingException.
   305  //
   306  //   * ConflictException
   307  //   409 response - ConflictException.
   308  //
   309  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateRoutingControl
   310  func (c *Route53RecoveryControlConfig) CreateRoutingControl(input *CreateRoutingControlInput) (*CreateRoutingControlOutput, error) {
   311  	req, out := c.CreateRoutingControlRequest(input)
   312  	return out, req.Send()
   313  }
   314  
   315  // CreateRoutingControlWithContext is the same as CreateRoutingControl with the addition of
   316  // the ability to pass a context and additional request options.
   317  //
   318  // See CreateRoutingControl for details on how to use this API operation.
   319  //
   320  // The context must be non-nil and will be used for request cancellation. If
   321  // the context is nil a panic will occur. In the future the SDK may create
   322  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   323  // for more information on using Contexts.
   324  func (c *Route53RecoveryControlConfig) CreateRoutingControlWithContext(ctx aws.Context, input *CreateRoutingControlInput, opts ...request.Option) (*CreateRoutingControlOutput, error) {
   325  	req, out := c.CreateRoutingControlRequest(input)
   326  	req.SetContext(ctx)
   327  	req.ApplyOptions(opts...)
   328  	return out, req.Send()
   329  }
   330  
   331  const opCreateSafetyRule = "CreateSafetyRule"
   332  
   333  // CreateSafetyRuleRequest generates a "aws/request.Request" representing the
   334  // client's request for the CreateSafetyRule operation. The "output" return
   335  // value will be populated with the request's response once the request completes
   336  // successfully.
   337  //
   338  // Use "Send" method on the returned Request to send the API call to the service.
   339  // the "output" return value is not valid until after Send returns without error.
   340  //
   341  // See CreateSafetyRule for more information on using the CreateSafetyRule
   342  // API call, and error handling.
   343  //
   344  // This method is useful when you want to inject custom logic or configuration
   345  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   346  //
   347  //
   348  //    // Example sending a request using the CreateSafetyRuleRequest method.
   349  //    req, resp := client.CreateSafetyRuleRequest(params)
   350  //
   351  //    err := req.Send()
   352  //    if err == nil { // resp is now filled
   353  //        fmt.Println(resp)
   354  //    }
   355  //
   356  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateSafetyRule
   357  func (c *Route53RecoveryControlConfig) CreateSafetyRuleRequest(input *CreateSafetyRuleInput) (req *request.Request, output *CreateSafetyRuleOutput) {
   358  	op := &request.Operation{
   359  		Name:       opCreateSafetyRule,
   360  		HTTPMethod: "POST",
   361  		HTTPPath:   "/safetyrule",
   362  	}
   363  
   364  	if input == nil {
   365  		input = &CreateSafetyRuleInput{}
   366  	}
   367  
   368  	output = &CreateSafetyRuleOutput{}
   369  	req = c.newRequest(op, input, output)
   370  	return
   371  }
   372  
   373  // CreateSafetyRule API operation for AWS Route53 Recovery Control Config.
   374  //
   375  // Creates a safety rule in a control panel. Safety rules let you add safeguards
   376  // around enabling and disabling routing controls, to help prevent unexpected
   377  // outcomes.
   378  //
   379  // There are two types of safety rules: assertion rules and gating rules.
   380  //
   381  // Assertion rule: An assertion rule enforces that, when a routing control state
   382  // is changed, the criteria set by the rule configuration is met. Otherwise,
   383  // the change to the routing control is not accepted.
   384  //
   385  // Gating rule: A gating rule verifies that a set of gating controls evaluates
   386  // as true, based on a rule configuration that you specify. If the gating rule
   387  // evaluates to true, Amazon Route 53 Application Recovery Controller allows
   388  // a set of routing control state changes to run and complete against the set
   389  // of target controls.
   390  //
   391  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   392  // with awserr.Error's Code and Message methods to get detailed information about
   393  // the error.
   394  //
   395  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   396  // API operation CreateSafetyRule for usage and error information.
   397  //
   398  // Returned Error Types:
   399  //   * ValidationException
   400  //   400 response - Multiple causes. For example, you might have a malformed query
   401  //   string and input parameter might be out of range, or you used parameters
   402  //   together incorrectly.
   403  //
   404  //   * InternalServerException
   405  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   406  //
   407  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/CreateSafetyRule
   408  func (c *Route53RecoveryControlConfig) CreateSafetyRule(input *CreateSafetyRuleInput) (*CreateSafetyRuleOutput, error) {
   409  	req, out := c.CreateSafetyRuleRequest(input)
   410  	return out, req.Send()
   411  }
   412  
   413  // CreateSafetyRuleWithContext is the same as CreateSafetyRule with the addition of
   414  // the ability to pass a context and additional request options.
   415  //
   416  // See CreateSafetyRule for details on how to use this API operation.
   417  //
   418  // The context must be non-nil and will be used for request cancellation. If
   419  // the context is nil a panic will occur. In the future the SDK may create
   420  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   421  // for more information on using Contexts.
   422  func (c *Route53RecoveryControlConfig) CreateSafetyRuleWithContext(ctx aws.Context, input *CreateSafetyRuleInput, opts ...request.Option) (*CreateSafetyRuleOutput, error) {
   423  	req, out := c.CreateSafetyRuleRequest(input)
   424  	req.SetContext(ctx)
   425  	req.ApplyOptions(opts...)
   426  	return out, req.Send()
   427  }
   428  
   429  const opDeleteCluster = "DeleteCluster"
   430  
   431  // DeleteClusterRequest generates a "aws/request.Request" representing the
   432  // client's request for the DeleteCluster operation. The "output" return
   433  // value will be populated with the request's response once the request completes
   434  // successfully.
   435  //
   436  // Use "Send" method on the returned Request to send the API call to the service.
   437  // the "output" return value is not valid until after Send returns without error.
   438  //
   439  // See DeleteCluster for more information on using the DeleteCluster
   440  // API call, and error handling.
   441  //
   442  // This method is useful when you want to inject custom logic or configuration
   443  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   444  //
   445  //
   446  //    // Example sending a request using the DeleteClusterRequest method.
   447  //    req, resp := client.DeleteClusterRequest(params)
   448  //
   449  //    err := req.Send()
   450  //    if err == nil { // resp is now filled
   451  //        fmt.Println(resp)
   452  //    }
   453  //
   454  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteCluster
   455  func (c *Route53RecoveryControlConfig) DeleteClusterRequest(input *DeleteClusterInput) (req *request.Request, output *DeleteClusterOutput) {
   456  	op := &request.Operation{
   457  		Name:       opDeleteCluster,
   458  		HTTPMethod: "DELETE",
   459  		HTTPPath:   "/cluster/{ClusterArn}",
   460  	}
   461  
   462  	if input == nil {
   463  		input = &DeleteClusterInput{}
   464  	}
   465  
   466  	output = &DeleteClusterOutput{}
   467  	req = c.newRequest(op, input, output)
   468  	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
   469  	return
   470  }
   471  
   472  // DeleteCluster API operation for AWS Route53 Recovery Control Config.
   473  //
   474  // Delete a cluster.
   475  //
   476  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   477  // with awserr.Error's Code and Message methods to get detailed information about
   478  // the error.
   479  //
   480  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   481  // API operation DeleteCluster for usage and error information.
   482  //
   483  // Returned Error Types:
   484  //   * ValidationException
   485  //   400 response - Multiple causes. For example, you might have a malformed query
   486  //   string and input parameter might be out of range, or you used parameters
   487  //   together incorrectly.
   488  //
   489  //   * InternalServerException
   490  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   491  //
   492  //   * AccessDeniedException
   493  //   403 response - AccessDeniedException. You do not have sufficient access to
   494  //   perform this action.
   495  //
   496  //   * ResourceNotFoundException
   497  //   404 response - The query string contains a syntax error or resource not found.
   498  //
   499  //   * ThrottlingException
   500  //   429 response - ThrottlingException.
   501  //
   502  //   * ConflictException
   503  //   409 response - ConflictException.
   504  //
   505  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteCluster
   506  func (c *Route53RecoveryControlConfig) DeleteCluster(input *DeleteClusterInput) (*DeleteClusterOutput, error) {
   507  	req, out := c.DeleteClusterRequest(input)
   508  	return out, req.Send()
   509  }
   510  
   511  // DeleteClusterWithContext is the same as DeleteCluster with the addition of
   512  // the ability to pass a context and additional request options.
   513  //
   514  // See DeleteCluster for details on how to use this API operation.
   515  //
   516  // The context must be non-nil and will be used for request cancellation. If
   517  // the context is nil a panic will occur. In the future the SDK may create
   518  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   519  // for more information on using Contexts.
   520  func (c *Route53RecoveryControlConfig) DeleteClusterWithContext(ctx aws.Context, input *DeleteClusterInput, opts ...request.Option) (*DeleteClusterOutput, error) {
   521  	req, out := c.DeleteClusterRequest(input)
   522  	req.SetContext(ctx)
   523  	req.ApplyOptions(opts...)
   524  	return out, req.Send()
   525  }
   526  
   527  const opDeleteControlPanel = "DeleteControlPanel"
   528  
   529  // DeleteControlPanelRequest generates a "aws/request.Request" representing the
   530  // client's request for the DeleteControlPanel operation. The "output" return
   531  // value will be populated with the request's response once the request completes
   532  // successfully.
   533  //
   534  // Use "Send" method on the returned Request to send the API call to the service.
   535  // the "output" return value is not valid until after Send returns without error.
   536  //
   537  // See DeleteControlPanel for more information on using the DeleteControlPanel
   538  // API call, and error handling.
   539  //
   540  // This method is useful when you want to inject custom logic or configuration
   541  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   542  //
   543  //
   544  //    // Example sending a request using the DeleteControlPanelRequest method.
   545  //    req, resp := client.DeleteControlPanelRequest(params)
   546  //
   547  //    err := req.Send()
   548  //    if err == nil { // resp is now filled
   549  //        fmt.Println(resp)
   550  //    }
   551  //
   552  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteControlPanel
   553  func (c *Route53RecoveryControlConfig) DeleteControlPanelRequest(input *DeleteControlPanelInput) (req *request.Request, output *DeleteControlPanelOutput) {
   554  	op := &request.Operation{
   555  		Name:       opDeleteControlPanel,
   556  		HTTPMethod: "DELETE",
   557  		HTTPPath:   "/controlpanel/{ControlPanelArn}",
   558  	}
   559  
   560  	if input == nil {
   561  		input = &DeleteControlPanelInput{}
   562  	}
   563  
   564  	output = &DeleteControlPanelOutput{}
   565  	req = c.newRequest(op, input, output)
   566  	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
   567  	return
   568  }
   569  
   570  // DeleteControlPanel API operation for AWS Route53 Recovery Control Config.
   571  //
   572  // Deletes a control panel.
   573  //
   574  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   575  // with awserr.Error's Code and Message methods to get detailed information about
   576  // the error.
   577  //
   578  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   579  // API operation DeleteControlPanel for usage and error information.
   580  //
   581  // Returned Error Types:
   582  //   * ValidationException
   583  //   400 response - Multiple causes. For example, you might have a malformed query
   584  //   string and input parameter might be out of range, or you used parameters
   585  //   together incorrectly.
   586  //
   587  //   * InternalServerException
   588  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   589  //
   590  //   * AccessDeniedException
   591  //   403 response - AccessDeniedException. You do not have sufficient access to
   592  //   perform this action.
   593  //
   594  //   * ResourceNotFoundException
   595  //   404 response - The query string contains a syntax error or resource not found.
   596  //
   597  //   * ThrottlingException
   598  //   429 response - ThrottlingException.
   599  //
   600  //   * ConflictException
   601  //   409 response - ConflictException.
   602  //
   603  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteControlPanel
   604  func (c *Route53RecoveryControlConfig) DeleteControlPanel(input *DeleteControlPanelInput) (*DeleteControlPanelOutput, error) {
   605  	req, out := c.DeleteControlPanelRequest(input)
   606  	return out, req.Send()
   607  }
   608  
   609  // DeleteControlPanelWithContext is the same as DeleteControlPanel with the addition of
   610  // the ability to pass a context and additional request options.
   611  //
   612  // See DeleteControlPanel for details on how to use this API operation.
   613  //
   614  // The context must be non-nil and will be used for request cancellation. If
   615  // the context is nil a panic will occur. In the future the SDK may create
   616  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   617  // for more information on using Contexts.
   618  func (c *Route53RecoveryControlConfig) DeleteControlPanelWithContext(ctx aws.Context, input *DeleteControlPanelInput, opts ...request.Option) (*DeleteControlPanelOutput, error) {
   619  	req, out := c.DeleteControlPanelRequest(input)
   620  	req.SetContext(ctx)
   621  	req.ApplyOptions(opts...)
   622  	return out, req.Send()
   623  }
   624  
   625  const opDeleteRoutingControl = "DeleteRoutingControl"
   626  
   627  // DeleteRoutingControlRequest generates a "aws/request.Request" representing the
   628  // client's request for the DeleteRoutingControl operation. The "output" return
   629  // value will be populated with the request's response once the request completes
   630  // successfully.
   631  //
   632  // Use "Send" method on the returned Request to send the API call to the service.
   633  // the "output" return value is not valid until after Send returns without error.
   634  //
   635  // See DeleteRoutingControl for more information on using the DeleteRoutingControl
   636  // API call, and error handling.
   637  //
   638  // This method is useful when you want to inject custom logic or configuration
   639  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   640  //
   641  //
   642  //    // Example sending a request using the DeleteRoutingControlRequest method.
   643  //    req, resp := client.DeleteRoutingControlRequest(params)
   644  //
   645  //    err := req.Send()
   646  //    if err == nil { // resp is now filled
   647  //        fmt.Println(resp)
   648  //    }
   649  //
   650  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteRoutingControl
   651  func (c *Route53RecoveryControlConfig) DeleteRoutingControlRequest(input *DeleteRoutingControlInput) (req *request.Request, output *DeleteRoutingControlOutput) {
   652  	op := &request.Operation{
   653  		Name:       opDeleteRoutingControl,
   654  		HTTPMethod: "DELETE",
   655  		HTTPPath:   "/routingcontrol/{RoutingControlArn}",
   656  	}
   657  
   658  	if input == nil {
   659  		input = &DeleteRoutingControlInput{}
   660  	}
   661  
   662  	output = &DeleteRoutingControlOutput{}
   663  	req = c.newRequest(op, input, output)
   664  	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
   665  	return
   666  }
   667  
   668  // DeleteRoutingControl API operation for AWS Route53 Recovery Control Config.
   669  //
   670  // Deletes a routing control.
   671  //
   672  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   673  // with awserr.Error's Code and Message methods to get detailed information about
   674  // the error.
   675  //
   676  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   677  // API operation DeleteRoutingControl for usage and error information.
   678  //
   679  // Returned Error Types:
   680  //   * ValidationException
   681  //   400 response - Multiple causes. For example, you might have a malformed query
   682  //   string and input parameter might be out of range, or you used parameters
   683  //   together incorrectly.
   684  //
   685  //   * InternalServerException
   686  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   687  //
   688  //   * AccessDeniedException
   689  //   403 response - AccessDeniedException. You do not have sufficient access to
   690  //   perform this action.
   691  //
   692  //   * ResourceNotFoundException
   693  //   404 response - The query string contains a syntax error or resource not found.
   694  //
   695  //   * ThrottlingException
   696  //   429 response - ThrottlingException.
   697  //
   698  //   * ConflictException
   699  //   409 response - ConflictException.
   700  //
   701  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteRoutingControl
   702  func (c *Route53RecoveryControlConfig) DeleteRoutingControl(input *DeleteRoutingControlInput) (*DeleteRoutingControlOutput, error) {
   703  	req, out := c.DeleteRoutingControlRequest(input)
   704  	return out, req.Send()
   705  }
   706  
   707  // DeleteRoutingControlWithContext is the same as DeleteRoutingControl with the addition of
   708  // the ability to pass a context and additional request options.
   709  //
   710  // See DeleteRoutingControl for details on how to use this API operation.
   711  //
   712  // The context must be non-nil and will be used for request cancellation. If
   713  // the context is nil a panic will occur. In the future the SDK may create
   714  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   715  // for more information on using Contexts.
   716  func (c *Route53RecoveryControlConfig) DeleteRoutingControlWithContext(ctx aws.Context, input *DeleteRoutingControlInput, opts ...request.Option) (*DeleteRoutingControlOutput, error) {
   717  	req, out := c.DeleteRoutingControlRequest(input)
   718  	req.SetContext(ctx)
   719  	req.ApplyOptions(opts...)
   720  	return out, req.Send()
   721  }
   722  
   723  const opDeleteSafetyRule = "DeleteSafetyRule"
   724  
   725  // DeleteSafetyRuleRequest generates a "aws/request.Request" representing the
   726  // client's request for the DeleteSafetyRule operation. The "output" return
   727  // value will be populated with the request's response once the request completes
   728  // successfully.
   729  //
   730  // Use "Send" method on the returned Request to send the API call to the service.
   731  // the "output" return value is not valid until after Send returns without error.
   732  //
   733  // See DeleteSafetyRule for more information on using the DeleteSafetyRule
   734  // API call, and error handling.
   735  //
   736  // This method is useful when you want to inject custom logic or configuration
   737  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   738  //
   739  //
   740  //    // Example sending a request using the DeleteSafetyRuleRequest method.
   741  //    req, resp := client.DeleteSafetyRuleRequest(params)
   742  //
   743  //    err := req.Send()
   744  //    if err == nil { // resp is now filled
   745  //        fmt.Println(resp)
   746  //    }
   747  //
   748  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteSafetyRule
   749  func (c *Route53RecoveryControlConfig) DeleteSafetyRuleRequest(input *DeleteSafetyRuleInput) (req *request.Request, output *DeleteSafetyRuleOutput) {
   750  	op := &request.Operation{
   751  		Name:       opDeleteSafetyRule,
   752  		HTTPMethod: "DELETE",
   753  		HTTPPath:   "/safetyrule/{SafetyRuleArn}",
   754  	}
   755  
   756  	if input == nil {
   757  		input = &DeleteSafetyRuleInput{}
   758  	}
   759  
   760  	output = &DeleteSafetyRuleOutput{}
   761  	req = c.newRequest(op, input, output)
   762  	req.Handlers.Unmarshal.Swap(restjson.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
   763  	return
   764  }
   765  
   766  // DeleteSafetyRule API operation for AWS Route53 Recovery Control Config.
   767  //
   768  // Deletes a safety rule.
   769  // />
   770  //
   771  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   772  // with awserr.Error's Code and Message methods to get detailed information about
   773  // the error.
   774  //
   775  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   776  // API operation DeleteSafetyRule for usage and error information.
   777  //
   778  // Returned Error Types:
   779  //   * ResourceNotFoundException
   780  //   404 response - The query string contains a syntax error or resource not found.
   781  //
   782  //   * ValidationException
   783  //   400 response - Multiple causes. For example, you might have a malformed query
   784  //   string and input parameter might be out of range, or you used parameters
   785  //   together incorrectly.
   786  //
   787  //   * InternalServerException
   788  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   789  //
   790  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DeleteSafetyRule
   791  func (c *Route53RecoveryControlConfig) DeleteSafetyRule(input *DeleteSafetyRuleInput) (*DeleteSafetyRuleOutput, error) {
   792  	req, out := c.DeleteSafetyRuleRequest(input)
   793  	return out, req.Send()
   794  }
   795  
   796  // DeleteSafetyRuleWithContext is the same as DeleteSafetyRule with the addition of
   797  // the ability to pass a context and additional request options.
   798  //
   799  // See DeleteSafetyRule for details on how to use this API operation.
   800  //
   801  // The context must be non-nil and will be used for request cancellation. If
   802  // the context is nil a panic will occur. In the future the SDK may create
   803  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   804  // for more information on using Contexts.
   805  func (c *Route53RecoveryControlConfig) DeleteSafetyRuleWithContext(ctx aws.Context, input *DeleteSafetyRuleInput, opts ...request.Option) (*DeleteSafetyRuleOutput, error) {
   806  	req, out := c.DeleteSafetyRuleRequest(input)
   807  	req.SetContext(ctx)
   808  	req.ApplyOptions(opts...)
   809  	return out, req.Send()
   810  }
   811  
   812  const opDescribeCluster = "DescribeCluster"
   813  
   814  // DescribeClusterRequest generates a "aws/request.Request" representing the
   815  // client's request for the DescribeCluster operation. The "output" return
   816  // value will be populated with the request's response once the request completes
   817  // successfully.
   818  //
   819  // Use "Send" method on the returned Request to send the API call to the service.
   820  // the "output" return value is not valid until after Send returns without error.
   821  //
   822  // See DescribeCluster for more information on using the DescribeCluster
   823  // API call, and error handling.
   824  //
   825  // This method is useful when you want to inject custom logic or configuration
   826  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   827  //
   828  //
   829  //    // Example sending a request using the DescribeClusterRequest method.
   830  //    req, resp := client.DescribeClusterRequest(params)
   831  //
   832  //    err := req.Send()
   833  //    if err == nil { // resp is now filled
   834  //        fmt.Println(resp)
   835  //    }
   836  //
   837  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeCluster
   838  func (c *Route53RecoveryControlConfig) DescribeClusterRequest(input *DescribeClusterInput) (req *request.Request, output *DescribeClusterOutput) {
   839  	op := &request.Operation{
   840  		Name:       opDescribeCluster,
   841  		HTTPMethod: "GET",
   842  		HTTPPath:   "/cluster/{ClusterArn}",
   843  	}
   844  
   845  	if input == nil {
   846  		input = &DescribeClusterInput{}
   847  	}
   848  
   849  	output = &DescribeClusterOutput{}
   850  	req = c.newRequest(op, input, output)
   851  	return
   852  }
   853  
   854  // DescribeCluster API operation for AWS Route53 Recovery Control Config.
   855  //
   856  // Display the details about a cluster. The response includes the cluster name,
   857  // endpoints, status, and Amazon Resource Name (ARN).
   858  //
   859  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   860  // with awserr.Error's Code and Message methods to get detailed information about
   861  // the error.
   862  //
   863  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   864  // API operation DescribeCluster for usage and error information.
   865  //
   866  // Returned Error Types:
   867  //   * ValidationException
   868  //   400 response - Multiple causes. For example, you might have a malformed query
   869  //   string and input parameter might be out of range, or you used parameters
   870  //   together incorrectly.
   871  //
   872  //   * InternalServerException
   873  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   874  //
   875  //   * AccessDeniedException
   876  //   403 response - AccessDeniedException. You do not have sufficient access to
   877  //   perform this action.
   878  //
   879  //   * ResourceNotFoundException
   880  //   404 response - The query string contains a syntax error or resource not found.
   881  //
   882  //   * ThrottlingException
   883  //   429 response - ThrottlingException.
   884  //
   885  //   * ConflictException
   886  //   409 response - ConflictException.
   887  //
   888  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeCluster
   889  func (c *Route53RecoveryControlConfig) DescribeCluster(input *DescribeClusterInput) (*DescribeClusterOutput, error) {
   890  	req, out := c.DescribeClusterRequest(input)
   891  	return out, req.Send()
   892  }
   893  
   894  // DescribeClusterWithContext is the same as DescribeCluster with the addition of
   895  // the ability to pass a context and additional request options.
   896  //
   897  // See DescribeCluster for details on how to use this API operation.
   898  //
   899  // The context must be non-nil and will be used for request cancellation. If
   900  // the context is nil a panic will occur. In the future the SDK may create
   901  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   902  // for more information on using Contexts.
   903  func (c *Route53RecoveryControlConfig) DescribeClusterWithContext(ctx aws.Context, input *DescribeClusterInput, opts ...request.Option) (*DescribeClusterOutput, error) {
   904  	req, out := c.DescribeClusterRequest(input)
   905  	req.SetContext(ctx)
   906  	req.ApplyOptions(opts...)
   907  	return out, req.Send()
   908  }
   909  
   910  const opDescribeControlPanel = "DescribeControlPanel"
   911  
   912  // DescribeControlPanelRequest generates a "aws/request.Request" representing the
   913  // client's request for the DescribeControlPanel operation. The "output" return
   914  // value will be populated with the request's response once the request completes
   915  // successfully.
   916  //
   917  // Use "Send" method on the returned Request to send the API call to the service.
   918  // the "output" return value is not valid until after Send returns without error.
   919  //
   920  // See DescribeControlPanel for more information on using the DescribeControlPanel
   921  // API call, and error handling.
   922  //
   923  // This method is useful when you want to inject custom logic or configuration
   924  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
   925  //
   926  //
   927  //    // Example sending a request using the DescribeControlPanelRequest method.
   928  //    req, resp := client.DescribeControlPanelRequest(params)
   929  //
   930  //    err := req.Send()
   931  //    if err == nil { // resp is now filled
   932  //        fmt.Println(resp)
   933  //    }
   934  //
   935  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeControlPanel
   936  func (c *Route53RecoveryControlConfig) DescribeControlPanelRequest(input *DescribeControlPanelInput) (req *request.Request, output *DescribeControlPanelOutput) {
   937  	op := &request.Operation{
   938  		Name:       opDescribeControlPanel,
   939  		HTTPMethod: "GET",
   940  		HTTPPath:   "/controlpanel/{ControlPanelArn}",
   941  	}
   942  
   943  	if input == nil {
   944  		input = &DescribeControlPanelInput{}
   945  	}
   946  
   947  	output = &DescribeControlPanelOutput{}
   948  	req = c.newRequest(op, input, output)
   949  	return
   950  }
   951  
   952  // DescribeControlPanel API operation for AWS Route53 Recovery Control Config.
   953  //
   954  // Displays details about a control panel.
   955  //
   956  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   957  // with awserr.Error's Code and Message methods to get detailed information about
   958  // the error.
   959  //
   960  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
   961  // API operation DescribeControlPanel for usage and error information.
   962  //
   963  // Returned Error Types:
   964  //   * ValidationException
   965  //   400 response - Multiple causes. For example, you might have a malformed query
   966  //   string and input parameter might be out of range, or you used parameters
   967  //   together incorrectly.
   968  //
   969  //   * InternalServerException
   970  //   500 response - InternalServiceError. Temporary service error. Retry the request.
   971  //
   972  //   * AccessDeniedException
   973  //   403 response - AccessDeniedException. You do not have sufficient access to
   974  //   perform this action.
   975  //
   976  //   * ResourceNotFoundException
   977  //   404 response - The query string contains a syntax error or resource not found.
   978  //
   979  //   * ThrottlingException
   980  //   429 response - ThrottlingException.
   981  //
   982  //   * ConflictException
   983  //   409 response - ConflictException.
   984  //
   985  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeControlPanel
   986  func (c *Route53RecoveryControlConfig) DescribeControlPanel(input *DescribeControlPanelInput) (*DescribeControlPanelOutput, error) {
   987  	req, out := c.DescribeControlPanelRequest(input)
   988  	return out, req.Send()
   989  }
   990  
   991  // DescribeControlPanelWithContext is the same as DescribeControlPanel with the addition of
   992  // the ability to pass a context and additional request options.
   993  //
   994  // See DescribeControlPanel for details on how to use this API operation.
   995  //
   996  // The context must be non-nil and will be used for request cancellation. If
   997  // the context is nil a panic will occur. In the future the SDK may create
   998  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
   999  // for more information on using Contexts.
  1000  func (c *Route53RecoveryControlConfig) DescribeControlPanelWithContext(ctx aws.Context, input *DescribeControlPanelInput, opts ...request.Option) (*DescribeControlPanelOutput, error) {
  1001  	req, out := c.DescribeControlPanelRequest(input)
  1002  	req.SetContext(ctx)
  1003  	req.ApplyOptions(opts...)
  1004  	return out, req.Send()
  1005  }
  1006  
  1007  const opDescribeRoutingControl = "DescribeRoutingControl"
  1008  
  1009  // DescribeRoutingControlRequest generates a "aws/request.Request" representing the
  1010  // client's request for the DescribeRoutingControl operation. The "output" return
  1011  // value will be populated with the request's response once the request completes
  1012  // successfully.
  1013  //
  1014  // Use "Send" method on the returned Request to send the API call to the service.
  1015  // the "output" return value is not valid until after Send returns without error.
  1016  //
  1017  // See DescribeRoutingControl for more information on using the DescribeRoutingControl
  1018  // API call, and error handling.
  1019  //
  1020  // This method is useful when you want to inject custom logic or configuration
  1021  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1022  //
  1023  //
  1024  //    // Example sending a request using the DescribeRoutingControlRequest method.
  1025  //    req, resp := client.DescribeRoutingControlRequest(params)
  1026  //
  1027  //    err := req.Send()
  1028  //    if err == nil { // resp is now filled
  1029  //        fmt.Println(resp)
  1030  //    }
  1031  //
  1032  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeRoutingControl
  1033  func (c *Route53RecoveryControlConfig) DescribeRoutingControlRequest(input *DescribeRoutingControlInput) (req *request.Request, output *DescribeRoutingControlOutput) {
  1034  	op := &request.Operation{
  1035  		Name:       opDescribeRoutingControl,
  1036  		HTTPMethod: "GET",
  1037  		HTTPPath:   "/routingcontrol/{RoutingControlArn}",
  1038  	}
  1039  
  1040  	if input == nil {
  1041  		input = &DescribeRoutingControlInput{}
  1042  	}
  1043  
  1044  	output = &DescribeRoutingControlOutput{}
  1045  	req = c.newRequest(op, input, output)
  1046  	return
  1047  }
  1048  
  1049  // DescribeRoutingControl API operation for AWS Route53 Recovery Control Config.
  1050  //
  1051  // Displays details about a routing control. A routing control has one of two
  1052  // states: ON and OFF. You can map the routing control state to the state of
  1053  // an Amazon Route 53 health check, which can be used to control routing.
  1054  //
  1055  // To get or update the routing control state, see the Recovery Cluster (data
  1056  // plane) API actions for Amazon Route 53 Application Recovery Controller.
  1057  //
  1058  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  1059  // with awserr.Error's Code and Message methods to get detailed information about
  1060  // the error.
  1061  //
  1062  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  1063  // API operation DescribeRoutingControl for usage and error information.
  1064  //
  1065  // Returned Error Types:
  1066  //   * ValidationException
  1067  //   400 response - Multiple causes. For example, you might have a malformed query
  1068  //   string and input parameter might be out of range, or you used parameters
  1069  //   together incorrectly.
  1070  //
  1071  //   * InternalServerException
  1072  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  1073  //
  1074  //   * AccessDeniedException
  1075  //   403 response - AccessDeniedException. You do not have sufficient access to
  1076  //   perform this action.
  1077  //
  1078  //   * ResourceNotFoundException
  1079  //   404 response - The query string contains a syntax error or resource not found.
  1080  //
  1081  //   * ThrottlingException
  1082  //   429 response - ThrottlingException.
  1083  //
  1084  //   * ConflictException
  1085  //   409 response - ConflictException.
  1086  //
  1087  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeRoutingControl
  1088  func (c *Route53RecoveryControlConfig) DescribeRoutingControl(input *DescribeRoutingControlInput) (*DescribeRoutingControlOutput, error) {
  1089  	req, out := c.DescribeRoutingControlRequest(input)
  1090  	return out, req.Send()
  1091  }
  1092  
  1093  // DescribeRoutingControlWithContext is the same as DescribeRoutingControl with the addition of
  1094  // the ability to pass a context and additional request options.
  1095  //
  1096  // See DescribeRoutingControl for details on how to use this API operation.
  1097  //
  1098  // The context must be non-nil and will be used for request cancellation. If
  1099  // the context is nil a panic will occur. In the future the SDK may create
  1100  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1101  // for more information on using Contexts.
  1102  func (c *Route53RecoveryControlConfig) DescribeRoutingControlWithContext(ctx aws.Context, input *DescribeRoutingControlInput, opts ...request.Option) (*DescribeRoutingControlOutput, error) {
  1103  	req, out := c.DescribeRoutingControlRequest(input)
  1104  	req.SetContext(ctx)
  1105  	req.ApplyOptions(opts...)
  1106  	return out, req.Send()
  1107  }
  1108  
  1109  const opDescribeSafetyRule = "DescribeSafetyRule"
  1110  
  1111  // DescribeSafetyRuleRequest generates a "aws/request.Request" representing the
  1112  // client's request for the DescribeSafetyRule operation. The "output" return
  1113  // value will be populated with the request's response once the request completes
  1114  // successfully.
  1115  //
  1116  // Use "Send" method on the returned Request to send the API call to the service.
  1117  // the "output" return value is not valid until after Send returns without error.
  1118  //
  1119  // See DescribeSafetyRule for more information on using the DescribeSafetyRule
  1120  // API call, and error handling.
  1121  //
  1122  // This method is useful when you want to inject custom logic or configuration
  1123  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1124  //
  1125  //
  1126  //    // Example sending a request using the DescribeSafetyRuleRequest method.
  1127  //    req, resp := client.DescribeSafetyRuleRequest(params)
  1128  //
  1129  //    err := req.Send()
  1130  //    if err == nil { // resp is now filled
  1131  //        fmt.Println(resp)
  1132  //    }
  1133  //
  1134  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeSafetyRule
  1135  func (c *Route53RecoveryControlConfig) DescribeSafetyRuleRequest(input *DescribeSafetyRuleInput) (req *request.Request, output *DescribeSafetyRuleOutput) {
  1136  	op := &request.Operation{
  1137  		Name:       opDescribeSafetyRule,
  1138  		HTTPMethod: "GET",
  1139  		HTTPPath:   "/safetyrule/{SafetyRuleArn}",
  1140  	}
  1141  
  1142  	if input == nil {
  1143  		input = &DescribeSafetyRuleInput{}
  1144  	}
  1145  
  1146  	output = &DescribeSafetyRuleOutput{}
  1147  	req = c.newRequest(op, input, output)
  1148  	return
  1149  }
  1150  
  1151  // DescribeSafetyRule API operation for AWS Route53 Recovery Control Config.
  1152  //
  1153  // Describes the safety rules (that is, the assertion rules and gating rules)
  1154  // for the routing controls in a control panel.
  1155  //
  1156  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  1157  // with awserr.Error's Code and Message methods to get detailed information about
  1158  // the error.
  1159  //
  1160  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  1161  // API operation DescribeSafetyRule for usage and error information.
  1162  //
  1163  // Returned Error Types:
  1164  //   * ValidationException
  1165  //   400 response - Multiple causes. For example, you might have a malformed query
  1166  //   string and input parameter might be out of range, or you used parameters
  1167  //   together incorrectly.
  1168  //
  1169  //   * ResourceNotFoundException
  1170  //   404 response - The query string contains a syntax error or resource not found.
  1171  //
  1172  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/DescribeSafetyRule
  1173  func (c *Route53RecoveryControlConfig) DescribeSafetyRule(input *DescribeSafetyRuleInput) (*DescribeSafetyRuleOutput, error) {
  1174  	req, out := c.DescribeSafetyRuleRequest(input)
  1175  	return out, req.Send()
  1176  }
  1177  
  1178  // DescribeSafetyRuleWithContext is the same as DescribeSafetyRule with the addition of
  1179  // the ability to pass a context and additional request options.
  1180  //
  1181  // See DescribeSafetyRule for details on how to use this API operation.
  1182  //
  1183  // The context must be non-nil and will be used for request cancellation. If
  1184  // the context is nil a panic will occur. In the future the SDK may create
  1185  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1186  // for more information on using Contexts.
  1187  func (c *Route53RecoveryControlConfig) DescribeSafetyRuleWithContext(ctx aws.Context, input *DescribeSafetyRuleInput, opts ...request.Option) (*DescribeSafetyRuleOutput, error) {
  1188  	req, out := c.DescribeSafetyRuleRequest(input)
  1189  	req.SetContext(ctx)
  1190  	req.ApplyOptions(opts...)
  1191  	return out, req.Send()
  1192  }
  1193  
  1194  const opListAssociatedRoute53HealthChecks = "ListAssociatedRoute53HealthChecks"
  1195  
  1196  // ListAssociatedRoute53HealthChecksRequest generates a "aws/request.Request" representing the
  1197  // client's request for the ListAssociatedRoute53HealthChecks operation. The "output" return
  1198  // value will be populated with the request's response once the request completes
  1199  // successfully.
  1200  //
  1201  // Use "Send" method on the returned Request to send the API call to the service.
  1202  // the "output" return value is not valid until after Send returns without error.
  1203  //
  1204  // See ListAssociatedRoute53HealthChecks for more information on using the ListAssociatedRoute53HealthChecks
  1205  // API call, and error handling.
  1206  //
  1207  // This method is useful when you want to inject custom logic or configuration
  1208  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1209  //
  1210  //
  1211  //    // Example sending a request using the ListAssociatedRoute53HealthChecksRequest method.
  1212  //    req, resp := client.ListAssociatedRoute53HealthChecksRequest(params)
  1213  //
  1214  //    err := req.Send()
  1215  //    if err == nil { // resp is now filled
  1216  //        fmt.Println(resp)
  1217  //    }
  1218  //
  1219  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListAssociatedRoute53HealthChecks
  1220  func (c *Route53RecoveryControlConfig) ListAssociatedRoute53HealthChecksRequest(input *ListAssociatedRoute53HealthChecksInput) (req *request.Request, output *ListAssociatedRoute53HealthChecksOutput) {
  1221  	op := &request.Operation{
  1222  		Name:       opListAssociatedRoute53HealthChecks,
  1223  		HTTPMethod: "GET",
  1224  		HTTPPath:   "/routingcontrol/{RoutingControlArn}/associatedRoute53HealthChecks",
  1225  		Paginator: &request.Paginator{
  1226  			InputTokens:     []string{"NextToken"},
  1227  			OutputTokens:    []string{"NextToken"},
  1228  			LimitToken:      "MaxResults",
  1229  			TruncationToken: "",
  1230  		},
  1231  	}
  1232  
  1233  	if input == nil {
  1234  		input = &ListAssociatedRoute53HealthChecksInput{}
  1235  	}
  1236  
  1237  	output = &ListAssociatedRoute53HealthChecksOutput{}
  1238  	req = c.newRequest(op, input, output)
  1239  	return
  1240  }
  1241  
  1242  // ListAssociatedRoute53HealthChecks API operation for AWS Route53 Recovery Control Config.
  1243  //
  1244  // Returns an array of all Amazon Route 53 health checks associated with a specific
  1245  // routing control.
  1246  //
  1247  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  1248  // with awserr.Error's Code and Message methods to get detailed information about
  1249  // the error.
  1250  //
  1251  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  1252  // API operation ListAssociatedRoute53HealthChecks for usage and error information.
  1253  //
  1254  // Returned Error Types:
  1255  //   * ResourceNotFoundException
  1256  //   404 response - The query string contains a syntax error or resource not found.
  1257  //
  1258  //   * ValidationException
  1259  //   400 response - Multiple causes. For example, you might have a malformed query
  1260  //   string and input parameter might be out of range, or you used parameters
  1261  //   together incorrectly.
  1262  //
  1263  //   * InternalServerException
  1264  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  1265  //
  1266  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListAssociatedRoute53HealthChecks
  1267  func (c *Route53RecoveryControlConfig) ListAssociatedRoute53HealthChecks(input *ListAssociatedRoute53HealthChecksInput) (*ListAssociatedRoute53HealthChecksOutput, error) {
  1268  	req, out := c.ListAssociatedRoute53HealthChecksRequest(input)
  1269  	return out, req.Send()
  1270  }
  1271  
  1272  // ListAssociatedRoute53HealthChecksWithContext is the same as ListAssociatedRoute53HealthChecks with the addition of
  1273  // the ability to pass a context and additional request options.
  1274  //
  1275  // See ListAssociatedRoute53HealthChecks for details on how to use this API operation.
  1276  //
  1277  // The context must be non-nil and will be used for request cancellation. If
  1278  // the context is nil a panic will occur. In the future the SDK may create
  1279  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1280  // for more information on using Contexts.
  1281  func (c *Route53RecoveryControlConfig) ListAssociatedRoute53HealthChecksWithContext(ctx aws.Context, input *ListAssociatedRoute53HealthChecksInput, opts ...request.Option) (*ListAssociatedRoute53HealthChecksOutput, error) {
  1282  	req, out := c.ListAssociatedRoute53HealthChecksRequest(input)
  1283  	req.SetContext(ctx)
  1284  	req.ApplyOptions(opts...)
  1285  	return out, req.Send()
  1286  }
  1287  
  1288  // ListAssociatedRoute53HealthChecksPages iterates over the pages of a ListAssociatedRoute53HealthChecks operation,
  1289  // calling the "fn" function with the response data for each page. To stop
  1290  // iterating, return false from the fn function.
  1291  //
  1292  // See ListAssociatedRoute53HealthChecks method for more information on how to use this operation.
  1293  //
  1294  // Note: This operation can generate multiple requests to a service.
  1295  //
  1296  //    // Example iterating over at most 3 pages of a ListAssociatedRoute53HealthChecks operation.
  1297  //    pageNum := 0
  1298  //    err := client.ListAssociatedRoute53HealthChecksPages(params,
  1299  //        func(page *route53recoverycontrolconfig.ListAssociatedRoute53HealthChecksOutput, lastPage bool) bool {
  1300  //            pageNum++
  1301  //            fmt.Println(page)
  1302  //            return pageNum <= 3
  1303  //        })
  1304  //
  1305  func (c *Route53RecoveryControlConfig) ListAssociatedRoute53HealthChecksPages(input *ListAssociatedRoute53HealthChecksInput, fn func(*ListAssociatedRoute53HealthChecksOutput, bool) bool) error {
  1306  	return c.ListAssociatedRoute53HealthChecksPagesWithContext(aws.BackgroundContext(), input, fn)
  1307  }
  1308  
  1309  // ListAssociatedRoute53HealthChecksPagesWithContext same as ListAssociatedRoute53HealthChecksPages except
  1310  // it takes a Context and allows setting request options on the pages.
  1311  //
  1312  // The context must be non-nil and will be used for request cancellation. If
  1313  // the context is nil a panic will occur. In the future the SDK may create
  1314  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1315  // for more information on using Contexts.
  1316  func (c *Route53RecoveryControlConfig) ListAssociatedRoute53HealthChecksPagesWithContext(ctx aws.Context, input *ListAssociatedRoute53HealthChecksInput, fn func(*ListAssociatedRoute53HealthChecksOutput, bool) bool, opts ...request.Option) error {
  1317  	p := request.Pagination{
  1318  		NewRequest: func() (*request.Request, error) {
  1319  			var inCpy *ListAssociatedRoute53HealthChecksInput
  1320  			if input != nil {
  1321  				tmp := *input
  1322  				inCpy = &tmp
  1323  			}
  1324  			req, _ := c.ListAssociatedRoute53HealthChecksRequest(inCpy)
  1325  			req.SetContext(ctx)
  1326  			req.ApplyOptions(opts...)
  1327  			return req, nil
  1328  		},
  1329  	}
  1330  
  1331  	for p.Next() {
  1332  		if !fn(p.Page().(*ListAssociatedRoute53HealthChecksOutput), !p.HasNextPage()) {
  1333  			break
  1334  		}
  1335  	}
  1336  
  1337  	return p.Err()
  1338  }
  1339  
  1340  const opListClusters = "ListClusters"
  1341  
  1342  // ListClustersRequest generates a "aws/request.Request" representing the
  1343  // client's request for the ListClusters operation. The "output" return
  1344  // value will be populated with the request's response once the request completes
  1345  // successfully.
  1346  //
  1347  // Use "Send" method on the returned Request to send the API call to the service.
  1348  // the "output" return value is not valid until after Send returns without error.
  1349  //
  1350  // See ListClusters for more information on using the ListClusters
  1351  // API call, and error handling.
  1352  //
  1353  // This method is useful when you want to inject custom logic or configuration
  1354  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1355  //
  1356  //
  1357  //    // Example sending a request using the ListClustersRequest method.
  1358  //    req, resp := client.ListClustersRequest(params)
  1359  //
  1360  //    err := req.Send()
  1361  //    if err == nil { // resp is now filled
  1362  //        fmt.Println(resp)
  1363  //    }
  1364  //
  1365  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListClusters
  1366  func (c *Route53RecoveryControlConfig) ListClustersRequest(input *ListClustersInput) (req *request.Request, output *ListClustersOutput) {
  1367  	op := &request.Operation{
  1368  		Name:       opListClusters,
  1369  		HTTPMethod: "GET",
  1370  		HTTPPath:   "/cluster",
  1371  		Paginator: &request.Paginator{
  1372  			InputTokens:     []string{"NextToken"},
  1373  			OutputTokens:    []string{"NextToken"},
  1374  			LimitToken:      "MaxResults",
  1375  			TruncationToken: "",
  1376  		},
  1377  	}
  1378  
  1379  	if input == nil {
  1380  		input = &ListClustersInput{}
  1381  	}
  1382  
  1383  	output = &ListClustersOutput{}
  1384  	req = c.newRequest(op, input, output)
  1385  	return
  1386  }
  1387  
  1388  // ListClusters API operation for AWS Route53 Recovery Control Config.
  1389  //
  1390  // Returns an array of all the clusters in an account.
  1391  //
  1392  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  1393  // with awserr.Error's Code and Message methods to get detailed information about
  1394  // the error.
  1395  //
  1396  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  1397  // API operation ListClusters for usage and error information.
  1398  //
  1399  // Returned Error Types:
  1400  //   * ResourceNotFoundException
  1401  //   404 response - The query string contains a syntax error or resource not found.
  1402  //
  1403  //   * ThrottlingException
  1404  //   429 response - ThrottlingException.
  1405  //
  1406  //   * ValidationException
  1407  //   400 response - Multiple causes. For example, you might have a malformed query
  1408  //   string and input parameter might be out of range, or you used parameters
  1409  //   together incorrectly.
  1410  //
  1411  //   * InternalServerException
  1412  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  1413  //
  1414  //   * AccessDeniedException
  1415  //   403 response - AccessDeniedException. You do not have sufficient access to
  1416  //   perform this action.
  1417  //
  1418  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListClusters
  1419  func (c *Route53RecoveryControlConfig) ListClusters(input *ListClustersInput) (*ListClustersOutput, error) {
  1420  	req, out := c.ListClustersRequest(input)
  1421  	return out, req.Send()
  1422  }
  1423  
  1424  // ListClustersWithContext is the same as ListClusters with the addition of
  1425  // the ability to pass a context and additional request options.
  1426  //
  1427  // See ListClusters for details on how to use this API operation.
  1428  //
  1429  // The context must be non-nil and will be used for request cancellation. If
  1430  // the context is nil a panic will occur. In the future the SDK may create
  1431  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1432  // for more information on using Contexts.
  1433  func (c *Route53RecoveryControlConfig) ListClustersWithContext(ctx aws.Context, input *ListClustersInput, opts ...request.Option) (*ListClustersOutput, error) {
  1434  	req, out := c.ListClustersRequest(input)
  1435  	req.SetContext(ctx)
  1436  	req.ApplyOptions(opts...)
  1437  	return out, req.Send()
  1438  }
  1439  
  1440  // ListClustersPages iterates over the pages of a ListClusters operation,
  1441  // calling the "fn" function with the response data for each page. To stop
  1442  // iterating, return false from the fn function.
  1443  //
  1444  // See ListClusters method for more information on how to use this operation.
  1445  //
  1446  // Note: This operation can generate multiple requests to a service.
  1447  //
  1448  //    // Example iterating over at most 3 pages of a ListClusters operation.
  1449  //    pageNum := 0
  1450  //    err := client.ListClustersPages(params,
  1451  //        func(page *route53recoverycontrolconfig.ListClustersOutput, lastPage bool) bool {
  1452  //            pageNum++
  1453  //            fmt.Println(page)
  1454  //            return pageNum <= 3
  1455  //        })
  1456  //
  1457  func (c *Route53RecoveryControlConfig) ListClustersPages(input *ListClustersInput, fn func(*ListClustersOutput, bool) bool) error {
  1458  	return c.ListClustersPagesWithContext(aws.BackgroundContext(), input, fn)
  1459  }
  1460  
  1461  // ListClustersPagesWithContext same as ListClustersPages except
  1462  // it takes a Context and allows setting request options on the pages.
  1463  //
  1464  // The context must be non-nil and will be used for request cancellation. If
  1465  // the context is nil a panic will occur. In the future the SDK may create
  1466  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1467  // for more information on using Contexts.
  1468  func (c *Route53RecoveryControlConfig) ListClustersPagesWithContext(ctx aws.Context, input *ListClustersInput, fn func(*ListClustersOutput, bool) bool, opts ...request.Option) error {
  1469  	p := request.Pagination{
  1470  		NewRequest: func() (*request.Request, error) {
  1471  			var inCpy *ListClustersInput
  1472  			if input != nil {
  1473  				tmp := *input
  1474  				inCpy = &tmp
  1475  			}
  1476  			req, _ := c.ListClustersRequest(inCpy)
  1477  			req.SetContext(ctx)
  1478  			req.ApplyOptions(opts...)
  1479  			return req, nil
  1480  		},
  1481  	}
  1482  
  1483  	for p.Next() {
  1484  		if !fn(p.Page().(*ListClustersOutput), !p.HasNextPage()) {
  1485  			break
  1486  		}
  1487  	}
  1488  
  1489  	return p.Err()
  1490  }
  1491  
  1492  const opListControlPanels = "ListControlPanels"
  1493  
  1494  // ListControlPanelsRequest generates a "aws/request.Request" representing the
  1495  // client's request for the ListControlPanels operation. The "output" return
  1496  // value will be populated with the request's response once the request completes
  1497  // successfully.
  1498  //
  1499  // Use "Send" method on the returned Request to send the API call to the service.
  1500  // the "output" return value is not valid until after Send returns without error.
  1501  //
  1502  // See ListControlPanels for more information on using the ListControlPanels
  1503  // API call, and error handling.
  1504  //
  1505  // This method is useful when you want to inject custom logic or configuration
  1506  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1507  //
  1508  //
  1509  //    // Example sending a request using the ListControlPanelsRequest method.
  1510  //    req, resp := client.ListControlPanelsRequest(params)
  1511  //
  1512  //    err := req.Send()
  1513  //    if err == nil { // resp is now filled
  1514  //        fmt.Println(resp)
  1515  //    }
  1516  //
  1517  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListControlPanels
  1518  func (c *Route53RecoveryControlConfig) ListControlPanelsRequest(input *ListControlPanelsInput) (req *request.Request, output *ListControlPanelsOutput) {
  1519  	op := &request.Operation{
  1520  		Name:       opListControlPanels,
  1521  		HTTPMethod: "GET",
  1522  		HTTPPath:   "/controlpanels",
  1523  		Paginator: &request.Paginator{
  1524  			InputTokens:     []string{"NextToken"},
  1525  			OutputTokens:    []string{"NextToken"},
  1526  			LimitToken:      "MaxResults",
  1527  			TruncationToken: "",
  1528  		},
  1529  	}
  1530  
  1531  	if input == nil {
  1532  		input = &ListControlPanelsInput{}
  1533  	}
  1534  
  1535  	output = &ListControlPanelsOutput{}
  1536  	req = c.newRequest(op, input, output)
  1537  	return
  1538  }
  1539  
  1540  // ListControlPanels API operation for AWS Route53 Recovery Control Config.
  1541  //
  1542  // Returns an array of control panels for a cluster.
  1543  //
  1544  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  1545  // with awserr.Error's Code and Message methods to get detailed information about
  1546  // the error.
  1547  //
  1548  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  1549  // API operation ListControlPanels for usage and error information.
  1550  //
  1551  // Returned Error Types:
  1552  //   * ResourceNotFoundException
  1553  //   404 response - The query string contains a syntax error or resource not found.
  1554  //
  1555  //   * ThrottlingException
  1556  //   429 response - ThrottlingException.
  1557  //
  1558  //   * ValidationException
  1559  //   400 response - Multiple causes. For example, you might have a malformed query
  1560  //   string and input parameter might be out of range, or you used parameters
  1561  //   together incorrectly.
  1562  //
  1563  //   * InternalServerException
  1564  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  1565  //
  1566  //   * AccessDeniedException
  1567  //   403 response - AccessDeniedException. You do not have sufficient access to
  1568  //   perform this action.
  1569  //
  1570  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListControlPanels
  1571  func (c *Route53RecoveryControlConfig) ListControlPanels(input *ListControlPanelsInput) (*ListControlPanelsOutput, error) {
  1572  	req, out := c.ListControlPanelsRequest(input)
  1573  	return out, req.Send()
  1574  }
  1575  
  1576  // ListControlPanelsWithContext is the same as ListControlPanels with the addition of
  1577  // the ability to pass a context and additional request options.
  1578  //
  1579  // See ListControlPanels for details on how to use this API operation.
  1580  //
  1581  // The context must be non-nil and will be used for request cancellation. If
  1582  // the context is nil a panic will occur. In the future the SDK may create
  1583  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1584  // for more information on using Contexts.
  1585  func (c *Route53RecoveryControlConfig) ListControlPanelsWithContext(ctx aws.Context, input *ListControlPanelsInput, opts ...request.Option) (*ListControlPanelsOutput, error) {
  1586  	req, out := c.ListControlPanelsRequest(input)
  1587  	req.SetContext(ctx)
  1588  	req.ApplyOptions(opts...)
  1589  	return out, req.Send()
  1590  }
  1591  
  1592  // ListControlPanelsPages iterates over the pages of a ListControlPanels operation,
  1593  // calling the "fn" function with the response data for each page. To stop
  1594  // iterating, return false from the fn function.
  1595  //
  1596  // See ListControlPanels method for more information on how to use this operation.
  1597  //
  1598  // Note: This operation can generate multiple requests to a service.
  1599  //
  1600  //    // Example iterating over at most 3 pages of a ListControlPanels operation.
  1601  //    pageNum := 0
  1602  //    err := client.ListControlPanelsPages(params,
  1603  //        func(page *route53recoverycontrolconfig.ListControlPanelsOutput, lastPage bool) bool {
  1604  //            pageNum++
  1605  //            fmt.Println(page)
  1606  //            return pageNum <= 3
  1607  //        })
  1608  //
  1609  func (c *Route53RecoveryControlConfig) ListControlPanelsPages(input *ListControlPanelsInput, fn func(*ListControlPanelsOutput, bool) bool) error {
  1610  	return c.ListControlPanelsPagesWithContext(aws.BackgroundContext(), input, fn)
  1611  }
  1612  
  1613  // ListControlPanelsPagesWithContext same as ListControlPanelsPages except
  1614  // it takes a Context and allows setting request options on the pages.
  1615  //
  1616  // The context must be non-nil and will be used for request cancellation. If
  1617  // the context is nil a panic will occur. In the future the SDK may create
  1618  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1619  // for more information on using Contexts.
  1620  func (c *Route53RecoveryControlConfig) ListControlPanelsPagesWithContext(ctx aws.Context, input *ListControlPanelsInput, fn func(*ListControlPanelsOutput, bool) bool, opts ...request.Option) error {
  1621  	p := request.Pagination{
  1622  		NewRequest: func() (*request.Request, error) {
  1623  			var inCpy *ListControlPanelsInput
  1624  			if input != nil {
  1625  				tmp := *input
  1626  				inCpy = &tmp
  1627  			}
  1628  			req, _ := c.ListControlPanelsRequest(inCpy)
  1629  			req.SetContext(ctx)
  1630  			req.ApplyOptions(opts...)
  1631  			return req, nil
  1632  		},
  1633  	}
  1634  
  1635  	for p.Next() {
  1636  		if !fn(p.Page().(*ListControlPanelsOutput), !p.HasNextPage()) {
  1637  			break
  1638  		}
  1639  	}
  1640  
  1641  	return p.Err()
  1642  }
  1643  
  1644  const opListRoutingControls = "ListRoutingControls"
  1645  
  1646  // ListRoutingControlsRequest generates a "aws/request.Request" representing the
  1647  // client's request for the ListRoutingControls operation. The "output" return
  1648  // value will be populated with the request's response once the request completes
  1649  // successfully.
  1650  //
  1651  // Use "Send" method on the returned Request to send the API call to the service.
  1652  // the "output" return value is not valid until after Send returns without error.
  1653  //
  1654  // See ListRoutingControls for more information on using the ListRoutingControls
  1655  // API call, and error handling.
  1656  //
  1657  // This method is useful when you want to inject custom logic or configuration
  1658  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1659  //
  1660  //
  1661  //    // Example sending a request using the ListRoutingControlsRequest method.
  1662  //    req, resp := client.ListRoutingControlsRequest(params)
  1663  //
  1664  //    err := req.Send()
  1665  //    if err == nil { // resp is now filled
  1666  //        fmt.Println(resp)
  1667  //    }
  1668  //
  1669  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListRoutingControls
  1670  func (c *Route53RecoveryControlConfig) ListRoutingControlsRequest(input *ListRoutingControlsInput) (req *request.Request, output *ListRoutingControlsOutput) {
  1671  	op := &request.Operation{
  1672  		Name:       opListRoutingControls,
  1673  		HTTPMethod: "GET",
  1674  		HTTPPath:   "/controlpanel/{ControlPanelArn}/routingcontrols",
  1675  		Paginator: &request.Paginator{
  1676  			InputTokens:     []string{"NextToken"},
  1677  			OutputTokens:    []string{"NextToken"},
  1678  			LimitToken:      "MaxResults",
  1679  			TruncationToken: "",
  1680  		},
  1681  	}
  1682  
  1683  	if input == nil {
  1684  		input = &ListRoutingControlsInput{}
  1685  	}
  1686  
  1687  	output = &ListRoutingControlsOutput{}
  1688  	req = c.newRequest(op, input, output)
  1689  	return
  1690  }
  1691  
  1692  // ListRoutingControls API operation for AWS Route53 Recovery Control Config.
  1693  //
  1694  // Returns an array of routing controls for a control panel. A routing control
  1695  // is an Amazon Route 53 Application Recovery Controller construct that has
  1696  // one of two states: ON and OFF. You can map the routing control state to the
  1697  // state of an Amazon Route 53 health check, which can be used to control routing.
  1698  //
  1699  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  1700  // with awserr.Error's Code and Message methods to get detailed information about
  1701  // the error.
  1702  //
  1703  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  1704  // API operation ListRoutingControls for usage and error information.
  1705  //
  1706  // Returned Error Types:
  1707  //   * ResourceNotFoundException
  1708  //   404 response - The query string contains a syntax error or resource not found.
  1709  //
  1710  //   * ThrottlingException
  1711  //   429 response - ThrottlingException.
  1712  //
  1713  //   * ValidationException
  1714  //   400 response - Multiple causes. For example, you might have a malformed query
  1715  //   string and input parameter might be out of range, or you used parameters
  1716  //   together incorrectly.
  1717  //
  1718  //   * InternalServerException
  1719  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  1720  //
  1721  //   * AccessDeniedException
  1722  //   403 response - AccessDeniedException. You do not have sufficient access to
  1723  //   perform this action.
  1724  //
  1725  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListRoutingControls
  1726  func (c *Route53RecoveryControlConfig) ListRoutingControls(input *ListRoutingControlsInput) (*ListRoutingControlsOutput, error) {
  1727  	req, out := c.ListRoutingControlsRequest(input)
  1728  	return out, req.Send()
  1729  }
  1730  
  1731  // ListRoutingControlsWithContext is the same as ListRoutingControls with the addition of
  1732  // the ability to pass a context and additional request options.
  1733  //
  1734  // See ListRoutingControls for details on how to use this API operation.
  1735  //
  1736  // The context must be non-nil and will be used for request cancellation. If
  1737  // the context is nil a panic will occur. In the future the SDK may create
  1738  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1739  // for more information on using Contexts.
  1740  func (c *Route53RecoveryControlConfig) ListRoutingControlsWithContext(ctx aws.Context, input *ListRoutingControlsInput, opts ...request.Option) (*ListRoutingControlsOutput, error) {
  1741  	req, out := c.ListRoutingControlsRequest(input)
  1742  	req.SetContext(ctx)
  1743  	req.ApplyOptions(opts...)
  1744  	return out, req.Send()
  1745  }
  1746  
  1747  // ListRoutingControlsPages iterates over the pages of a ListRoutingControls operation,
  1748  // calling the "fn" function with the response data for each page. To stop
  1749  // iterating, return false from the fn function.
  1750  //
  1751  // See ListRoutingControls method for more information on how to use this operation.
  1752  //
  1753  // Note: This operation can generate multiple requests to a service.
  1754  //
  1755  //    // Example iterating over at most 3 pages of a ListRoutingControls operation.
  1756  //    pageNum := 0
  1757  //    err := client.ListRoutingControlsPages(params,
  1758  //        func(page *route53recoverycontrolconfig.ListRoutingControlsOutput, lastPage bool) bool {
  1759  //            pageNum++
  1760  //            fmt.Println(page)
  1761  //            return pageNum <= 3
  1762  //        })
  1763  //
  1764  func (c *Route53RecoveryControlConfig) ListRoutingControlsPages(input *ListRoutingControlsInput, fn func(*ListRoutingControlsOutput, bool) bool) error {
  1765  	return c.ListRoutingControlsPagesWithContext(aws.BackgroundContext(), input, fn)
  1766  }
  1767  
  1768  // ListRoutingControlsPagesWithContext same as ListRoutingControlsPages except
  1769  // it takes a Context and allows setting request options on the pages.
  1770  //
  1771  // The context must be non-nil and will be used for request cancellation. If
  1772  // the context is nil a panic will occur. In the future the SDK may create
  1773  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1774  // for more information on using Contexts.
  1775  func (c *Route53RecoveryControlConfig) ListRoutingControlsPagesWithContext(ctx aws.Context, input *ListRoutingControlsInput, fn func(*ListRoutingControlsOutput, bool) bool, opts ...request.Option) error {
  1776  	p := request.Pagination{
  1777  		NewRequest: func() (*request.Request, error) {
  1778  			var inCpy *ListRoutingControlsInput
  1779  			if input != nil {
  1780  				tmp := *input
  1781  				inCpy = &tmp
  1782  			}
  1783  			req, _ := c.ListRoutingControlsRequest(inCpy)
  1784  			req.SetContext(ctx)
  1785  			req.ApplyOptions(opts...)
  1786  			return req, nil
  1787  		},
  1788  	}
  1789  
  1790  	for p.Next() {
  1791  		if !fn(p.Page().(*ListRoutingControlsOutput), !p.HasNextPage()) {
  1792  			break
  1793  		}
  1794  	}
  1795  
  1796  	return p.Err()
  1797  }
  1798  
  1799  const opListSafetyRules = "ListSafetyRules"
  1800  
  1801  // ListSafetyRulesRequest generates a "aws/request.Request" representing the
  1802  // client's request for the ListSafetyRules operation. The "output" return
  1803  // value will be populated with the request's response once the request completes
  1804  // successfully.
  1805  //
  1806  // Use "Send" method on the returned Request to send the API call to the service.
  1807  // the "output" return value is not valid until after Send returns without error.
  1808  //
  1809  // See ListSafetyRules for more information on using the ListSafetyRules
  1810  // API call, and error handling.
  1811  //
  1812  // This method is useful when you want to inject custom logic or configuration
  1813  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1814  //
  1815  //
  1816  //    // Example sending a request using the ListSafetyRulesRequest method.
  1817  //    req, resp := client.ListSafetyRulesRequest(params)
  1818  //
  1819  //    err := req.Send()
  1820  //    if err == nil { // resp is now filled
  1821  //        fmt.Println(resp)
  1822  //    }
  1823  //
  1824  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListSafetyRules
  1825  func (c *Route53RecoveryControlConfig) ListSafetyRulesRequest(input *ListSafetyRulesInput) (req *request.Request, output *ListSafetyRulesOutput) {
  1826  	op := &request.Operation{
  1827  		Name:       opListSafetyRules,
  1828  		HTTPMethod: "GET",
  1829  		HTTPPath:   "/controlpanel/{ControlPanelArn}/safetyrules",
  1830  		Paginator: &request.Paginator{
  1831  			InputTokens:     []string{"NextToken"},
  1832  			OutputTokens:    []string{"NextToken"},
  1833  			LimitToken:      "MaxResults",
  1834  			TruncationToken: "",
  1835  		},
  1836  	}
  1837  
  1838  	if input == nil {
  1839  		input = &ListSafetyRulesInput{}
  1840  	}
  1841  
  1842  	output = &ListSafetyRulesOutput{}
  1843  	req = c.newRequest(op, input, output)
  1844  	return
  1845  }
  1846  
  1847  // ListSafetyRules API operation for AWS Route53 Recovery Control Config.
  1848  //
  1849  // List the safety rules (the assertion rules and gating rules) that you've
  1850  // defined for the routing controls in a control panel.
  1851  //
  1852  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  1853  // with awserr.Error's Code and Message methods to get detailed information about
  1854  // the error.
  1855  //
  1856  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  1857  // API operation ListSafetyRules for usage and error information.
  1858  //
  1859  // Returned Error Types:
  1860  //   * ResourceNotFoundException
  1861  //   404 response - The query string contains a syntax error or resource not found.
  1862  //
  1863  //   * ThrottlingException
  1864  //   429 response - ThrottlingException.
  1865  //
  1866  //   * ValidationException
  1867  //   400 response - Multiple causes. For example, you might have a malformed query
  1868  //   string and input parameter might be out of range, or you used parameters
  1869  //   together incorrectly.
  1870  //
  1871  //   * InternalServerException
  1872  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  1873  //
  1874  //   * AccessDeniedException
  1875  //   403 response - AccessDeniedException. You do not have sufficient access to
  1876  //   perform this action.
  1877  //
  1878  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/ListSafetyRules
  1879  func (c *Route53RecoveryControlConfig) ListSafetyRules(input *ListSafetyRulesInput) (*ListSafetyRulesOutput, error) {
  1880  	req, out := c.ListSafetyRulesRequest(input)
  1881  	return out, req.Send()
  1882  }
  1883  
  1884  // ListSafetyRulesWithContext is the same as ListSafetyRules with the addition of
  1885  // the ability to pass a context and additional request options.
  1886  //
  1887  // See ListSafetyRules for details on how to use this API operation.
  1888  //
  1889  // The context must be non-nil and will be used for request cancellation. If
  1890  // the context is nil a panic will occur. In the future the SDK may create
  1891  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1892  // for more information on using Contexts.
  1893  func (c *Route53RecoveryControlConfig) ListSafetyRulesWithContext(ctx aws.Context, input *ListSafetyRulesInput, opts ...request.Option) (*ListSafetyRulesOutput, error) {
  1894  	req, out := c.ListSafetyRulesRequest(input)
  1895  	req.SetContext(ctx)
  1896  	req.ApplyOptions(opts...)
  1897  	return out, req.Send()
  1898  }
  1899  
  1900  // ListSafetyRulesPages iterates over the pages of a ListSafetyRules operation,
  1901  // calling the "fn" function with the response data for each page. To stop
  1902  // iterating, return false from the fn function.
  1903  //
  1904  // See ListSafetyRules method for more information on how to use this operation.
  1905  //
  1906  // Note: This operation can generate multiple requests to a service.
  1907  //
  1908  //    // Example iterating over at most 3 pages of a ListSafetyRules operation.
  1909  //    pageNum := 0
  1910  //    err := client.ListSafetyRulesPages(params,
  1911  //        func(page *route53recoverycontrolconfig.ListSafetyRulesOutput, lastPage bool) bool {
  1912  //            pageNum++
  1913  //            fmt.Println(page)
  1914  //            return pageNum <= 3
  1915  //        })
  1916  //
  1917  func (c *Route53RecoveryControlConfig) ListSafetyRulesPages(input *ListSafetyRulesInput, fn func(*ListSafetyRulesOutput, bool) bool) error {
  1918  	return c.ListSafetyRulesPagesWithContext(aws.BackgroundContext(), input, fn)
  1919  }
  1920  
  1921  // ListSafetyRulesPagesWithContext same as ListSafetyRulesPages except
  1922  // it takes a Context and allows setting request options on the pages.
  1923  //
  1924  // The context must be non-nil and will be used for request cancellation. If
  1925  // the context is nil a panic will occur. In the future the SDK may create
  1926  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  1927  // for more information on using Contexts.
  1928  func (c *Route53RecoveryControlConfig) ListSafetyRulesPagesWithContext(ctx aws.Context, input *ListSafetyRulesInput, fn func(*ListSafetyRulesOutput, bool) bool, opts ...request.Option) error {
  1929  	p := request.Pagination{
  1930  		NewRequest: func() (*request.Request, error) {
  1931  			var inCpy *ListSafetyRulesInput
  1932  			if input != nil {
  1933  				tmp := *input
  1934  				inCpy = &tmp
  1935  			}
  1936  			req, _ := c.ListSafetyRulesRequest(inCpy)
  1937  			req.SetContext(ctx)
  1938  			req.ApplyOptions(opts...)
  1939  			return req, nil
  1940  		},
  1941  	}
  1942  
  1943  	for p.Next() {
  1944  		if !fn(p.Page().(*ListSafetyRulesOutput), !p.HasNextPage()) {
  1945  			break
  1946  		}
  1947  	}
  1948  
  1949  	return p.Err()
  1950  }
  1951  
  1952  const opUpdateControlPanel = "UpdateControlPanel"
  1953  
  1954  // UpdateControlPanelRequest generates a "aws/request.Request" representing the
  1955  // client's request for the UpdateControlPanel operation. The "output" return
  1956  // value will be populated with the request's response once the request completes
  1957  // successfully.
  1958  //
  1959  // Use "Send" method on the returned Request to send the API call to the service.
  1960  // the "output" return value is not valid until after Send returns without error.
  1961  //
  1962  // See UpdateControlPanel for more information on using the UpdateControlPanel
  1963  // API call, and error handling.
  1964  //
  1965  // This method is useful when you want to inject custom logic or configuration
  1966  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  1967  //
  1968  //
  1969  //    // Example sending a request using the UpdateControlPanelRequest method.
  1970  //    req, resp := client.UpdateControlPanelRequest(params)
  1971  //
  1972  //    err := req.Send()
  1973  //    if err == nil { // resp is now filled
  1974  //        fmt.Println(resp)
  1975  //    }
  1976  //
  1977  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/UpdateControlPanel
  1978  func (c *Route53RecoveryControlConfig) UpdateControlPanelRequest(input *UpdateControlPanelInput) (req *request.Request, output *UpdateControlPanelOutput) {
  1979  	op := &request.Operation{
  1980  		Name:       opUpdateControlPanel,
  1981  		HTTPMethod: "PUT",
  1982  		HTTPPath:   "/controlpanel",
  1983  	}
  1984  
  1985  	if input == nil {
  1986  		input = &UpdateControlPanelInput{}
  1987  	}
  1988  
  1989  	output = &UpdateControlPanelOutput{}
  1990  	req = c.newRequest(op, input, output)
  1991  	return
  1992  }
  1993  
  1994  // UpdateControlPanel API operation for AWS Route53 Recovery Control Config.
  1995  //
  1996  // Updates a control panel. The only update you can make to a control panel
  1997  // is to change the name of the control panel.
  1998  //
  1999  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  2000  // with awserr.Error's Code and Message methods to get detailed information about
  2001  // the error.
  2002  //
  2003  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  2004  // API operation UpdateControlPanel for usage and error information.
  2005  //
  2006  // Returned Error Types:
  2007  //   * ValidationException
  2008  //   400 response - Multiple causes. For example, you might have a malformed query
  2009  //   string and input parameter might be out of range, or you used parameters
  2010  //   together incorrectly.
  2011  //
  2012  //   * InternalServerException
  2013  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  2014  //
  2015  //   * AccessDeniedException
  2016  //   403 response - AccessDeniedException. You do not have sufficient access to
  2017  //   perform this action.
  2018  //
  2019  //   * ResourceNotFoundException
  2020  //   404 response - The query string contains a syntax error or resource not found.
  2021  //
  2022  //   * ThrottlingException
  2023  //   429 response - ThrottlingException.
  2024  //
  2025  //   * ConflictException
  2026  //   409 response - ConflictException.
  2027  //
  2028  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/UpdateControlPanel
  2029  func (c *Route53RecoveryControlConfig) UpdateControlPanel(input *UpdateControlPanelInput) (*UpdateControlPanelOutput, error) {
  2030  	req, out := c.UpdateControlPanelRequest(input)
  2031  	return out, req.Send()
  2032  }
  2033  
  2034  // UpdateControlPanelWithContext is the same as UpdateControlPanel with the addition of
  2035  // the ability to pass a context and additional request options.
  2036  //
  2037  // See UpdateControlPanel for details on how to use this API operation.
  2038  //
  2039  // The context must be non-nil and will be used for request cancellation. If
  2040  // the context is nil a panic will occur. In the future the SDK may create
  2041  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  2042  // for more information on using Contexts.
  2043  func (c *Route53RecoveryControlConfig) UpdateControlPanelWithContext(ctx aws.Context, input *UpdateControlPanelInput, opts ...request.Option) (*UpdateControlPanelOutput, error) {
  2044  	req, out := c.UpdateControlPanelRequest(input)
  2045  	req.SetContext(ctx)
  2046  	req.ApplyOptions(opts...)
  2047  	return out, req.Send()
  2048  }
  2049  
  2050  const opUpdateRoutingControl = "UpdateRoutingControl"
  2051  
  2052  // UpdateRoutingControlRequest generates a "aws/request.Request" representing the
  2053  // client's request for the UpdateRoutingControl operation. The "output" return
  2054  // value will be populated with the request's response once the request completes
  2055  // successfully.
  2056  //
  2057  // Use "Send" method on the returned Request to send the API call to the service.
  2058  // the "output" return value is not valid until after Send returns without error.
  2059  //
  2060  // See UpdateRoutingControl for more information on using the UpdateRoutingControl
  2061  // API call, and error handling.
  2062  //
  2063  // This method is useful when you want to inject custom logic or configuration
  2064  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  2065  //
  2066  //
  2067  //    // Example sending a request using the UpdateRoutingControlRequest method.
  2068  //    req, resp := client.UpdateRoutingControlRequest(params)
  2069  //
  2070  //    err := req.Send()
  2071  //    if err == nil { // resp is now filled
  2072  //        fmt.Println(resp)
  2073  //    }
  2074  //
  2075  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/UpdateRoutingControl
  2076  func (c *Route53RecoveryControlConfig) UpdateRoutingControlRequest(input *UpdateRoutingControlInput) (req *request.Request, output *UpdateRoutingControlOutput) {
  2077  	op := &request.Operation{
  2078  		Name:       opUpdateRoutingControl,
  2079  		HTTPMethod: "PUT",
  2080  		HTTPPath:   "/routingcontrol",
  2081  	}
  2082  
  2083  	if input == nil {
  2084  		input = &UpdateRoutingControlInput{}
  2085  	}
  2086  
  2087  	output = &UpdateRoutingControlOutput{}
  2088  	req = c.newRequest(op, input, output)
  2089  	return
  2090  }
  2091  
  2092  // UpdateRoutingControl API operation for AWS Route53 Recovery Control Config.
  2093  //
  2094  // Updates a routing control. You can only update the name of the routing control.
  2095  // To get or update the routing control state, see the Recovery Cluster (data
  2096  // plane) API actions for Amazon Route 53 Application Recovery Controller.
  2097  //
  2098  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  2099  // with awserr.Error's Code and Message methods to get detailed information about
  2100  // the error.
  2101  //
  2102  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  2103  // API operation UpdateRoutingControl for usage and error information.
  2104  //
  2105  // Returned Error Types:
  2106  //   * ValidationException
  2107  //   400 response - Multiple causes. For example, you might have a malformed query
  2108  //   string and input parameter might be out of range, or you used parameters
  2109  //   together incorrectly.
  2110  //
  2111  //   * InternalServerException
  2112  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  2113  //
  2114  //   * AccessDeniedException
  2115  //   403 response - AccessDeniedException. You do not have sufficient access to
  2116  //   perform this action.
  2117  //
  2118  //   * ResourceNotFoundException
  2119  //   404 response - The query string contains a syntax error or resource not found.
  2120  //
  2121  //   * ThrottlingException
  2122  //   429 response - ThrottlingException.
  2123  //
  2124  //   * ConflictException
  2125  //   409 response - ConflictException.
  2126  //
  2127  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/UpdateRoutingControl
  2128  func (c *Route53RecoveryControlConfig) UpdateRoutingControl(input *UpdateRoutingControlInput) (*UpdateRoutingControlOutput, error) {
  2129  	req, out := c.UpdateRoutingControlRequest(input)
  2130  	return out, req.Send()
  2131  }
  2132  
  2133  // UpdateRoutingControlWithContext is the same as UpdateRoutingControl with the addition of
  2134  // the ability to pass a context and additional request options.
  2135  //
  2136  // See UpdateRoutingControl for details on how to use this API operation.
  2137  //
  2138  // The context must be non-nil and will be used for request cancellation. If
  2139  // the context is nil a panic will occur. In the future the SDK may create
  2140  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  2141  // for more information on using Contexts.
  2142  func (c *Route53RecoveryControlConfig) UpdateRoutingControlWithContext(ctx aws.Context, input *UpdateRoutingControlInput, opts ...request.Option) (*UpdateRoutingControlOutput, error) {
  2143  	req, out := c.UpdateRoutingControlRequest(input)
  2144  	req.SetContext(ctx)
  2145  	req.ApplyOptions(opts...)
  2146  	return out, req.Send()
  2147  }
  2148  
  2149  const opUpdateSafetyRule = "UpdateSafetyRule"
  2150  
  2151  // UpdateSafetyRuleRequest generates a "aws/request.Request" representing the
  2152  // client's request for the UpdateSafetyRule operation. The "output" return
  2153  // value will be populated with the request's response once the request completes
  2154  // successfully.
  2155  //
  2156  // Use "Send" method on the returned Request to send the API call to the service.
  2157  // the "output" return value is not valid until after Send returns without error.
  2158  //
  2159  // See UpdateSafetyRule for more information on using the UpdateSafetyRule
  2160  // API call, and error handling.
  2161  //
  2162  // This method is useful when you want to inject custom logic or configuration
  2163  // into the SDK's request lifecycle. Such as custom headers, or retry logic.
  2164  //
  2165  //
  2166  //    // Example sending a request using the UpdateSafetyRuleRequest method.
  2167  //    req, resp := client.UpdateSafetyRuleRequest(params)
  2168  //
  2169  //    err := req.Send()
  2170  //    if err == nil { // resp is now filled
  2171  //        fmt.Println(resp)
  2172  //    }
  2173  //
  2174  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/UpdateSafetyRule
  2175  func (c *Route53RecoveryControlConfig) UpdateSafetyRuleRequest(input *UpdateSafetyRuleInput) (req *request.Request, output *UpdateSafetyRuleOutput) {
  2176  	op := &request.Operation{
  2177  		Name:       opUpdateSafetyRule,
  2178  		HTTPMethod: "PUT",
  2179  		HTTPPath:   "/safetyrule",
  2180  	}
  2181  
  2182  	if input == nil {
  2183  		input = &UpdateSafetyRuleInput{}
  2184  	}
  2185  
  2186  	output = &UpdateSafetyRuleOutput{}
  2187  	req = c.newRequest(op, input, output)
  2188  	return
  2189  }
  2190  
  2191  // UpdateSafetyRule API operation for AWS Route53 Recovery Control Config.
  2192  //
  2193  // Update a safety rule (an assertion rule or gating rule) for the routing controls
  2194  // in a control panel. You can only update the name and the waiting period for
  2195  // a safety rule. To make other updates, delete the safety rule and create a
  2196  // new safety rule.
  2197  //
  2198  // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  2199  // with awserr.Error's Code and Message methods to get detailed information about
  2200  // the error.
  2201  //
  2202  // See the AWS API reference guide for AWS Route53 Recovery Control Config's
  2203  // API operation UpdateSafetyRule for usage and error information.
  2204  //
  2205  // Returned Error Types:
  2206  //   * ResourceNotFoundException
  2207  //   404 response - The query string contains a syntax error or resource not found.
  2208  //
  2209  //   * ValidationException
  2210  //   400 response - Multiple causes. For example, you might have a malformed query
  2211  //   string and input parameter might be out of range, or you used parameters
  2212  //   together incorrectly.
  2213  //
  2214  //   * InternalServerException
  2215  //   500 response - InternalServiceError. Temporary service error. Retry the request.
  2216  //
  2217  // See also, https://docs.aws.amazon.com/goto/WebAPI/route53-recovery-control-config-2020-11-02/UpdateSafetyRule
  2218  func (c *Route53RecoveryControlConfig) UpdateSafetyRule(input *UpdateSafetyRuleInput) (*UpdateSafetyRuleOutput, error) {
  2219  	req, out := c.UpdateSafetyRuleRequest(input)
  2220  	return out, req.Send()
  2221  }
  2222  
  2223  // UpdateSafetyRuleWithContext is the same as UpdateSafetyRule with the addition of
  2224  // the ability to pass a context and additional request options.
  2225  //
  2226  // See UpdateSafetyRule for details on how to use this API operation.
  2227  //
  2228  // The context must be non-nil and will be used for request cancellation. If
  2229  // the context is nil a panic will occur. In the future the SDK may create
  2230  // sub-contexts for http.Requests. See https://golang.org/pkg/context/
  2231  // for more information on using Contexts.
  2232  func (c *Route53RecoveryControlConfig) UpdateSafetyRuleWithContext(ctx aws.Context, input *UpdateSafetyRuleInput, opts ...request.Option) (*UpdateSafetyRuleOutput, error) {
  2233  	req, out := c.UpdateSafetyRuleRequest(input)
  2234  	req.SetContext(ctx)
  2235  	req.ApplyOptions(opts...)
  2236  	return out, req.Send()
  2237  }
  2238  
  2239  // 403 response - AccessDeniedException. You do not have sufficient access to
  2240  // perform this action.
  2241  type AccessDeniedException struct {
  2242  	_            struct{}                  `type:"structure"`
  2243  	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
  2244  
  2245  	Message_ *string `locationName:"message" type:"string"`
  2246  }
  2247  
  2248  // String returns the string representation.
  2249  //
  2250  // API parameter values that are decorated as "sensitive" in the API will not
  2251  // be included in the string output. The member name will be present, but the
  2252  // value will be replaced with "sensitive".
  2253  func (s AccessDeniedException) String() string {
  2254  	return awsutil.Prettify(s)
  2255  }
  2256  
  2257  // GoString returns the string representation.
  2258  //
  2259  // API parameter values that are decorated as "sensitive" in the API will not
  2260  // be included in the string output. The member name will be present, but the
  2261  // value will be replaced with "sensitive".
  2262  func (s AccessDeniedException) GoString() string {
  2263  	return s.String()
  2264  }
  2265  
  2266  func newErrorAccessDeniedException(v protocol.ResponseMetadata) error {
  2267  	return &AccessDeniedException{
  2268  		RespMetadata: v,
  2269  	}
  2270  }
  2271  
  2272  // Code returns the exception type name.
  2273  func (s *AccessDeniedException) Code() string {
  2274  	return "AccessDeniedException"
  2275  }
  2276  
  2277  // Message returns the exception's message.
  2278  func (s *AccessDeniedException) Message() string {
  2279  	if s.Message_ != nil {
  2280  		return *s.Message_
  2281  	}
  2282  	return ""
  2283  }
  2284  
  2285  // OrigErr always returns nil, satisfies awserr.Error interface.
  2286  func (s *AccessDeniedException) OrigErr() error {
  2287  	return nil
  2288  }
  2289  
  2290  func (s *AccessDeniedException) Error() string {
  2291  	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
  2292  }
  2293  
  2294  // Status code returns the HTTP status code for the request's response error.
  2295  func (s *AccessDeniedException) StatusCode() int {
  2296  	return s.RespMetadata.StatusCode
  2297  }
  2298  
  2299  // RequestID returns the service's response RequestID for request.
  2300  func (s *AccessDeniedException) RequestID() string {
  2301  	return s.RespMetadata.RequestID
  2302  }
  2303  
  2304  // An assertion rule enforces that, when a routing control state is changed,
  2305  // the criteria set by the rule configuration is met. Otherwise, the change
  2306  // to the routing control is not accepted.
  2307  type AssertionRule struct {
  2308  	_ struct{} `type:"structure"`
  2309  
  2310  	// The routing controls that are part of transactions that are evaluated to
  2311  	// determine if a request to change a routing control state is allowed. For
  2312  	// example, you might include three routing controls, one for each of three
  2313  	// Amazon Web Services Regions.
  2314  	//
  2315  	// AssertedControls is a required field
  2316  	AssertedControls []*string `type:"list" required:"true"`
  2317  
  2318  	// The Amazon Resource Name (ARN) of the control panel.
  2319  	//
  2320  	// ControlPanelArn is a required field
  2321  	ControlPanelArn *string `type:"string" required:"true"`
  2322  
  2323  	// Name of the assertion rule. You can use any non-white space character in
  2324  	// the name.
  2325  	//
  2326  	// Name is a required field
  2327  	Name *string `min:"1" type:"string" required:"true"`
  2328  
  2329  	// The criteria that you set for specific assertion controls (routing controls)
  2330  	// that designate how many controls must be enabled as the result of a transaction.
  2331  	// For example, if you have three assertion controls, you might specify atleast
  2332  	// 2 for your rule configuration. This means that at least two assertion controls
  2333  	// must be enabled, so that at least two Amazon Web Services Regions are enabled.
  2334  	//
  2335  	// RuleConfig is a required field
  2336  	RuleConfig *RuleConfig `type:"structure" required:"true"`
  2337  
  2338  	// The Amazon Resource Name (ARN) of the assertion rule.
  2339  	//
  2340  	// SafetyRuleArn is a required field
  2341  	SafetyRuleArn *string `type:"string" required:"true"`
  2342  
  2343  	// The deployment status of an assertion rule. Status can be one of the following:
  2344  	// PENDING, DEPLOYED, PENDING_DELETION.
  2345  	//
  2346  	// Status is a required field
  2347  	Status *string `type:"string" required:"true" enum:"Status"`
  2348  
  2349  	// An evaluation period, in milliseconds (ms), during which any request against
  2350  	// the target routing controls will fail. This helps prevent "flapping" of state.
  2351  	// The wait period is 5000 ms by default, but you can choose a custom value.
  2352  	//
  2353  	// WaitPeriodMs is a required field
  2354  	WaitPeriodMs *int64 `type:"integer" required:"true"`
  2355  }
  2356  
  2357  // String returns the string representation.
  2358  //
  2359  // API parameter values that are decorated as "sensitive" in the API will not
  2360  // be included in the string output. The member name will be present, but the
  2361  // value will be replaced with "sensitive".
  2362  func (s AssertionRule) String() string {
  2363  	return awsutil.Prettify(s)
  2364  }
  2365  
  2366  // GoString returns the string representation.
  2367  //
  2368  // API parameter values that are decorated as "sensitive" in the API will not
  2369  // be included in the string output. The member name will be present, but the
  2370  // value will be replaced with "sensitive".
  2371  func (s AssertionRule) GoString() string {
  2372  	return s.String()
  2373  }
  2374  
  2375  // SetAssertedControls sets the AssertedControls field's value.
  2376  func (s *AssertionRule) SetAssertedControls(v []*string) *AssertionRule {
  2377  	s.AssertedControls = v
  2378  	return s
  2379  }
  2380  
  2381  // SetControlPanelArn sets the ControlPanelArn field's value.
  2382  func (s *AssertionRule) SetControlPanelArn(v string) *AssertionRule {
  2383  	s.ControlPanelArn = &v
  2384  	return s
  2385  }
  2386  
  2387  // SetName sets the Name field's value.
  2388  func (s *AssertionRule) SetName(v string) *AssertionRule {
  2389  	s.Name = &v
  2390  	return s
  2391  }
  2392  
  2393  // SetRuleConfig sets the RuleConfig field's value.
  2394  func (s *AssertionRule) SetRuleConfig(v *RuleConfig) *AssertionRule {
  2395  	s.RuleConfig = v
  2396  	return s
  2397  }
  2398  
  2399  // SetSafetyRuleArn sets the SafetyRuleArn field's value.
  2400  func (s *AssertionRule) SetSafetyRuleArn(v string) *AssertionRule {
  2401  	s.SafetyRuleArn = &v
  2402  	return s
  2403  }
  2404  
  2405  // SetStatus sets the Status field's value.
  2406  func (s *AssertionRule) SetStatus(v string) *AssertionRule {
  2407  	s.Status = &v
  2408  	return s
  2409  }
  2410  
  2411  // SetWaitPeriodMs sets the WaitPeriodMs field's value.
  2412  func (s *AssertionRule) SetWaitPeriodMs(v int64) *AssertionRule {
  2413  	s.WaitPeriodMs = &v
  2414  	return s
  2415  }
  2416  
  2417  // An update to an assertion rule. You can update the name or the evaluation
  2418  // period (wait period). If you don't specify one of the items to update, the
  2419  // item is unchanged.
  2420  type AssertionRuleUpdate struct {
  2421  	_ struct{} `type:"structure"`
  2422  
  2423  	// The name of the assertion rule. You can use any non-white space character
  2424  	// in the name.
  2425  	//
  2426  	// Name is a required field
  2427  	Name *string `min:"1" type:"string" required:"true"`
  2428  
  2429  	// The Amazon Resource Name (ARN) of the assertion rule.
  2430  	//
  2431  	// SafetyRuleArn is a required field
  2432  	SafetyRuleArn *string `type:"string" required:"true"`
  2433  
  2434  	// An evaluation period, in milliseconds (ms), during which any request against
  2435  	// the target routing controls will fail. This helps prevent "flapping" of state.
  2436  	// The wait period is 5000 ms by default, but you can choose a custom value.
  2437  	//
  2438  	// WaitPeriodMs is a required field
  2439  	WaitPeriodMs *int64 `type:"integer" required:"true"`
  2440  }
  2441  
  2442  // String returns the string representation.
  2443  //
  2444  // API parameter values that are decorated as "sensitive" in the API will not
  2445  // be included in the string output. The member name will be present, but the
  2446  // value will be replaced with "sensitive".
  2447  func (s AssertionRuleUpdate) String() string {
  2448  	return awsutil.Prettify(s)
  2449  }
  2450  
  2451  // GoString returns the string representation.
  2452  //
  2453  // API parameter values that are decorated as "sensitive" in the API will not
  2454  // be included in the string output. The member name will be present, but the
  2455  // value will be replaced with "sensitive".
  2456  func (s AssertionRuleUpdate) GoString() string {
  2457  	return s.String()
  2458  }
  2459  
  2460  // Validate inspects the fields of the type to determine if they are valid.
  2461  func (s *AssertionRuleUpdate) Validate() error {
  2462  	invalidParams := request.ErrInvalidParams{Context: "AssertionRuleUpdate"}
  2463  	if s.Name == nil {
  2464  		invalidParams.Add(request.NewErrParamRequired("Name"))
  2465  	}
  2466  	if s.Name != nil && len(*s.Name) < 1 {
  2467  		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
  2468  	}
  2469  	if s.SafetyRuleArn == nil {
  2470  		invalidParams.Add(request.NewErrParamRequired("SafetyRuleArn"))
  2471  	}
  2472  	if s.WaitPeriodMs == nil {
  2473  		invalidParams.Add(request.NewErrParamRequired("WaitPeriodMs"))
  2474  	}
  2475  
  2476  	if invalidParams.Len() > 0 {
  2477  		return invalidParams
  2478  	}
  2479  	return nil
  2480  }
  2481  
  2482  // SetName sets the Name field's value.
  2483  func (s *AssertionRuleUpdate) SetName(v string) *AssertionRuleUpdate {
  2484  	s.Name = &v
  2485  	return s
  2486  }
  2487  
  2488  // SetSafetyRuleArn sets the SafetyRuleArn field's value.
  2489  func (s *AssertionRuleUpdate) SetSafetyRuleArn(v string) *AssertionRuleUpdate {
  2490  	s.SafetyRuleArn = &v
  2491  	return s
  2492  }
  2493  
  2494  // SetWaitPeriodMs sets the WaitPeriodMs field's value.
  2495  func (s *AssertionRuleUpdate) SetWaitPeriodMs(v int64) *AssertionRuleUpdate {
  2496  	s.WaitPeriodMs = &v
  2497  	return s
  2498  }
  2499  
  2500  // A cluster is a set of five consensus-forming Regional endpoints that represent
  2501  // the infrastructure that hosts your routing controls. Typically, you host
  2502  // together on one cluster all of the routing controls for your applications.
  2503  type Cluster struct {
  2504  	_ struct{} `type:"structure"`
  2505  
  2506  	// The Amazon Resource Name (ARN) of the cluster.
  2507  	ClusterArn *string `type:"string"`
  2508  
  2509  	// Endpoints for a cluster. Specify one of these endpoints when you want to
  2510  	// set or retrieve a routing control state in the cluster.
  2511  	//
  2512  	// To get or update the routing control state, see the Amazon Route 53 Application
  2513  	// Recovery Controller Cluster (Data Plane) Actions.
  2514  	ClusterEndpoints []*ClusterEndpoint `type:"list"`
  2515  
  2516  	// The name of the cluster.
  2517  	Name *string `min:"1" type:"string"`
  2518  
  2519  	// Deployment status of a resource. Status can be one of the following: PENDING,
  2520  	// DEPLOYED, PENDING_DELETION.
  2521  	Status *string `type:"string" enum:"Status"`
  2522  }
  2523  
  2524  // String returns the string representation.
  2525  //
  2526  // API parameter values that are decorated as "sensitive" in the API will not
  2527  // be included in the string output. The member name will be present, but the
  2528  // value will be replaced with "sensitive".
  2529  func (s Cluster) String() string {
  2530  	return awsutil.Prettify(s)
  2531  }
  2532  
  2533  // GoString returns the string representation.
  2534  //
  2535  // API parameter values that are decorated as "sensitive" in the API will not
  2536  // be included in the string output. The member name will be present, but the
  2537  // value will be replaced with "sensitive".
  2538  func (s Cluster) GoString() string {
  2539  	return s.String()
  2540  }
  2541  
  2542  // SetClusterArn sets the ClusterArn field's value.
  2543  func (s *Cluster) SetClusterArn(v string) *Cluster {
  2544  	s.ClusterArn = &v
  2545  	return s
  2546  }
  2547  
  2548  // SetClusterEndpoints sets the ClusterEndpoints field's value.
  2549  func (s *Cluster) SetClusterEndpoints(v []*ClusterEndpoint) *Cluster {
  2550  	s.ClusterEndpoints = v
  2551  	return s
  2552  }
  2553  
  2554  // SetName sets the Name field's value.
  2555  func (s *Cluster) SetName(v string) *Cluster {
  2556  	s.Name = &v
  2557  	return s
  2558  }
  2559  
  2560  // SetStatus sets the Status field's value.
  2561  func (s *Cluster) SetStatus(v string) *Cluster {
  2562  	s.Status = &v
  2563  	return s
  2564  }
  2565  
  2566  // A cluster endpoint. Specify an endpoint when you want to set or retrieve
  2567  // a routing control state in the cluster.
  2568  type ClusterEndpoint struct {
  2569  	_ struct{} `type:"structure"`
  2570  
  2571  	// A cluster endpoint. Specify an endpoint and Amazon Web Services Region when
  2572  	// you want to set or retrieve a routing control state in the cluster.
  2573  	//
  2574  	// To get or update the routing control state, see the Amazon Route 53 Application
  2575  	// Recovery Controller Cluster (Data Plane) Actions.
  2576  	Endpoint *string `min:"1" type:"string"`
  2577  
  2578  	// The Amazon Web Services Region for a cluster endpoint.
  2579  	Region *string `min:"1" type:"string"`
  2580  }
  2581  
  2582  // String returns the string representation.
  2583  //
  2584  // API parameter values that are decorated as "sensitive" in the API will not
  2585  // be included in the string output. The member name will be present, but the
  2586  // value will be replaced with "sensitive".
  2587  func (s ClusterEndpoint) String() string {
  2588  	return awsutil.Prettify(s)
  2589  }
  2590  
  2591  // GoString returns the string representation.
  2592  //
  2593  // API parameter values that are decorated as "sensitive" in the API will not
  2594  // be included in the string output. The member name will be present, but the
  2595  // value will be replaced with "sensitive".
  2596  func (s ClusterEndpoint) GoString() string {
  2597  	return s.String()
  2598  }
  2599  
  2600  // SetEndpoint sets the Endpoint field's value.
  2601  func (s *ClusterEndpoint) SetEndpoint(v string) *ClusterEndpoint {
  2602  	s.Endpoint = &v
  2603  	return s
  2604  }
  2605  
  2606  // SetRegion sets the Region field's value.
  2607  func (s *ClusterEndpoint) SetRegion(v string) *ClusterEndpoint {
  2608  	s.Region = &v
  2609  	return s
  2610  }
  2611  
  2612  // 409 response - ConflictException.
  2613  type ConflictException struct {
  2614  	_            struct{}                  `type:"structure"`
  2615  	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
  2616  
  2617  	Message_ *string `locationName:"message" type:"string"`
  2618  }
  2619  
  2620  // String returns the string representation.
  2621  //
  2622  // API parameter values that are decorated as "sensitive" in the API will not
  2623  // be included in the string output. The member name will be present, but the
  2624  // value will be replaced with "sensitive".
  2625  func (s ConflictException) String() string {
  2626  	return awsutil.Prettify(s)
  2627  }
  2628  
  2629  // GoString returns the string representation.
  2630  //
  2631  // API parameter values that are decorated as "sensitive" in the API will not
  2632  // be included in the string output. The member name will be present, but the
  2633  // value will be replaced with "sensitive".
  2634  func (s ConflictException) GoString() string {
  2635  	return s.String()
  2636  }
  2637  
  2638  func newErrorConflictException(v protocol.ResponseMetadata) error {
  2639  	return &ConflictException{
  2640  		RespMetadata: v,
  2641  	}
  2642  }
  2643  
  2644  // Code returns the exception type name.
  2645  func (s *ConflictException) Code() string {
  2646  	return "ConflictException"
  2647  }
  2648  
  2649  // Message returns the exception's message.
  2650  func (s *ConflictException) Message() string {
  2651  	if s.Message_ != nil {
  2652  		return *s.Message_
  2653  	}
  2654  	return ""
  2655  }
  2656  
  2657  // OrigErr always returns nil, satisfies awserr.Error interface.
  2658  func (s *ConflictException) OrigErr() error {
  2659  	return nil
  2660  }
  2661  
  2662  func (s *ConflictException) Error() string {
  2663  	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
  2664  }
  2665  
  2666  // Status code returns the HTTP status code for the request's response error.
  2667  func (s *ConflictException) StatusCode() int {
  2668  	return s.RespMetadata.StatusCode
  2669  }
  2670  
  2671  // RequestID returns the service's response RequestID for request.
  2672  func (s *ConflictException) RequestID() string {
  2673  	return s.RespMetadata.RequestID
  2674  }
  2675  
  2676  // A control panel represents a group of routing controls that can be changed
  2677  // together in a single transaction.
  2678  type ControlPanel struct {
  2679  	_ struct{} `type:"structure"`
  2680  
  2681  	// The Amazon Resource Name (ARN) of the cluster that includes the control panel.
  2682  	ClusterArn *string `type:"string"`
  2683  
  2684  	// The Amazon Resource Name (ARN) of the control panel.
  2685  	ControlPanelArn *string `type:"string"`
  2686  
  2687  	// A flag that Amazon Route 53 Application Recovery Controller sets to true
  2688  	// to designate the default control panel for a cluster. When you create a cluster,
  2689  	// Amazon Route 53 Application Recovery Controller creates a control panel,
  2690  	// and sets this flag for that control panel. If you create a control panel
  2691  	// yourself, this flag is set to false.
  2692  	DefaultControlPanel *bool `type:"boolean"`
  2693  
  2694  	// The name of the control panel. You can use any non-white space character
  2695  	// in the name.
  2696  	Name *string `min:"1" type:"string"`
  2697  
  2698  	// The number of routing controls in the control panel.
  2699  	RoutingControlCount *int64 `type:"integer"`
  2700  
  2701  	// The deployment status of control panel. Status can be one of the following:
  2702  	// PENDING, DEPLOYED, PENDING_DELETION.
  2703  	Status *string `type:"string" enum:"Status"`
  2704  }
  2705  
  2706  // String returns the string representation.
  2707  //
  2708  // API parameter values that are decorated as "sensitive" in the API will not
  2709  // be included in the string output. The member name will be present, but the
  2710  // value will be replaced with "sensitive".
  2711  func (s ControlPanel) String() string {
  2712  	return awsutil.Prettify(s)
  2713  }
  2714  
  2715  // GoString returns the string representation.
  2716  //
  2717  // API parameter values that are decorated as "sensitive" in the API will not
  2718  // be included in the string output. The member name will be present, but the
  2719  // value will be replaced with "sensitive".
  2720  func (s ControlPanel) GoString() string {
  2721  	return s.String()
  2722  }
  2723  
  2724  // SetClusterArn sets the ClusterArn field's value.
  2725  func (s *ControlPanel) SetClusterArn(v string) *ControlPanel {
  2726  	s.ClusterArn = &v
  2727  	return s
  2728  }
  2729  
  2730  // SetControlPanelArn sets the ControlPanelArn field's value.
  2731  func (s *ControlPanel) SetControlPanelArn(v string) *ControlPanel {
  2732  	s.ControlPanelArn = &v
  2733  	return s
  2734  }
  2735  
  2736  // SetDefaultControlPanel sets the DefaultControlPanel field's value.
  2737  func (s *ControlPanel) SetDefaultControlPanel(v bool) *ControlPanel {
  2738  	s.DefaultControlPanel = &v
  2739  	return s
  2740  }
  2741  
  2742  // SetName sets the Name field's value.
  2743  func (s *ControlPanel) SetName(v string) *ControlPanel {
  2744  	s.Name = &v
  2745  	return s
  2746  }
  2747  
  2748  // SetRoutingControlCount sets the RoutingControlCount field's value.
  2749  func (s *ControlPanel) SetRoutingControlCount(v int64) *ControlPanel {
  2750  	s.RoutingControlCount = &v
  2751  	return s
  2752  }
  2753  
  2754  // SetStatus sets the Status field's value.
  2755  func (s *ControlPanel) SetStatus(v string) *ControlPanel {
  2756  	s.Status = &v
  2757  	return s
  2758  }
  2759  
  2760  // The properties of a request to create a cluster.
  2761  type CreateClusterInput struct {
  2762  	_ struct{} `type:"structure"`
  2763  
  2764  	// Unique client idempotency token.
  2765  	ClientToken *string `type:"string" idempotencyToken:"true"`
  2766  
  2767  	// The name of the cluster.
  2768  	//
  2769  	// ClusterName is a required field
  2770  	ClusterName *string `min:"1" type:"string" required:"true"`
  2771  }
  2772  
  2773  // String returns the string representation.
  2774  //
  2775  // API parameter values that are decorated as "sensitive" in the API will not
  2776  // be included in the string output. The member name will be present, but the
  2777  // value will be replaced with "sensitive".
  2778  func (s CreateClusterInput) String() string {
  2779  	return awsutil.Prettify(s)
  2780  }
  2781  
  2782  // GoString returns the string representation.
  2783  //
  2784  // API parameter values that are decorated as "sensitive" in the API will not
  2785  // be included in the string output. The member name will be present, but the
  2786  // value will be replaced with "sensitive".
  2787  func (s CreateClusterInput) GoString() string {
  2788  	return s.String()
  2789  }
  2790  
  2791  // Validate inspects the fields of the type to determine if they are valid.
  2792  func (s *CreateClusterInput) Validate() error {
  2793  	invalidParams := request.ErrInvalidParams{Context: "CreateClusterInput"}
  2794  	if s.ClusterName == nil {
  2795  		invalidParams.Add(request.NewErrParamRequired("ClusterName"))
  2796  	}
  2797  	if s.ClusterName != nil && len(*s.ClusterName) < 1 {
  2798  		invalidParams.Add(request.NewErrParamMinLen("ClusterName", 1))
  2799  	}
  2800  
  2801  	if invalidParams.Len() > 0 {
  2802  		return invalidParams
  2803  	}
  2804  	return nil
  2805  }
  2806  
  2807  // SetClientToken sets the ClientToken field's value.
  2808  func (s *CreateClusterInput) SetClientToken(v string) *CreateClusterInput {
  2809  	s.ClientToken = &v
  2810  	return s
  2811  }
  2812  
  2813  // SetClusterName sets the ClusterName field's value.
  2814  func (s *CreateClusterInput) SetClusterName(v string) *CreateClusterInput {
  2815  	s.ClusterName = &v
  2816  	return s
  2817  }
  2818  
  2819  // The result of a successful CreateCluster request.
  2820  type CreateClusterOutput struct {
  2821  	_ struct{} `type:"structure"`
  2822  
  2823  	// The cluster that was created.
  2824  	Cluster *Cluster `type:"structure"`
  2825  }
  2826  
  2827  // String returns the string representation.
  2828  //
  2829  // API parameter values that are decorated as "sensitive" in the API will not
  2830  // be included in the string output. The member name will be present, but the
  2831  // value will be replaced with "sensitive".
  2832  func (s CreateClusterOutput) String() string {
  2833  	return awsutil.Prettify(s)
  2834  }
  2835  
  2836  // GoString returns the string representation.
  2837  //
  2838  // API parameter values that are decorated as "sensitive" in the API will not
  2839  // be included in the string output. The member name will be present, but the
  2840  // value will be replaced with "sensitive".
  2841  func (s CreateClusterOutput) GoString() string {
  2842  	return s.String()
  2843  }
  2844  
  2845  // SetCluster sets the Cluster field's value.
  2846  func (s *CreateClusterOutput) SetCluster(v *Cluster) *CreateClusterOutput {
  2847  	s.Cluster = v
  2848  	return s
  2849  }
  2850  
  2851  // A request to create a control panel.
  2852  type CreateControlPanelInput struct {
  2853  	_ struct{} `type:"structure"`
  2854  
  2855  	// Unique client idempotency token.
  2856  	ClientToken *string `type:"string" idempotencyToken:"true"`
  2857  
  2858  	// The Amazon Resource Name (ARN) of the cluster for the control panel.
  2859  	//
  2860  	// ClusterArn is a required field
  2861  	ClusterArn *string `type:"string" required:"true"`
  2862  
  2863  	// The name of the control panel.
  2864  	//
  2865  	// ControlPanelName is a required field
  2866  	ControlPanelName *string `min:"1" type:"string" required:"true"`
  2867  }
  2868  
  2869  // String returns the string representation.
  2870  //
  2871  // API parameter values that are decorated as "sensitive" in the API will not
  2872  // be included in the string output. The member name will be present, but the
  2873  // value will be replaced with "sensitive".
  2874  func (s CreateControlPanelInput) String() string {
  2875  	return awsutil.Prettify(s)
  2876  }
  2877  
  2878  // GoString returns the string representation.
  2879  //
  2880  // API parameter values that are decorated as "sensitive" in the API will not
  2881  // be included in the string output. The member name will be present, but the
  2882  // value will be replaced with "sensitive".
  2883  func (s CreateControlPanelInput) GoString() string {
  2884  	return s.String()
  2885  }
  2886  
  2887  // Validate inspects the fields of the type to determine if they are valid.
  2888  func (s *CreateControlPanelInput) Validate() error {
  2889  	invalidParams := request.ErrInvalidParams{Context: "CreateControlPanelInput"}
  2890  	if s.ClusterArn == nil {
  2891  		invalidParams.Add(request.NewErrParamRequired("ClusterArn"))
  2892  	}
  2893  	if s.ControlPanelName == nil {
  2894  		invalidParams.Add(request.NewErrParamRequired("ControlPanelName"))
  2895  	}
  2896  	if s.ControlPanelName != nil && len(*s.ControlPanelName) < 1 {
  2897  		invalidParams.Add(request.NewErrParamMinLen("ControlPanelName", 1))
  2898  	}
  2899  
  2900  	if invalidParams.Len() > 0 {
  2901  		return invalidParams
  2902  	}
  2903  	return nil
  2904  }
  2905  
  2906  // SetClientToken sets the ClientToken field's value.
  2907  func (s *CreateControlPanelInput) SetClientToken(v string) *CreateControlPanelInput {
  2908  	s.ClientToken = &v
  2909  	return s
  2910  }
  2911  
  2912  // SetClusterArn sets the ClusterArn field's value.
  2913  func (s *CreateControlPanelInput) SetClusterArn(v string) *CreateControlPanelInput {
  2914  	s.ClusterArn = &v
  2915  	return s
  2916  }
  2917  
  2918  // SetControlPanelName sets the ControlPanelName field's value.
  2919  func (s *CreateControlPanelInput) SetControlPanelName(v string) *CreateControlPanelInput {
  2920  	s.ControlPanelName = &v
  2921  	return s
  2922  }
  2923  
  2924  // The result of a successful CreateControlPanel request.
  2925  type CreateControlPanelOutput struct {
  2926  	_ struct{} `type:"structure"`
  2927  
  2928  	// Information about a control panel.
  2929  	ControlPanel *ControlPanel `type:"structure"`
  2930  }
  2931  
  2932  // String returns the string representation.
  2933  //
  2934  // API parameter values that are decorated as "sensitive" in the API will not
  2935  // be included in the string output. The member name will be present, but the
  2936  // value will be replaced with "sensitive".
  2937  func (s CreateControlPanelOutput) String() string {
  2938  	return awsutil.Prettify(s)
  2939  }
  2940  
  2941  // GoString returns the string representation.
  2942  //
  2943  // API parameter values that are decorated as "sensitive" in the API will not
  2944  // be included in the string output. The member name will be present, but the
  2945  // value will be replaced with "sensitive".
  2946  func (s CreateControlPanelOutput) GoString() string {
  2947  	return s.String()
  2948  }
  2949  
  2950  // SetControlPanel sets the ControlPanel field's value.
  2951  func (s *CreateControlPanelOutput) SetControlPanel(v *ControlPanel) *CreateControlPanelOutput {
  2952  	s.ControlPanel = v
  2953  	return s
  2954  }
  2955  
  2956  // A request to create a routing control. If you don't specify ControlPanelArn,
  2957  // Amazon Route 53 Application Recovery Controller creates the routing control
  2958  // in DefaultControlPanel.
  2959  type CreateRoutingControlInput struct {
  2960  	_ struct{} `type:"structure"`
  2961  
  2962  	// Unique client idempotency token.
  2963  	ClientToken *string `type:"string" idempotencyToken:"true"`
  2964  
  2965  	// The Amazon Resource Name (ARN) of the cluster that includes the routing control.
  2966  	//
  2967  	// ClusterArn is a required field
  2968  	ClusterArn *string `type:"string" required:"true"`
  2969  
  2970  	// The Amazon Resource Name (ARN) of the control panel that includes the routing
  2971  	// control.
  2972  	ControlPanelArn *string `type:"string"`
  2973  
  2974  	// The name of the routing control.
  2975  	//
  2976  	// RoutingControlName is a required field
  2977  	RoutingControlName *string `min:"1" type:"string" required:"true"`
  2978  }
  2979  
  2980  // String returns the string representation.
  2981  //
  2982  // API parameter values that are decorated as "sensitive" in the API will not
  2983  // be included in the string output. The member name will be present, but the
  2984  // value will be replaced with "sensitive".
  2985  func (s CreateRoutingControlInput) String() string {
  2986  	return awsutil.Prettify(s)
  2987  }
  2988  
  2989  // GoString returns the string representation.
  2990  //
  2991  // API parameter values that are decorated as "sensitive" in the API will not
  2992  // be included in the string output. The member name will be present, but the
  2993  // value will be replaced with "sensitive".
  2994  func (s CreateRoutingControlInput) GoString() string {
  2995  	return s.String()
  2996  }
  2997  
  2998  // Validate inspects the fields of the type to determine if they are valid.
  2999  func (s *CreateRoutingControlInput) Validate() error {
  3000  	invalidParams := request.ErrInvalidParams{Context: "CreateRoutingControlInput"}
  3001  	if s.ClusterArn == nil {
  3002  		invalidParams.Add(request.NewErrParamRequired("ClusterArn"))
  3003  	}
  3004  	if s.RoutingControlName == nil {
  3005  		invalidParams.Add(request.NewErrParamRequired("RoutingControlName"))
  3006  	}
  3007  	if s.RoutingControlName != nil && len(*s.RoutingControlName) < 1 {
  3008  		invalidParams.Add(request.NewErrParamMinLen("RoutingControlName", 1))
  3009  	}
  3010  
  3011  	if invalidParams.Len() > 0 {
  3012  		return invalidParams
  3013  	}
  3014  	return nil
  3015  }
  3016  
  3017  // SetClientToken sets the ClientToken field's value.
  3018  func (s *CreateRoutingControlInput) SetClientToken(v string) *CreateRoutingControlInput {
  3019  	s.ClientToken = &v
  3020  	return s
  3021  }
  3022  
  3023  // SetClusterArn sets the ClusterArn field's value.
  3024  func (s *CreateRoutingControlInput) SetClusterArn(v string) *CreateRoutingControlInput {
  3025  	s.ClusterArn = &v
  3026  	return s
  3027  }
  3028  
  3029  // SetControlPanelArn sets the ControlPanelArn field's value.
  3030  func (s *CreateRoutingControlInput) SetControlPanelArn(v string) *CreateRoutingControlInput {
  3031  	s.ControlPanelArn = &v
  3032  	return s
  3033  }
  3034  
  3035  // SetRoutingControlName sets the RoutingControlName field's value.
  3036  func (s *CreateRoutingControlInput) SetRoutingControlName(v string) *CreateRoutingControlInput {
  3037  	s.RoutingControlName = &v
  3038  	return s
  3039  }
  3040  
  3041  // The result of a successful CreateRoutingControl request.
  3042  type CreateRoutingControlOutput struct {
  3043  	_ struct{} `type:"structure"`
  3044  
  3045  	// The routing control that is created.
  3046  	RoutingControl *RoutingControl `type:"structure"`
  3047  }
  3048  
  3049  // String returns the string representation.
  3050  //
  3051  // API parameter values that are decorated as "sensitive" in the API will not
  3052  // be included in the string output. The member name will be present, but the
  3053  // value will be replaced with "sensitive".
  3054  func (s CreateRoutingControlOutput) String() string {
  3055  	return awsutil.Prettify(s)
  3056  }
  3057  
  3058  // GoString returns the string representation.
  3059  //
  3060  // API parameter values that are decorated as "sensitive" in the API will not
  3061  // be included in the string output. The member name will be present, but the
  3062  // value will be replaced with "sensitive".
  3063  func (s CreateRoutingControlOutput) GoString() string {
  3064  	return s.String()
  3065  }
  3066  
  3067  // SetRoutingControl sets the RoutingControl field's value.
  3068  func (s *CreateRoutingControlOutput) SetRoutingControl(v *RoutingControl) *CreateRoutingControlOutput {
  3069  	s.RoutingControl = v
  3070  	return s
  3071  }
  3072  
  3073  // Request to create a safety rule. You can create either an assertion rule
  3074  // or a gating rule with a CreateSafetyRuleRequest call.
  3075  type CreateSafetyRuleInput struct {
  3076  	_ struct{} `type:"structure"`
  3077  
  3078  	// A new assertion rule for a control panel.
  3079  	AssertionRule *NewAssertionRule `type:"structure"`
  3080  
  3081  	// Unique client idempotency token.
  3082  	ClientToken *string `type:"string" idempotencyToken:"true"`
  3083  
  3084  	// A new gating rule for a control panel.
  3085  	GatingRule *NewGatingRule `type:"structure"`
  3086  }
  3087  
  3088  // String returns the string representation.
  3089  //
  3090  // API parameter values that are decorated as "sensitive" in the API will not
  3091  // be included in the string output. The member name will be present, but the
  3092  // value will be replaced with "sensitive".
  3093  func (s CreateSafetyRuleInput) String() string {
  3094  	return awsutil.Prettify(s)
  3095  }
  3096  
  3097  // GoString returns the string representation.
  3098  //
  3099  // API parameter values that are decorated as "sensitive" in the API will not
  3100  // be included in the string output. The member name will be present, but the
  3101  // value will be replaced with "sensitive".
  3102  func (s CreateSafetyRuleInput) GoString() string {
  3103  	return s.String()
  3104  }
  3105  
  3106  // Validate inspects the fields of the type to determine if they are valid.
  3107  func (s *CreateSafetyRuleInput) Validate() error {
  3108  	invalidParams := request.ErrInvalidParams{Context: "CreateSafetyRuleInput"}
  3109  	if s.AssertionRule != nil {
  3110  		if err := s.AssertionRule.Validate(); err != nil {
  3111  			invalidParams.AddNested("AssertionRule", err.(request.ErrInvalidParams))
  3112  		}
  3113  	}
  3114  	if s.GatingRule != nil {
  3115  		if err := s.GatingRule.Validate(); err != nil {
  3116  			invalidParams.AddNested("GatingRule", err.(request.ErrInvalidParams))
  3117  		}
  3118  	}
  3119  
  3120  	if invalidParams.Len() > 0 {
  3121  		return invalidParams
  3122  	}
  3123  	return nil
  3124  }
  3125  
  3126  // SetAssertionRule sets the AssertionRule field's value.
  3127  func (s *CreateSafetyRuleInput) SetAssertionRule(v *NewAssertionRule) *CreateSafetyRuleInput {
  3128  	s.AssertionRule = v
  3129  	return s
  3130  }
  3131  
  3132  // SetClientToken sets the ClientToken field's value.
  3133  func (s *CreateSafetyRuleInput) SetClientToken(v string) *CreateSafetyRuleInput {
  3134  	s.ClientToken = &v
  3135  	return s
  3136  }
  3137  
  3138  // SetGatingRule sets the GatingRule field's value.
  3139  func (s *CreateSafetyRuleInput) SetGatingRule(v *NewGatingRule) *CreateSafetyRuleInput {
  3140  	s.GatingRule = v
  3141  	return s
  3142  }
  3143  
  3144  // The result of a successful CreateSafetyRule request.
  3145  type CreateSafetyRuleOutput struct {
  3146  	_ struct{} `type:"structure"`
  3147  
  3148  	// An assertion rule enforces that, when a routing control state is changed,
  3149  	// the criteria set by the rule configuration is met. Otherwise, the change
  3150  	// to the routing control is not accepted.
  3151  	AssertionRule *AssertionRule `type:"structure"`
  3152  
  3153  	// A gating rule verifies that a set of gating controls evaluates as true, based
  3154  	// on a rule configuration that you specify. If the gating rule evaluates to
  3155  	// true, Amazon Route 53 Application Recovery Controller allows a set of routing
  3156  	// control state changes to run and complete against the set of target controls.
  3157  	GatingRule *GatingRule `type:"structure"`
  3158  }
  3159  
  3160  // String returns the string representation.
  3161  //
  3162  // API parameter values that are decorated as "sensitive" in the API will not
  3163  // be included in the string output. The member name will be present, but the
  3164  // value will be replaced with "sensitive".
  3165  func (s CreateSafetyRuleOutput) String() string {
  3166  	return awsutil.Prettify(s)
  3167  }
  3168  
  3169  // GoString returns the string representation.
  3170  //
  3171  // API parameter values that are decorated as "sensitive" in the API will not
  3172  // be included in the string output. The member name will be present, but the
  3173  // value will be replaced with "sensitive".
  3174  func (s CreateSafetyRuleOutput) GoString() string {
  3175  	return s.String()
  3176  }
  3177  
  3178  // SetAssertionRule sets the AssertionRule field's value.
  3179  func (s *CreateSafetyRuleOutput) SetAssertionRule(v *AssertionRule) *CreateSafetyRuleOutput {
  3180  	s.AssertionRule = v
  3181  	return s
  3182  }
  3183  
  3184  // SetGatingRule sets the GatingRule field's value.
  3185  func (s *CreateSafetyRuleOutput) SetGatingRule(v *GatingRule) *CreateSafetyRuleOutput {
  3186  	s.GatingRule = v
  3187  	return s
  3188  }
  3189  
  3190  type DeleteClusterInput struct {
  3191  	_ struct{} `type:"structure" nopayload:"true"`
  3192  
  3193  	// ClusterArn is a required field
  3194  	ClusterArn *string `location:"uri" locationName:"ClusterArn" type:"string" required:"true"`
  3195  }
  3196  
  3197  // String returns the string representation.
  3198  //
  3199  // API parameter values that are decorated as "sensitive" in the API will not
  3200  // be included in the string output. The member name will be present, but the
  3201  // value will be replaced with "sensitive".
  3202  func (s DeleteClusterInput) String() string {
  3203  	return awsutil.Prettify(s)
  3204  }
  3205  
  3206  // GoString returns the string representation.
  3207  //
  3208  // API parameter values that are decorated as "sensitive" in the API will not
  3209  // be included in the string output. The member name will be present, but the
  3210  // value will be replaced with "sensitive".
  3211  func (s DeleteClusterInput) GoString() string {
  3212  	return s.String()
  3213  }
  3214  
  3215  // Validate inspects the fields of the type to determine if they are valid.
  3216  func (s *DeleteClusterInput) Validate() error {
  3217  	invalidParams := request.ErrInvalidParams{Context: "DeleteClusterInput"}
  3218  	if s.ClusterArn == nil {
  3219  		invalidParams.Add(request.NewErrParamRequired("ClusterArn"))
  3220  	}
  3221  	if s.ClusterArn != nil && len(*s.ClusterArn) < 1 {
  3222  		invalidParams.Add(request.NewErrParamMinLen("ClusterArn", 1))
  3223  	}
  3224  
  3225  	if invalidParams.Len() > 0 {
  3226  		return invalidParams
  3227  	}
  3228  	return nil
  3229  }
  3230  
  3231  // SetClusterArn sets the ClusterArn field's value.
  3232  func (s *DeleteClusterInput) SetClusterArn(v string) *DeleteClusterInput {
  3233  	s.ClusterArn = &v
  3234  	return s
  3235  }
  3236  
  3237  // A successful DeleteCluster request returns no response.
  3238  type DeleteClusterOutput struct {
  3239  	_ struct{} `type:"structure" nopayload:"true"`
  3240  }
  3241  
  3242  // String returns the string representation.
  3243  //
  3244  // API parameter values that are decorated as "sensitive" in the API will not
  3245  // be included in the string output. The member name will be present, but the
  3246  // value will be replaced with "sensitive".
  3247  func (s DeleteClusterOutput) String() string {
  3248  	return awsutil.Prettify(s)
  3249  }
  3250  
  3251  // GoString returns the string representation.
  3252  //
  3253  // API parameter values that are decorated as "sensitive" in the API will not
  3254  // be included in the string output. The member name will be present, but the
  3255  // value will be replaced with "sensitive".
  3256  func (s DeleteClusterOutput) GoString() string {
  3257  	return s.String()
  3258  }
  3259  
  3260  type DeleteControlPanelInput struct {
  3261  	_ struct{} `type:"structure" nopayload:"true"`
  3262  
  3263  	// ControlPanelArn is a required field
  3264  	ControlPanelArn *string `location:"uri" locationName:"ControlPanelArn" type:"string" required:"true"`
  3265  }
  3266  
  3267  // String returns the string representation.
  3268  //
  3269  // API parameter values that are decorated as "sensitive" in the API will not
  3270  // be included in the string output. The member name will be present, but the
  3271  // value will be replaced with "sensitive".
  3272  func (s DeleteControlPanelInput) String() string {
  3273  	return awsutil.Prettify(s)
  3274  }
  3275  
  3276  // GoString returns the string representation.
  3277  //
  3278  // API parameter values that are decorated as "sensitive" in the API will not
  3279  // be included in the string output. The member name will be present, but the
  3280  // value will be replaced with "sensitive".
  3281  func (s DeleteControlPanelInput) GoString() string {
  3282  	return s.String()
  3283  }
  3284  
  3285  // Validate inspects the fields of the type to determine if they are valid.
  3286  func (s *DeleteControlPanelInput) Validate() error {
  3287  	invalidParams := request.ErrInvalidParams{Context: "DeleteControlPanelInput"}
  3288  	if s.ControlPanelArn == nil {
  3289  		invalidParams.Add(request.NewErrParamRequired("ControlPanelArn"))
  3290  	}
  3291  	if s.ControlPanelArn != nil && len(*s.ControlPanelArn) < 1 {
  3292  		invalidParams.Add(request.NewErrParamMinLen("ControlPanelArn", 1))
  3293  	}
  3294  
  3295  	if invalidParams.Len() > 0 {
  3296  		return invalidParams
  3297  	}
  3298  	return nil
  3299  }
  3300  
  3301  // SetControlPanelArn sets the ControlPanelArn field's value.
  3302  func (s *DeleteControlPanelInput) SetControlPanelArn(v string) *DeleteControlPanelInput {
  3303  	s.ControlPanelArn = &v
  3304  	return s
  3305  }
  3306  
  3307  // A successful DeleteControlPanel request returns no response.
  3308  type DeleteControlPanelOutput struct {
  3309  	_ struct{} `type:"structure" nopayload:"true"`
  3310  }
  3311  
  3312  // String returns the string representation.
  3313  //
  3314  // API parameter values that are decorated as "sensitive" in the API will not
  3315  // be included in the string output. The member name will be present, but the
  3316  // value will be replaced with "sensitive".
  3317  func (s DeleteControlPanelOutput) String() string {
  3318  	return awsutil.Prettify(s)
  3319  }
  3320  
  3321  // GoString returns the string representation.
  3322  //
  3323  // API parameter values that are decorated as "sensitive" in the API will not
  3324  // be included in the string output. The member name will be present, but the
  3325  // value will be replaced with "sensitive".
  3326  func (s DeleteControlPanelOutput) GoString() string {
  3327  	return s.String()
  3328  }
  3329  
  3330  type DeleteRoutingControlInput struct {
  3331  	_ struct{} `type:"structure" nopayload:"true"`
  3332  
  3333  	// RoutingControlArn is a required field
  3334  	RoutingControlArn *string `location:"uri" locationName:"RoutingControlArn" type:"string" required:"true"`
  3335  }
  3336  
  3337  // String returns the string representation.
  3338  //
  3339  // API parameter values that are decorated as "sensitive" in the API will not
  3340  // be included in the string output. The member name will be present, but the
  3341  // value will be replaced with "sensitive".
  3342  func (s DeleteRoutingControlInput) String() string {
  3343  	return awsutil.Prettify(s)
  3344  }
  3345  
  3346  // GoString returns the string representation.
  3347  //
  3348  // API parameter values that are decorated as "sensitive" in the API will not
  3349  // be included in the string output. The member name will be present, but the
  3350  // value will be replaced with "sensitive".
  3351  func (s DeleteRoutingControlInput) GoString() string {
  3352  	return s.String()
  3353  }
  3354  
  3355  // Validate inspects the fields of the type to determine if they are valid.
  3356  func (s *DeleteRoutingControlInput) Validate() error {
  3357  	invalidParams := request.ErrInvalidParams{Context: "DeleteRoutingControlInput"}
  3358  	if s.RoutingControlArn == nil {
  3359  		invalidParams.Add(request.NewErrParamRequired("RoutingControlArn"))
  3360  	}
  3361  	if s.RoutingControlArn != nil && len(*s.RoutingControlArn) < 1 {
  3362  		invalidParams.Add(request.NewErrParamMinLen("RoutingControlArn", 1))
  3363  	}
  3364  
  3365  	if invalidParams.Len() > 0 {
  3366  		return invalidParams
  3367  	}
  3368  	return nil
  3369  }
  3370  
  3371  // SetRoutingControlArn sets the RoutingControlArn field's value.
  3372  func (s *DeleteRoutingControlInput) SetRoutingControlArn(v string) *DeleteRoutingControlInput {
  3373  	s.RoutingControlArn = &v
  3374  	return s
  3375  }
  3376  
  3377  // A successful DeleteRoutingControl request returns no response.
  3378  type DeleteRoutingControlOutput struct {
  3379  	_ struct{} `type:"structure" nopayload:"true"`
  3380  }
  3381  
  3382  // String returns the string representation.
  3383  //
  3384  // API parameter values that are decorated as "sensitive" in the API will not
  3385  // be included in the string output. The member name will be present, but the
  3386  // value will be replaced with "sensitive".
  3387  func (s DeleteRoutingControlOutput) String() string {
  3388  	return awsutil.Prettify(s)
  3389  }
  3390  
  3391  // GoString returns the string representation.
  3392  //
  3393  // API parameter values that are decorated as "sensitive" in the API will not
  3394  // be included in the string output. The member name will be present, but the
  3395  // value will be replaced with "sensitive".
  3396  func (s DeleteRoutingControlOutput) GoString() string {
  3397  	return s.String()
  3398  }
  3399  
  3400  type DeleteSafetyRuleInput struct {
  3401  	_ struct{} `type:"structure" nopayload:"true"`
  3402  
  3403  	// SafetyRuleArn is a required field
  3404  	SafetyRuleArn *string `location:"uri" locationName:"SafetyRuleArn" type:"string" required:"true"`
  3405  }
  3406  
  3407  // String returns the string representation.
  3408  //
  3409  // API parameter values that are decorated as "sensitive" in the API will not
  3410  // be included in the string output. The member name will be present, but the
  3411  // value will be replaced with "sensitive".
  3412  func (s DeleteSafetyRuleInput) String() string {
  3413  	return awsutil.Prettify(s)
  3414  }
  3415  
  3416  // GoString returns the string representation.
  3417  //
  3418  // API parameter values that are decorated as "sensitive" in the API will not
  3419  // be included in the string output. The member name will be present, but the
  3420  // value will be replaced with "sensitive".
  3421  func (s DeleteSafetyRuleInput) GoString() string {
  3422  	return s.String()
  3423  }
  3424  
  3425  // Validate inspects the fields of the type to determine if they are valid.
  3426  func (s *DeleteSafetyRuleInput) Validate() error {
  3427  	invalidParams := request.ErrInvalidParams{Context: "DeleteSafetyRuleInput"}
  3428  	if s.SafetyRuleArn == nil {
  3429  		invalidParams.Add(request.NewErrParamRequired("SafetyRuleArn"))
  3430  	}
  3431  	if s.SafetyRuleArn != nil && len(*s.SafetyRuleArn) < 1 {
  3432  		invalidParams.Add(request.NewErrParamMinLen("SafetyRuleArn", 1))
  3433  	}
  3434  
  3435  	if invalidParams.Len() > 0 {
  3436  		return invalidParams
  3437  	}
  3438  	return nil
  3439  }
  3440  
  3441  // SetSafetyRuleArn sets the SafetyRuleArn field's value.
  3442  func (s *DeleteSafetyRuleInput) SetSafetyRuleArn(v string) *DeleteSafetyRuleInput {
  3443  	s.SafetyRuleArn = &v
  3444  	return s
  3445  }
  3446  
  3447  // There is an empty response when you delete a safety rule.
  3448  // />
  3449  type DeleteSafetyRuleOutput struct {
  3450  	_ struct{} `type:"structure" nopayload:"true"`
  3451  }
  3452  
  3453  // String returns the string representation.
  3454  //
  3455  // API parameter values that are decorated as "sensitive" in the API will not
  3456  // be included in the string output. The member name will be present, but the
  3457  // value will be replaced with "sensitive".
  3458  func (s DeleteSafetyRuleOutput) String() string {
  3459  	return awsutil.Prettify(s)
  3460  }
  3461  
  3462  // GoString returns the string representation.
  3463  //
  3464  // API parameter values that are decorated as "sensitive" in the API will not
  3465  // be included in the string output. The member name will be present, but the
  3466  // value will be replaced with "sensitive".
  3467  func (s DeleteSafetyRuleOutput) GoString() string {
  3468  	return s.String()
  3469  }
  3470  
  3471  type DescribeClusterInput struct {
  3472  	_ struct{} `type:"structure" nopayload:"true"`
  3473  
  3474  	// ClusterArn is a required field
  3475  	ClusterArn *string `location:"uri" locationName:"ClusterArn" type:"string" required:"true"`
  3476  }
  3477  
  3478  // String returns the string representation.
  3479  //
  3480  // API parameter values that are decorated as "sensitive" in the API will not
  3481  // be included in the string output. The member name will be present, but the
  3482  // value will be replaced with "sensitive".
  3483  func (s DescribeClusterInput) String() string {
  3484  	return awsutil.Prettify(s)
  3485  }
  3486  
  3487  // GoString returns the string representation.
  3488  //
  3489  // API parameter values that are decorated as "sensitive" in the API will not
  3490  // be included in the string output. The member name will be present, but the
  3491  // value will be replaced with "sensitive".
  3492  func (s DescribeClusterInput) GoString() string {
  3493  	return s.String()
  3494  }
  3495  
  3496  // Validate inspects the fields of the type to determine if they are valid.
  3497  func (s *DescribeClusterInput) Validate() error {
  3498  	invalidParams := request.ErrInvalidParams{Context: "DescribeClusterInput"}
  3499  	if s.ClusterArn == nil {
  3500  		invalidParams.Add(request.NewErrParamRequired("ClusterArn"))
  3501  	}
  3502  	if s.ClusterArn != nil && len(*s.ClusterArn) < 1 {
  3503  		invalidParams.Add(request.NewErrParamMinLen("ClusterArn", 1))
  3504  	}
  3505  
  3506  	if invalidParams.Len() > 0 {
  3507  		return invalidParams
  3508  	}
  3509  	return nil
  3510  }
  3511  
  3512  // SetClusterArn sets the ClusterArn field's value.
  3513  func (s *DescribeClusterInput) SetClusterArn(v string) *DescribeClusterInput {
  3514  	s.ClusterArn = &v
  3515  	return s
  3516  }
  3517  
  3518  // The result of a successful DescribeCluster request.
  3519  type DescribeClusterOutput struct {
  3520  	_ struct{} `type:"structure"`
  3521  
  3522  	// The cluster for the DescribeCluster request.
  3523  	Cluster *Cluster `type:"structure"`
  3524  }
  3525  
  3526  // String returns the string representation.
  3527  //
  3528  // API parameter values that are decorated as "sensitive" in the API will not
  3529  // be included in the string output. The member name will be present, but the
  3530  // value will be replaced with "sensitive".
  3531  func (s DescribeClusterOutput) String() string {
  3532  	return awsutil.Prettify(s)
  3533  }
  3534  
  3535  // GoString returns the string representation.
  3536  //
  3537  // API parameter values that are decorated as "sensitive" in the API will not
  3538  // be included in the string output. The member name will be present, but the
  3539  // value will be replaced with "sensitive".
  3540  func (s DescribeClusterOutput) GoString() string {
  3541  	return s.String()
  3542  }
  3543  
  3544  // SetCluster sets the Cluster field's value.
  3545  func (s *DescribeClusterOutput) SetCluster(v *Cluster) *DescribeClusterOutput {
  3546  	s.Cluster = v
  3547  	return s
  3548  }
  3549  
  3550  type DescribeControlPanelInput struct {
  3551  	_ struct{} `type:"structure" nopayload:"true"`
  3552  
  3553  	// ControlPanelArn is a required field
  3554  	ControlPanelArn *string `location:"uri" locationName:"ControlPanelArn" type:"string" required:"true"`
  3555  }
  3556  
  3557  // String returns the string representation.
  3558  //
  3559  // API parameter values that are decorated as "sensitive" in the API will not
  3560  // be included in the string output. The member name will be present, but the
  3561  // value will be replaced with "sensitive".
  3562  func (s DescribeControlPanelInput) String() string {
  3563  	return awsutil.Prettify(s)
  3564  }
  3565  
  3566  // GoString returns the string representation.
  3567  //
  3568  // API parameter values that are decorated as "sensitive" in the API will not
  3569  // be included in the string output. The member name will be present, but the
  3570  // value will be replaced with "sensitive".
  3571  func (s DescribeControlPanelInput) GoString() string {
  3572  	return s.String()
  3573  }
  3574  
  3575  // Validate inspects the fields of the type to determine if they are valid.
  3576  func (s *DescribeControlPanelInput) Validate() error {
  3577  	invalidParams := request.ErrInvalidParams{Context: "DescribeControlPanelInput"}
  3578  	if s.ControlPanelArn == nil {
  3579  		invalidParams.Add(request.NewErrParamRequired("ControlPanelArn"))
  3580  	}
  3581  	if s.ControlPanelArn != nil && len(*s.ControlPanelArn) < 1 {
  3582  		invalidParams.Add(request.NewErrParamMinLen("ControlPanelArn", 1))
  3583  	}
  3584  
  3585  	if invalidParams.Len() > 0 {
  3586  		return invalidParams
  3587  	}
  3588  	return nil
  3589  }
  3590  
  3591  // SetControlPanelArn sets the ControlPanelArn field's value.
  3592  func (s *DescribeControlPanelInput) SetControlPanelArn(v string) *DescribeControlPanelInput {
  3593  	s.ControlPanelArn = &v
  3594  	return s
  3595  }
  3596  
  3597  // The result of a successful DescribeControlPanel request.
  3598  type DescribeControlPanelOutput struct {
  3599  	_ struct{} `type:"structure"`
  3600  
  3601  	// Information about the control panel.
  3602  	ControlPanel *ControlPanel `type:"structure"`
  3603  }
  3604  
  3605  // String returns the string representation.
  3606  //
  3607  // API parameter values that are decorated as "sensitive" in the API will not
  3608  // be included in the string output. The member name will be present, but the
  3609  // value will be replaced with "sensitive".
  3610  func (s DescribeControlPanelOutput) String() string {
  3611  	return awsutil.Prettify(s)
  3612  }
  3613  
  3614  // GoString returns the string representation.
  3615  //
  3616  // API parameter values that are decorated as "sensitive" in the API will not
  3617  // be included in the string output. The member name will be present, but the
  3618  // value will be replaced with "sensitive".
  3619  func (s DescribeControlPanelOutput) GoString() string {
  3620  	return s.String()
  3621  }
  3622  
  3623  // SetControlPanel sets the ControlPanel field's value.
  3624  func (s *DescribeControlPanelOutput) SetControlPanel(v *ControlPanel) *DescribeControlPanelOutput {
  3625  	s.ControlPanel = v
  3626  	return s
  3627  }
  3628  
  3629  type DescribeRoutingControlInput struct {
  3630  	_ struct{} `type:"structure" nopayload:"true"`
  3631  
  3632  	// RoutingControlArn is a required field
  3633  	RoutingControlArn *string `location:"uri" locationName:"RoutingControlArn" type:"string" required:"true"`
  3634  }
  3635  
  3636  // String returns the string representation.
  3637  //
  3638  // API parameter values that are decorated as "sensitive" in the API will not
  3639  // be included in the string output. The member name will be present, but the
  3640  // value will be replaced with "sensitive".
  3641  func (s DescribeRoutingControlInput) String() string {
  3642  	return awsutil.Prettify(s)
  3643  }
  3644  
  3645  // GoString returns the string representation.
  3646  //
  3647  // API parameter values that are decorated as "sensitive" in the API will not
  3648  // be included in the string output. The member name will be present, but the
  3649  // value will be replaced with "sensitive".
  3650  func (s DescribeRoutingControlInput) GoString() string {
  3651  	return s.String()
  3652  }
  3653  
  3654  // Validate inspects the fields of the type to determine if they are valid.
  3655  func (s *DescribeRoutingControlInput) Validate() error {
  3656  	invalidParams := request.ErrInvalidParams{Context: "DescribeRoutingControlInput"}
  3657  	if s.RoutingControlArn == nil {
  3658  		invalidParams.Add(request.NewErrParamRequired("RoutingControlArn"))
  3659  	}
  3660  	if s.RoutingControlArn != nil && len(*s.RoutingControlArn) < 1 {
  3661  		invalidParams.Add(request.NewErrParamMinLen("RoutingControlArn", 1))
  3662  	}
  3663  
  3664  	if invalidParams.Len() > 0 {
  3665  		return invalidParams
  3666  	}
  3667  	return nil
  3668  }
  3669  
  3670  // SetRoutingControlArn sets the RoutingControlArn field's value.
  3671  func (s *DescribeRoutingControlInput) SetRoutingControlArn(v string) *DescribeRoutingControlInput {
  3672  	s.RoutingControlArn = &v
  3673  	return s
  3674  }
  3675  
  3676  // The result of a successful DescribeRoutingControl request.
  3677  type DescribeRoutingControlOutput struct {
  3678  	_ struct{} `type:"structure"`
  3679  
  3680  	// Information about the routing control.
  3681  	RoutingControl *RoutingControl `type:"structure"`
  3682  }
  3683  
  3684  // String returns the string representation.
  3685  //
  3686  // API parameter values that are decorated as "sensitive" in the API will not
  3687  // be included in the string output. The member name will be present, but the
  3688  // value will be replaced with "sensitive".
  3689  func (s DescribeRoutingControlOutput) String() string {
  3690  	return awsutil.Prettify(s)
  3691  }
  3692  
  3693  // GoString returns the string representation.
  3694  //
  3695  // API parameter values that are decorated as "sensitive" in the API will not
  3696  // be included in the string output. The member name will be present, but the
  3697  // value will be replaced with "sensitive".
  3698  func (s DescribeRoutingControlOutput) GoString() string {
  3699  	return s.String()
  3700  }
  3701  
  3702  // SetRoutingControl sets the RoutingControl field's value.
  3703  func (s *DescribeRoutingControlOutput) SetRoutingControl(v *RoutingControl) *DescribeRoutingControlOutput {
  3704  	s.RoutingControl = v
  3705  	return s
  3706  }
  3707  
  3708  type DescribeSafetyRuleInput struct {
  3709  	_ struct{} `type:"structure" nopayload:"true"`
  3710  
  3711  	// SafetyRuleArn is a required field
  3712  	SafetyRuleArn *string `location:"uri" locationName:"SafetyRuleArn" type:"string" required:"true"`
  3713  }
  3714  
  3715  // String returns the string representation.
  3716  //
  3717  // API parameter values that are decorated as "sensitive" in the API will not
  3718  // be included in the string output. The member name will be present, but the
  3719  // value will be replaced with "sensitive".
  3720  func (s DescribeSafetyRuleInput) String() string {
  3721  	return awsutil.Prettify(s)
  3722  }
  3723  
  3724  // GoString returns the string representation.
  3725  //
  3726  // API parameter values that are decorated as "sensitive" in the API will not
  3727  // be included in the string output. The member name will be present, but the
  3728  // value will be replaced with "sensitive".
  3729  func (s DescribeSafetyRuleInput) GoString() string {
  3730  	return s.String()
  3731  }
  3732  
  3733  // Validate inspects the fields of the type to determine if they are valid.
  3734  func (s *DescribeSafetyRuleInput) Validate() error {
  3735  	invalidParams := request.ErrInvalidParams{Context: "DescribeSafetyRuleInput"}
  3736  	if s.SafetyRuleArn == nil {
  3737  		invalidParams.Add(request.NewErrParamRequired("SafetyRuleArn"))
  3738  	}
  3739  	if s.SafetyRuleArn != nil && len(*s.SafetyRuleArn) < 1 {
  3740  		invalidParams.Add(request.NewErrParamMinLen("SafetyRuleArn", 1))
  3741  	}
  3742  
  3743  	if invalidParams.Len() > 0 {
  3744  		return invalidParams
  3745  	}
  3746  	return nil
  3747  }
  3748  
  3749  // SetSafetyRuleArn sets the SafetyRuleArn field's value.
  3750  func (s *DescribeSafetyRuleInput) SetSafetyRuleArn(v string) *DescribeSafetyRuleInput {
  3751  	s.SafetyRuleArn = &v
  3752  	return s
  3753  }
  3754  
  3755  // The response when you send a DescribeSafetyRuleResponse request.
  3756  type DescribeSafetyRuleOutput struct {
  3757  	_ struct{} `type:"structure"`
  3758  
  3759  	// An assertion rule enforces that, when a routing control state is changed,
  3760  	// the criteria set by the rule configuration is met. Otherwise, the change
  3761  	// to the routing control is not accepted.
  3762  	AssertionRule *AssertionRule `type:"structure"`
  3763  
  3764  	// A gating rule verifies that a set of gating controls evaluates as true, based
  3765  	// on a rule configuration that you specify. If the gating rule evaluates to
  3766  	// true, Amazon Route 53 Application Recovery Controller allows a set of routing
  3767  	// control state changes to run and complete against the set of target controls.
  3768  	GatingRule *GatingRule `type:"structure"`
  3769  }
  3770  
  3771  // String returns the string representation.
  3772  //
  3773  // API parameter values that are decorated as "sensitive" in the API will not
  3774  // be included in the string output. The member name will be present, but the
  3775  // value will be replaced with "sensitive".
  3776  func (s DescribeSafetyRuleOutput) String() string {
  3777  	return awsutil.Prettify(s)
  3778  }
  3779  
  3780  // GoString returns the string representation.
  3781  //
  3782  // API parameter values that are decorated as "sensitive" in the API will not
  3783  // be included in the string output. The member name will be present, but the
  3784  // value will be replaced with "sensitive".
  3785  func (s DescribeSafetyRuleOutput) GoString() string {
  3786  	return s.String()
  3787  }
  3788  
  3789  // SetAssertionRule sets the AssertionRule field's value.
  3790  func (s *DescribeSafetyRuleOutput) SetAssertionRule(v *AssertionRule) *DescribeSafetyRuleOutput {
  3791  	s.AssertionRule = v
  3792  	return s
  3793  }
  3794  
  3795  // SetGatingRule sets the GatingRule field's value.
  3796  func (s *DescribeSafetyRuleOutput) SetGatingRule(v *GatingRule) *DescribeSafetyRuleOutput {
  3797  	s.GatingRule = v
  3798  	return s
  3799  }
  3800  
  3801  // A gating rule verifies that a set of gating controls evaluates as true, based
  3802  // on a rule configuration that you specify. If the gating rule evaluates to
  3803  // true, Amazon Route 53 Application Recovery Controller allows a set of routing
  3804  // control state changes to run and complete against the set of target controls.
  3805  type GatingRule struct {
  3806  	_ struct{} `type:"structure"`
  3807  
  3808  	// The Amazon Resource Name (ARN) of the control panel.
  3809  	//
  3810  	// ControlPanelArn is a required field
  3811  	ControlPanelArn *string `type:"string" required:"true"`
  3812  
  3813  	// The gating controls for the gating rule. That is, routing controls that are
  3814  	// evaluated by the rule configuration that you specify.
  3815  	//
  3816  	// GatingControls is a required field
  3817  	GatingControls []*string `type:"list" required:"true"`
  3818  
  3819  	// The name for the gating rule.
  3820  	//
  3821  	// Name is a required field
  3822  	Name *string `min:"1" type:"string" required:"true"`
  3823  
  3824  	// The criteria that you set for specific gating controls (routing controls)
  3825  	// that designates how many controls must be enabled to allow you to change
  3826  	// (set or unset) the target controls.
  3827  	//
  3828  	// RuleConfig is a required field
  3829  	RuleConfig *RuleConfig `type:"structure" required:"true"`
  3830  
  3831  	// The Amazon Resource Name (ARN) of the gating rule.
  3832  	//
  3833  	// SafetyRuleArn is a required field
  3834  	SafetyRuleArn *string `type:"string" required:"true"`
  3835  
  3836  	// The deployment status of a gating rule. Status can be one of the following:
  3837  	// PENDING, DEPLOYED, PENDING_DELETION.
  3838  	//
  3839  	// Status is a required field
  3840  	Status *string `type:"string" required:"true" enum:"Status"`
  3841  
  3842  	// Routing controls that can only be set or unset if the specified RuleConfig
  3843  	// evaluates to true for the specified GatingControls. For example, say you
  3844  	// have three gating controls, one for each of three Amazon Web Services Regions.
  3845  	// Now you specify ATLEAST 2 as your RuleConfig. With these settings, you can
  3846  	// only change (set or unset) the routing controls that you have specified as
  3847  	// TargetControls if that rule evaluates to true.
  3848  	//
  3849  	// In other words, your ability to change the routing controls that you have
  3850  	// specified as TargetControls is gated by the rule that you set for the routing
  3851  	// controls in GatingControls.
  3852  	//
  3853  	// TargetControls is a required field
  3854  	TargetControls []*string `type:"list" required:"true"`
  3855  
  3856  	// An evaluation period, in milliseconds (ms), during which any request against
  3857  	// the target routing controls will fail. This helps prevent "flapping" of state.
  3858  	// The wait period is 5000 ms by default, but you can choose a custom value.
  3859  	//
  3860  	// WaitPeriodMs is a required field
  3861  	WaitPeriodMs *int64 `type:"integer" required:"true"`
  3862  }
  3863  
  3864  // String returns the string representation.
  3865  //
  3866  // API parameter values that are decorated as "sensitive" in the API will not
  3867  // be included in the string output. The member name will be present, but the
  3868  // value will be replaced with "sensitive".
  3869  func (s GatingRule) String() string {
  3870  	return awsutil.Prettify(s)
  3871  }
  3872  
  3873  // GoString returns the string representation.
  3874  //
  3875  // API parameter values that are decorated as "sensitive" in the API will not
  3876  // be included in the string output. The member name will be present, but the
  3877  // value will be replaced with "sensitive".
  3878  func (s GatingRule) GoString() string {
  3879  	return s.String()
  3880  }
  3881  
  3882  // SetControlPanelArn sets the ControlPanelArn field's value.
  3883  func (s *GatingRule) SetControlPanelArn(v string) *GatingRule {
  3884  	s.ControlPanelArn = &v
  3885  	return s
  3886  }
  3887  
  3888  // SetGatingControls sets the GatingControls field's value.
  3889  func (s *GatingRule) SetGatingControls(v []*string) *GatingRule {
  3890  	s.GatingControls = v
  3891  	return s
  3892  }
  3893  
  3894  // SetName sets the Name field's value.
  3895  func (s *GatingRule) SetName(v string) *GatingRule {
  3896  	s.Name = &v
  3897  	return s
  3898  }
  3899  
  3900  // SetRuleConfig sets the RuleConfig field's value.
  3901  func (s *GatingRule) SetRuleConfig(v *RuleConfig) *GatingRule {
  3902  	s.RuleConfig = v
  3903  	return s
  3904  }
  3905  
  3906  // SetSafetyRuleArn sets the SafetyRuleArn field's value.
  3907  func (s *GatingRule) SetSafetyRuleArn(v string) *GatingRule {
  3908  	s.SafetyRuleArn = &v
  3909  	return s
  3910  }
  3911  
  3912  // SetStatus sets the Status field's value.
  3913  func (s *GatingRule) SetStatus(v string) *GatingRule {
  3914  	s.Status = &v
  3915  	return s
  3916  }
  3917  
  3918  // SetTargetControls sets the TargetControls field's value.
  3919  func (s *GatingRule) SetTargetControls(v []*string) *GatingRule {
  3920  	s.TargetControls = v
  3921  	return s
  3922  }
  3923  
  3924  // SetWaitPeriodMs sets the WaitPeriodMs field's value.
  3925  func (s *GatingRule) SetWaitPeriodMs(v int64) *GatingRule {
  3926  	s.WaitPeriodMs = &v
  3927  	return s
  3928  }
  3929  
  3930  // Update to a gating rule. You can update the name or the evaluation period
  3931  // (wait period). If you don't specify one of the items to update, the item
  3932  // is unchanged.
  3933  type GatingRuleUpdate struct {
  3934  	_ struct{} `type:"structure"`
  3935  
  3936  	// The name for the gating rule.
  3937  	//
  3938  	// Name is a required field
  3939  	Name *string `min:"1" type:"string" required:"true"`
  3940  
  3941  	// The Amazon Resource Name (ARN) of the gating rule.
  3942  	//
  3943  	// SafetyRuleArn is a required field
  3944  	SafetyRuleArn *string `type:"string" required:"true"`
  3945  
  3946  	// An evaluation period, in milliseconds (ms), during which any request against
  3947  	// the target routing controls will fail. This helps prevent "flapping" of state.
  3948  	// The wait period is 5000 ms by default, but you can choose a custom value.
  3949  	//
  3950  	// WaitPeriodMs is a required field
  3951  	WaitPeriodMs *int64 `type:"integer" required:"true"`
  3952  }
  3953  
  3954  // String returns the string representation.
  3955  //
  3956  // API parameter values that are decorated as "sensitive" in the API will not
  3957  // be included in the string output. The member name will be present, but the
  3958  // value will be replaced with "sensitive".
  3959  func (s GatingRuleUpdate) String() string {
  3960  	return awsutil.Prettify(s)
  3961  }
  3962  
  3963  // GoString returns the string representation.
  3964  //
  3965  // API parameter values that are decorated as "sensitive" in the API will not
  3966  // be included in the string output. The member name will be present, but the
  3967  // value will be replaced with "sensitive".
  3968  func (s GatingRuleUpdate) GoString() string {
  3969  	return s.String()
  3970  }
  3971  
  3972  // Validate inspects the fields of the type to determine if they are valid.
  3973  func (s *GatingRuleUpdate) Validate() error {
  3974  	invalidParams := request.ErrInvalidParams{Context: "GatingRuleUpdate"}
  3975  	if s.Name == nil {
  3976  		invalidParams.Add(request.NewErrParamRequired("Name"))
  3977  	}
  3978  	if s.Name != nil && len(*s.Name) < 1 {
  3979  		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
  3980  	}
  3981  	if s.SafetyRuleArn == nil {
  3982  		invalidParams.Add(request.NewErrParamRequired("SafetyRuleArn"))
  3983  	}
  3984  	if s.WaitPeriodMs == nil {
  3985  		invalidParams.Add(request.NewErrParamRequired("WaitPeriodMs"))
  3986  	}
  3987  
  3988  	if invalidParams.Len() > 0 {
  3989  		return invalidParams
  3990  	}
  3991  	return nil
  3992  }
  3993  
  3994  // SetName sets the Name field's value.
  3995  func (s *GatingRuleUpdate) SetName(v string) *GatingRuleUpdate {
  3996  	s.Name = &v
  3997  	return s
  3998  }
  3999  
  4000  // SetSafetyRuleArn sets the SafetyRuleArn field's value.
  4001  func (s *GatingRuleUpdate) SetSafetyRuleArn(v string) *GatingRuleUpdate {
  4002  	s.SafetyRuleArn = &v
  4003  	return s
  4004  }
  4005  
  4006  // SetWaitPeriodMs sets the WaitPeriodMs field's value.
  4007  func (s *GatingRuleUpdate) SetWaitPeriodMs(v int64) *GatingRuleUpdate {
  4008  	s.WaitPeriodMs = &v
  4009  	return s
  4010  }
  4011  
  4012  // 500 response - InternalServiceError. Temporary service error. Retry the request.
  4013  type InternalServerException struct {
  4014  	_            struct{}                  `type:"structure"`
  4015  	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
  4016  
  4017  	Message_ *string `locationName:"message" type:"string"`
  4018  }
  4019  
  4020  // String returns the string representation.
  4021  //
  4022  // API parameter values that are decorated as "sensitive" in the API will not
  4023  // be included in the string output. The member name will be present, but the
  4024  // value will be replaced with "sensitive".
  4025  func (s InternalServerException) String() string {
  4026  	return awsutil.Prettify(s)
  4027  }
  4028  
  4029  // GoString returns the string representation.
  4030  //
  4031  // API parameter values that are decorated as "sensitive" in the API will not
  4032  // be included in the string output. The member name will be present, but the
  4033  // value will be replaced with "sensitive".
  4034  func (s InternalServerException) GoString() string {
  4035  	return s.String()
  4036  }
  4037  
  4038  func newErrorInternalServerException(v protocol.ResponseMetadata) error {
  4039  	return &InternalServerException{
  4040  		RespMetadata: v,
  4041  	}
  4042  }
  4043  
  4044  // Code returns the exception type name.
  4045  func (s *InternalServerException) Code() string {
  4046  	return "InternalServerException"
  4047  }
  4048  
  4049  // Message returns the exception's message.
  4050  func (s *InternalServerException) Message() string {
  4051  	if s.Message_ != nil {
  4052  		return *s.Message_
  4053  	}
  4054  	return ""
  4055  }
  4056  
  4057  // OrigErr always returns nil, satisfies awserr.Error interface.
  4058  func (s *InternalServerException) OrigErr() error {
  4059  	return nil
  4060  }
  4061  
  4062  func (s *InternalServerException) Error() string {
  4063  	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
  4064  }
  4065  
  4066  // Status code returns the HTTP status code for the request's response error.
  4067  func (s *InternalServerException) StatusCode() int {
  4068  	return s.RespMetadata.StatusCode
  4069  }
  4070  
  4071  // RequestID returns the service's response RequestID for request.
  4072  func (s *InternalServerException) RequestID() string {
  4073  	return s.RespMetadata.RequestID
  4074  }
  4075  
  4076  type ListAssociatedRoute53HealthChecksInput struct {
  4077  	_ struct{} `type:"structure" nopayload:"true"`
  4078  
  4079  	MaxResults *int64 `location:"querystring" locationName:"MaxResults" min:"1" type:"integer"`
  4080  
  4081  	NextToken *string `location:"querystring" locationName:"NextToken" type:"string"`
  4082  
  4083  	// RoutingControlArn is a required field
  4084  	RoutingControlArn *string `location:"uri" locationName:"RoutingControlArn" type:"string" required:"true"`
  4085  }
  4086  
  4087  // String returns the string representation.
  4088  //
  4089  // API parameter values that are decorated as "sensitive" in the API will not
  4090  // be included in the string output. The member name will be present, but the
  4091  // value will be replaced with "sensitive".
  4092  func (s ListAssociatedRoute53HealthChecksInput) String() string {
  4093  	return awsutil.Prettify(s)
  4094  }
  4095  
  4096  // GoString returns the string representation.
  4097  //
  4098  // API parameter values that are decorated as "sensitive" in the API will not
  4099  // be included in the string output. The member name will be present, but the
  4100  // value will be replaced with "sensitive".
  4101  func (s ListAssociatedRoute53HealthChecksInput) GoString() string {
  4102  	return s.String()
  4103  }
  4104  
  4105  // Validate inspects the fields of the type to determine if they are valid.
  4106  func (s *ListAssociatedRoute53HealthChecksInput) Validate() error {
  4107  	invalidParams := request.ErrInvalidParams{Context: "ListAssociatedRoute53HealthChecksInput"}
  4108  	if s.MaxResults != nil && *s.MaxResults < 1 {
  4109  		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
  4110  	}
  4111  	if s.RoutingControlArn == nil {
  4112  		invalidParams.Add(request.NewErrParamRequired("RoutingControlArn"))
  4113  	}
  4114  	if s.RoutingControlArn != nil && len(*s.RoutingControlArn) < 1 {
  4115  		invalidParams.Add(request.NewErrParamMinLen("RoutingControlArn", 1))
  4116  	}
  4117  
  4118  	if invalidParams.Len() > 0 {
  4119  		return invalidParams
  4120  	}
  4121  	return nil
  4122  }
  4123  
  4124  // SetMaxResults sets the MaxResults field's value.
  4125  func (s *ListAssociatedRoute53HealthChecksInput) SetMaxResults(v int64) *ListAssociatedRoute53HealthChecksInput {
  4126  	s.MaxResults = &v
  4127  	return s
  4128  }
  4129  
  4130  // SetNextToken sets the NextToken field's value.
  4131  func (s *ListAssociatedRoute53HealthChecksInput) SetNextToken(v string) *ListAssociatedRoute53HealthChecksInput {
  4132  	s.NextToken = &v
  4133  	return s
  4134  }
  4135  
  4136  // SetRoutingControlArn sets the RoutingControlArn field's value.
  4137  func (s *ListAssociatedRoute53HealthChecksInput) SetRoutingControlArn(v string) *ListAssociatedRoute53HealthChecksInput {
  4138  	s.RoutingControlArn = &v
  4139  	return s
  4140  }
  4141  
  4142  // The result of a successful ListAssociatedRoute53HealthChecks request.
  4143  type ListAssociatedRoute53HealthChecksOutput struct {
  4144  	_ struct{} `type:"structure"`
  4145  
  4146  	// Identifiers for the health checks.
  4147  	HealthCheckIds []*string `type:"list"`
  4148  
  4149  	// The token that identifies which batch of results you want to see.
  4150  	NextToken *string `type:"string"`
  4151  }
  4152  
  4153  // String returns the string representation.
  4154  //
  4155  // API parameter values that are decorated as "sensitive" in the API will not
  4156  // be included in the string output. The member name will be present, but the
  4157  // value will be replaced with "sensitive".
  4158  func (s ListAssociatedRoute53HealthChecksOutput) String() string {
  4159  	return awsutil.Prettify(s)
  4160  }
  4161  
  4162  // GoString returns the string representation.
  4163  //
  4164  // API parameter values that are decorated as "sensitive" in the API will not
  4165  // be included in the string output. The member name will be present, but the
  4166  // value will be replaced with "sensitive".
  4167  func (s ListAssociatedRoute53HealthChecksOutput) GoString() string {
  4168  	return s.String()
  4169  }
  4170  
  4171  // SetHealthCheckIds sets the HealthCheckIds field's value.
  4172  func (s *ListAssociatedRoute53HealthChecksOutput) SetHealthCheckIds(v []*string) *ListAssociatedRoute53HealthChecksOutput {
  4173  	s.HealthCheckIds = v
  4174  	return s
  4175  }
  4176  
  4177  // SetNextToken sets the NextToken field's value.
  4178  func (s *ListAssociatedRoute53HealthChecksOutput) SetNextToken(v string) *ListAssociatedRoute53HealthChecksOutput {
  4179  	s.NextToken = &v
  4180  	return s
  4181  }
  4182  
  4183  type ListClustersInput struct {
  4184  	_ struct{} `type:"structure" nopayload:"true"`
  4185  
  4186  	MaxResults *int64 `location:"querystring" locationName:"MaxResults" min:"1" type:"integer"`
  4187  
  4188  	NextToken *string `location:"querystring" locationName:"NextToken" type:"string"`
  4189  }
  4190  
  4191  // String returns the string representation.
  4192  //
  4193  // API parameter values that are decorated as "sensitive" in the API will not
  4194  // be included in the string output. The member name will be present, but the
  4195  // value will be replaced with "sensitive".
  4196  func (s ListClustersInput) String() string {
  4197  	return awsutil.Prettify(s)
  4198  }
  4199  
  4200  // GoString returns the string representation.
  4201  //
  4202  // API parameter values that are decorated as "sensitive" in the API will not
  4203  // be included in the string output. The member name will be present, but the
  4204  // value will be replaced with "sensitive".
  4205  func (s ListClustersInput) GoString() string {
  4206  	return s.String()
  4207  }
  4208  
  4209  // Validate inspects the fields of the type to determine if they are valid.
  4210  func (s *ListClustersInput) Validate() error {
  4211  	invalidParams := request.ErrInvalidParams{Context: "ListClustersInput"}
  4212  	if s.MaxResults != nil && *s.MaxResults < 1 {
  4213  		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
  4214  	}
  4215  
  4216  	if invalidParams.Len() > 0 {
  4217  		return invalidParams
  4218  	}
  4219  	return nil
  4220  }
  4221  
  4222  // SetMaxResults sets the MaxResults field's value.
  4223  func (s *ListClustersInput) SetMaxResults(v int64) *ListClustersInput {
  4224  	s.MaxResults = &v
  4225  	return s
  4226  }
  4227  
  4228  // SetNextToken sets the NextToken field's value.
  4229  func (s *ListClustersInput) SetNextToken(v string) *ListClustersInput {
  4230  	s.NextToken = &v
  4231  	return s
  4232  }
  4233  
  4234  // The result of a successful ListClusters request.
  4235  type ListClustersOutput struct {
  4236  	_ struct{} `type:"structure"`
  4237  
  4238  	// An array of the clusters in an account.
  4239  	Clusters []*Cluster `type:"list"`
  4240  
  4241  	// The token that identifies which batch of results you want to see.
  4242  	NextToken *string `type:"string"`
  4243  }
  4244  
  4245  // String returns the string representation.
  4246  //
  4247  // API parameter values that are decorated as "sensitive" in the API will not
  4248  // be included in the string output. The member name will be present, but the
  4249  // value will be replaced with "sensitive".
  4250  func (s ListClustersOutput) String() string {
  4251  	return awsutil.Prettify(s)
  4252  }
  4253  
  4254  // GoString returns the string representation.
  4255  //
  4256  // API parameter values that are decorated as "sensitive" in the API will not
  4257  // be included in the string output. The member name will be present, but the
  4258  // value will be replaced with "sensitive".
  4259  func (s ListClustersOutput) GoString() string {
  4260  	return s.String()
  4261  }
  4262  
  4263  // SetClusters sets the Clusters field's value.
  4264  func (s *ListClustersOutput) SetClusters(v []*Cluster) *ListClustersOutput {
  4265  	s.Clusters = v
  4266  	return s
  4267  }
  4268  
  4269  // SetNextToken sets the NextToken field's value.
  4270  func (s *ListClustersOutput) SetNextToken(v string) *ListClustersOutput {
  4271  	s.NextToken = &v
  4272  	return s
  4273  }
  4274  
  4275  type ListControlPanelsInput struct {
  4276  	_ struct{} `type:"structure" nopayload:"true"`
  4277  
  4278  	ClusterArn *string `location:"querystring" locationName:"ClusterArn" type:"string"`
  4279  
  4280  	MaxResults *int64 `location:"querystring" locationName:"MaxResults" min:"1" type:"integer"`
  4281  
  4282  	NextToken *string `location:"querystring" locationName:"NextToken" type:"string"`
  4283  }
  4284  
  4285  // String returns the string representation.
  4286  //
  4287  // API parameter values that are decorated as "sensitive" in the API will not
  4288  // be included in the string output. The member name will be present, but the
  4289  // value will be replaced with "sensitive".
  4290  func (s ListControlPanelsInput) String() string {
  4291  	return awsutil.Prettify(s)
  4292  }
  4293  
  4294  // GoString returns the string representation.
  4295  //
  4296  // API parameter values that are decorated as "sensitive" in the API will not
  4297  // be included in the string output. The member name will be present, but the
  4298  // value will be replaced with "sensitive".
  4299  func (s ListControlPanelsInput) GoString() string {
  4300  	return s.String()
  4301  }
  4302  
  4303  // Validate inspects the fields of the type to determine if they are valid.
  4304  func (s *ListControlPanelsInput) Validate() error {
  4305  	invalidParams := request.ErrInvalidParams{Context: "ListControlPanelsInput"}
  4306  	if s.MaxResults != nil && *s.MaxResults < 1 {
  4307  		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
  4308  	}
  4309  
  4310  	if invalidParams.Len() > 0 {
  4311  		return invalidParams
  4312  	}
  4313  	return nil
  4314  }
  4315  
  4316  // SetClusterArn sets the ClusterArn field's value.
  4317  func (s *ListControlPanelsInput) SetClusterArn(v string) *ListControlPanelsInput {
  4318  	s.ClusterArn = &v
  4319  	return s
  4320  }
  4321  
  4322  // SetMaxResults sets the MaxResults field's value.
  4323  func (s *ListControlPanelsInput) SetMaxResults(v int64) *ListControlPanelsInput {
  4324  	s.MaxResults = &v
  4325  	return s
  4326  }
  4327  
  4328  // SetNextToken sets the NextToken field's value.
  4329  func (s *ListControlPanelsInput) SetNextToken(v string) *ListControlPanelsInput {
  4330  	s.NextToken = &v
  4331  	return s
  4332  }
  4333  
  4334  // The result of a successful ListControlPanel request.
  4335  type ListControlPanelsOutput struct {
  4336  	_ struct{} `type:"structure"`
  4337  
  4338  	// The result of a successful ListControlPanel request.
  4339  	ControlPanels []*ControlPanel `type:"list"`
  4340  
  4341  	// The token that identifies which batch of results you want to see.
  4342  	NextToken *string `type:"string"`
  4343  }
  4344  
  4345  // String returns the string representation.
  4346  //
  4347  // API parameter values that are decorated as "sensitive" in the API will not
  4348  // be included in the string output. The member name will be present, but the
  4349  // value will be replaced with "sensitive".
  4350  func (s ListControlPanelsOutput) String() string {
  4351  	return awsutil.Prettify(s)
  4352  }
  4353  
  4354  // GoString returns the string representation.
  4355  //
  4356  // API parameter values that are decorated as "sensitive" in the API will not
  4357  // be included in the string output. The member name will be present, but the
  4358  // value will be replaced with "sensitive".
  4359  func (s ListControlPanelsOutput) GoString() string {
  4360  	return s.String()
  4361  }
  4362  
  4363  // SetControlPanels sets the ControlPanels field's value.
  4364  func (s *ListControlPanelsOutput) SetControlPanels(v []*ControlPanel) *ListControlPanelsOutput {
  4365  	s.ControlPanels = v
  4366  	return s
  4367  }
  4368  
  4369  // SetNextToken sets the NextToken field's value.
  4370  func (s *ListControlPanelsOutput) SetNextToken(v string) *ListControlPanelsOutput {
  4371  	s.NextToken = &v
  4372  	return s
  4373  }
  4374  
  4375  type ListRoutingControlsInput struct {
  4376  	_ struct{} `type:"structure" nopayload:"true"`
  4377  
  4378  	// ControlPanelArn is a required field
  4379  	ControlPanelArn *string `location:"uri" locationName:"ControlPanelArn" type:"string" required:"true"`
  4380  
  4381  	MaxResults *int64 `location:"querystring" locationName:"MaxResults" min:"1" type:"integer"`
  4382  
  4383  	NextToken *string `location:"querystring" locationName:"NextToken" type:"string"`
  4384  }
  4385  
  4386  // String returns the string representation.
  4387  //
  4388  // API parameter values that are decorated as "sensitive" in the API will not
  4389  // be included in the string output. The member name will be present, but the
  4390  // value will be replaced with "sensitive".
  4391  func (s ListRoutingControlsInput) String() string {
  4392  	return awsutil.Prettify(s)
  4393  }
  4394  
  4395  // GoString returns the string representation.
  4396  //
  4397  // API parameter values that are decorated as "sensitive" in the API will not
  4398  // be included in the string output. The member name will be present, but the
  4399  // value will be replaced with "sensitive".
  4400  func (s ListRoutingControlsInput) GoString() string {
  4401  	return s.String()
  4402  }
  4403  
  4404  // Validate inspects the fields of the type to determine if they are valid.
  4405  func (s *ListRoutingControlsInput) Validate() error {
  4406  	invalidParams := request.ErrInvalidParams{Context: "ListRoutingControlsInput"}
  4407  	if s.ControlPanelArn == nil {
  4408  		invalidParams.Add(request.NewErrParamRequired("ControlPanelArn"))
  4409  	}
  4410  	if s.ControlPanelArn != nil && len(*s.ControlPanelArn) < 1 {
  4411  		invalidParams.Add(request.NewErrParamMinLen("ControlPanelArn", 1))
  4412  	}
  4413  	if s.MaxResults != nil && *s.MaxResults < 1 {
  4414  		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
  4415  	}
  4416  
  4417  	if invalidParams.Len() > 0 {
  4418  		return invalidParams
  4419  	}
  4420  	return nil
  4421  }
  4422  
  4423  // SetControlPanelArn sets the ControlPanelArn field's value.
  4424  func (s *ListRoutingControlsInput) SetControlPanelArn(v string) *ListRoutingControlsInput {
  4425  	s.ControlPanelArn = &v
  4426  	return s
  4427  }
  4428  
  4429  // SetMaxResults sets the MaxResults field's value.
  4430  func (s *ListRoutingControlsInput) SetMaxResults(v int64) *ListRoutingControlsInput {
  4431  	s.MaxResults = &v
  4432  	return s
  4433  }
  4434  
  4435  // SetNextToken sets the NextToken field's value.
  4436  func (s *ListRoutingControlsInput) SetNextToken(v string) *ListRoutingControlsInput {
  4437  	s.NextToken = &v
  4438  	return s
  4439  }
  4440  
  4441  // The result of a successful ListRoutingControl request.
  4442  type ListRoutingControlsOutput struct {
  4443  	_ struct{} `type:"structure"`
  4444  
  4445  	// The token that identifies which batch of results you want to see.
  4446  	NextToken *string `type:"string"`
  4447  
  4448  	// An array of routing controls.
  4449  	RoutingControls []*RoutingControl `type:"list"`
  4450  }
  4451  
  4452  // String returns the string representation.
  4453  //
  4454  // API parameter values that are decorated as "sensitive" in the API will not
  4455  // be included in the string output. The member name will be present, but the
  4456  // value will be replaced with "sensitive".
  4457  func (s ListRoutingControlsOutput) String() string {
  4458  	return awsutil.Prettify(s)
  4459  }
  4460  
  4461  // GoString returns the string representation.
  4462  //
  4463  // API parameter values that are decorated as "sensitive" in the API will not
  4464  // be included in the string output. The member name will be present, but the
  4465  // value will be replaced with "sensitive".
  4466  func (s ListRoutingControlsOutput) GoString() string {
  4467  	return s.String()
  4468  }
  4469  
  4470  // SetNextToken sets the NextToken field's value.
  4471  func (s *ListRoutingControlsOutput) SetNextToken(v string) *ListRoutingControlsOutput {
  4472  	s.NextToken = &v
  4473  	return s
  4474  }
  4475  
  4476  // SetRoutingControls sets the RoutingControls field's value.
  4477  func (s *ListRoutingControlsOutput) SetRoutingControls(v []*RoutingControl) *ListRoutingControlsOutput {
  4478  	s.RoutingControls = v
  4479  	return s
  4480  }
  4481  
  4482  type ListSafetyRulesInput struct {
  4483  	_ struct{} `type:"structure" nopayload:"true"`
  4484  
  4485  	// ControlPanelArn is a required field
  4486  	ControlPanelArn *string `location:"uri" locationName:"ControlPanelArn" type:"string" required:"true"`
  4487  
  4488  	MaxResults *int64 `location:"querystring" locationName:"MaxResults" min:"1" type:"integer"`
  4489  
  4490  	NextToken *string `location:"querystring" locationName:"NextToken" type:"string"`
  4491  }
  4492  
  4493  // String returns the string representation.
  4494  //
  4495  // API parameter values that are decorated as "sensitive" in the API will not
  4496  // be included in the string output. The member name will be present, but the
  4497  // value will be replaced with "sensitive".
  4498  func (s ListSafetyRulesInput) String() string {
  4499  	return awsutil.Prettify(s)
  4500  }
  4501  
  4502  // GoString returns the string representation.
  4503  //
  4504  // API parameter values that are decorated as "sensitive" in the API will not
  4505  // be included in the string output. The member name will be present, but the
  4506  // value will be replaced with "sensitive".
  4507  func (s ListSafetyRulesInput) GoString() string {
  4508  	return s.String()
  4509  }
  4510  
  4511  // Validate inspects the fields of the type to determine if they are valid.
  4512  func (s *ListSafetyRulesInput) Validate() error {
  4513  	invalidParams := request.ErrInvalidParams{Context: "ListSafetyRulesInput"}
  4514  	if s.ControlPanelArn == nil {
  4515  		invalidParams.Add(request.NewErrParamRequired("ControlPanelArn"))
  4516  	}
  4517  	if s.ControlPanelArn != nil && len(*s.ControlPanelArn) < 1 {
  4518  		invalidParams.Add(request.NewErrParamMinLen("ControlPanelArn", 1))
  4519  	}
  4520  	if s.MaxResults != nil && *s.MaxResults < 1 {
  4521  		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
  4522  	}
  4523  
  4524  	if invalidParams.Len() > 0 {
  4525  		return invalidParams
  4526  	}
  4527  	return nil
  4528  }
  4529  
  4530  // SetControlPanelArn sets the ControlPanelArn field's value.
  4531  func (s *ListSafetyRulesInput) SetControlPanelArn(v string) *ListSafetyRulesInput {
  4532  	s.ControlPanelArn = &v
  4533  	return s
  4534  }
  4535  
  4536  // SetMaxResults sets the MaxResults field's value.
  4537  func (s *ListSafetyRulesInput) SetMaxResults(v int64) *ListSafetyRulesInput {
  4538  	s.MaxResults = &v
  4539  	return s
  4540  }
  4541  
  4542  // SetNextToken sets the NextToken field's value.
  4543  func (s *ListSafetyRulesInput) SetNextToken(v string) *ListSafetyRulesInput {
  4544  	s.NextToken = &v
  4545  	return s
  4546  }
  4547  
  4548  // The response to a ListSafetyRulesRequest.
  4549  type ListSafetyRulesOutput struct {
  4550  	_ struct{} `type:"structure"`
  4551  
  4552  	// The token that identifies which batch of results you want to see.
  4553  	NextToken *string `type:"string"`
  4554  
  4555  	// The list of safety rules in a control panel.
  4556  	SafetyRules []*Rule `type:"list"`
  4557  }
  4558  
  4559  // String returns the string representation.
  4560  //
  4561  // API parameter values that are decorated as "sensitive" in the API will not
  4562  // be included in the string output. The member name will be present, but the
  4563  // value will be replaced with "sensitive".
  4564  func (s ListSafetyRulesOutput) String() string {
  4565  	return awsutil.Prettify(s)
  4566  }
  4567  
  4568  // GoString returns the string representation.
  4569  //
  4570  // API parameter values that are decorated as "sensitive" in the API will not
  4571  // be included in the string output. The member name will be present, but the
  4572  // value will be replaced with "sensitive".
  4573  func (s ListSafetyRulesOutput) GoString() string {
  4574  	return s.String()
  4575  }
  4576  
  4577  // SetNextToken sets the NextToken field's value.
  4578  func (s *ListSafetyRulesOutput) SetNextToken(v string) *ListSafetyRulesOutput {
  4579  	s.NextToken = &v
  4580  	return s
  4581  }
  4582  
  4583  // SetSafetyRules sets the SafetyRules field's value.
  4584  func (s *ListSafetyRulesOutput) SetSafetyRules(v []*Rule) *ListSafetyRulesOutput {
  4585  	s.SafetyRules = v
  4586  	return s
  4587  }
  4588  
  4589  // A new assertion rule for a control panel.
  4590  type NewAssertionRule struct {
  4591  	_ struct{} `type:"structure"`
  4592  
  4593  	// The routing controls that are part of transactions that are evaluated to
  4594  	// determine if a request to change a routing control state is allowed. For
  4595  	// example, you might include three routing controls, one for each of three
  4596  	// Amazon Web Services Regions.
  4597  	//
  4598  	// AssertedControls is a required field
  4599  	AssertedControls []*string `type:"list" required:"true"`
  4600  
  4601  	// The Amazon Resource Name (ARN) for the control panel.
  4602  	//
  4603  	// ControlPanelArn is a required field
  4604  	ControlPanelArn *string `type:"string" required:"true"`
  4605  
  4606  	// The name of the assertion rule. You can use any non-white space character
  4607  	// in the name.
  4608  	//
  4609  	// Name is a required field
  4610  	Name *string `min:"1" type:"string" required:"true"`
  4611  
  4612  	// The criteria that you set for specific assertion controls (routing controls)
  4613  	// that designate how many controls must be enabled as the result of a transaction.
  4614  	// For example, if you have three assertion controls, you might specify atleast
  4615  	// 2 for your rule configuration. This means that at least two assertion controls
  4616  	// must be enabled, so that at least two Amazon Web Services Regions are enabled.
  4617  	//
  4618  	// RuleConfig is a required field
  4619  	RuleConfig *RuleConfig `type:"structure" required:"true"`
  4620  
  4621  	// An evaluation period, in milliseconds (ms), during which any request against
  4622  	// the target routing controls will fail. This helps prevent "flapping" of state.
  4623  	// The wait period is 5000 ms by default, but you can choose a custom value.
  4624  	//
  4625  	// WaitPeriodMs is a required field
  4626  	WaitPeriodMs *int64 `type:"integer" required:"true"`
  4627  }
  4628  
  4629  // String returns the string representation.
  4630  //
  4631  // API parameter values that are decorated as "sensitive" in the API will not
  4632  // be included in the string output. The member name will be present, but the
  4633  // value will be replaced with "sensitive".
  4634  func (s NewAssertionRule) String() string {
  4635  	return awsutil.Prettify(s)
  4636  }
  4637  
  4638  // GoString returns the string representation.
  4639  //
  4640  // API parameter values that are decorated as "sensitive" in the API will not
  4641  // be included in the string output. The member name will be present, but the
  4642  // value will be replaced with "sensitive".
  4643  func (s NewAssertionRule) GoString() string {
  4644  	return s.String()
  4645  }
  4646  
  4647  // Validate inspects the fields of the type to determine if they are valid.
  4648  func (s *NewAssertionRule) Validate() error {
  4649  	invalidParams := request.ErrInvalidParams{Context: "NewAssertionRule"}
  4650  	if s.AssertedControls == nil {
  4651  		invalidParams.Add(request.NewErrParamRequired("AssertedControls"))
  4652  	}
  4653  	if s.ControlPanelArn == nil {
  4654  		invalidParams.Add(request.NewErrParamRequired("ControlPanelArn"))
  4655  	}
  4656  	if s.Name == nil {
  4657  		invalidParams.Add(request.NewErrParamRequired("Name"))
  4658  	}
  4659  	if s.Name != nil && len(*s.Name) < 1 {
  4660  		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
  4661  	}
  4662  	if s.RuleConfig == nil {
  4663  		invalidParams.Add(request.NewErrParamRequired("RuleConfig"))
  4664  	}
  4665  	if s.WaitPeriodMs == nil {
  4666  		invalidParams.Add(request.NewErrParamRequired("WaitPeriodMs"))
  4667  	}
  4668  	if s.RuleConfig != nil {
  4669  		if err := s.RuleConfig.Validate(); err != nil {
  4670  			invalidParams.AddNested("RuleConfig", err.(request.ErrInvalidParams))
  4671  		}
  4672  	}
  4673  
  4674  	if invalidParams.Len() > 0 {
  4675  		return invalidParams
  4676  	}
  4677  	return nil
  4678  }
  4679  
  4680  // SetAssertedControls sets the AssertedControls field's value.
  4681  func (s *NewAssertionRule) SetAssertedControls(v []*string) *NewAssertionRule {
  4682  	s.AssertedControls = v
  4683  	return s
  4684  }
  4685  
  4686  // SetControlPanelArn sets the ControlPanelArn field's value.
  4687  func (s *NewAssertionRule) SetControlPanelArn(v string) *NewAssertionRule {
  4688  	s.ControlPanelArn = &v
  4689  	return s
  4690  }
  4691  
  4692  // SetName sets the Name field's value.
  4693  func (s *NewAssertionRule) SetName(v string) *NewAssertionRule {
  4694  	s.Name = &v
  4695  	return s
  4696  }
  4697  
  4698  // SetRuleConfig sets the RuleConfig field's value.
  4699  func (s *NewAssertionRule) SetRuleConfig(v *RuleConfig) *NewAssertionRule {
  4700  	s.RuleConfig = v
  4701  	return s
  4702  }
  4703  
  4704  // SetWaitPeriodMs sets the WaitPeriodMs field's value.
  4705  func (s *NewAssertionRule) SetWaitPeriodMs(v int64) *NewAssertionRule {
  4706  	s.WaitPeriodMs = &v
  4707  	return s
  4708  }
  4709  
  4710  // A new gating rule for a control panel.
  4711  type NewGatingRule struct {
  4712  	_ struct{} `type:"structure"`
  4713  
  4714  	// The Amazon Resource Name (ARN) of the control panel.
  4715  	//
  4716  	// ControlPanelArn is a required field
  4717  	ControlPanelArn *string `type:"string" required:"true"`
  4718  
  4719  	// The gating controls for the new gating rule. That is, routing controls that
  4720  	// are evaluated by the rule configuration that you specify.
  4721  	//
  4722  	// GatingControls is a required field
  4723  	GatingControls []*string `type:"list" required:"true"`
  4724  
  4725  	// The name for the new gating rule.
  4726  	//
  4727  	// Name is a required field
  4728  	Name *string `min:"1" type:"string" required:"true"`
  4729  
  4730  	// The criteria that you set for specific gating controls (routing controls)
  4731  	// that designates how many controls must be enabled to allow you to change
  4732  	// (set or unset) the target controls.
  4733  	//
  4734  	// RuleConfig is a required field
  4735  	RuleConfig *RuleConfig `type:"structure" required:"true"`
  4736  
  4737  	// Routing controls that can only be set or unset if the specified RuleConfig
  4738  	// evaluates to true for the specified GatingControls. For example, say you
  4739  	// have three gating controls, one for each of three Amazon Web Services Regions.
  4740  	// Now you specify AtLeast 2 as your RuleConfig. With these settings, you can
  4741  	// only change (set or unset) the routing controls that you have specified as
  4742  	// TargetControls if that rule evaluates to true.
  4743  	//
  4744  	// In other words, your ability to change the routing controls that you have
  4745  	// specified as TargetControls is gated by the rule that you set for the routing
  4746  	// controls in GatingControls.
  4747  	//
  4748  	// TargetControls is a required field
  4749  	TargetControls []*string `type:"list" required:"true"`
  4750  
  4751  	// An evaluation period, in milliseconds (ms), during which any request against
  4752  	// the target routing controls will fail. This helps prevent "flapping" of state.
  4753  	// The wait period is 5000 ms by default, but you can choose a custom value.
  4754  	//
  4755  	// WaitPeriodMs is a required field
  4756  	WaitPeriodMs *int64 `type:"integer" required:"true"`
  4757  }
  4758  
  4759  // String returns the string representation.
  4760  //
  4761  // API parameter values that are decorated as "sensitive" in the API will not
  4762  // be included in the string output. The member name will be present, but the
  4763  // value will be replaced with "sensitive".
  4764  func (s NewGatingRule) String() string {
  4765  	return awsutil.Prettify(s)
  4766  }
  4767  
  4768  // GoString returns the string representation.
  4769  //
  4770  // API parameter values that are decorated as "sensitive" in the API will not
  4771  // be included in the string output. The member name will be present, but the
  4772  // value will be replaced with "sensitive".
  4773  func (s NewGatingRule) GoString() string {
  4774  	return s.String()
  4775  }
  4776  
  4777  // Validate inspects the fields of the type to determine if they are valid.
  4778  func (s *NewGatingRule) Validate() error {
  4779  	invalidParams := request.ErrInvalidParams{Context: "NewGatingRule"}
  4780  	if s.ControlPanelArn == nil {
  4781  		invalidParams.Add(request.NewErrParamRequired("ControlPanelArn"))
  4782  	}
  4783  	if s.GatingControls == nil {
  4784  		invalidParams.Add(request.NewErrParamRequired("GatingControls"))
  4785  	}
  4786  	if s.Name == nil {
  4787  		invalidParams.Add(request.NewErrParamRequired("Name"))
  4788  	}
  4789  	if s.Name != nil && len(*s.Name) < 1 {
  4790  		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
  4791  	}
  4792  	if s.RuleConfig == nil {
  4793  		invalidParams.Add(request.NewErrParamRequired("RuleConfig"))
  4794  	}
  4795  	if s.TargetControls == nil {
  4796  		invalidParams.Add(request.NewErrParamRequired("TargetControls"))
  4797  	}
  4798  	if s.WaitPeriodMs == nil {
  4799  		invalidParams.Add(request.NewErrParamRequired("WaitPeriodMs"))
  4800  	}
  4801  	if s.RuleConfig != nil {
  4802  		if err := s.RuleConfig.Validate(); err != nil {
  4803  			invalidParams.AddNested("RuleConfig", err.(request.ErrInvalidParams))
  4804  		}
  4805  	}
  4806  
  4807  	if invalidParams.Len() > 0 {
  4808  		return invalidParams
  4809  	}
  4810  	return nil
  4811  }
  4812  
  4813  // SetControlPanelArn sets the ControlPanelArn field's value.
  4814  func (s *NewGatingRule) SetControlPanelArn(v string) *NewGatingRule {
  4815  	s.ControlPanelArn = &v
  4816  	return s
  4817  }
  4818  
  4819  // SetGatingControls sets the GatingControls field's value.
  4820  func (s *NewGatingRule) SetGatingControls(v []*string) *NewGatingRule {
  4821  	s.GatingControls = v
  4822  	return s
  4823  }
  4824  
  4825  // SetName sets the Name field's value.
  4826  func (s *NewGatingRule) SetName(v string) *NewGatingRule {
  4827  	s.Name = &v
  4828  	return s
  4829  }
  4830  
  4831  // SetRuleConfig sets the RuleConfig field's value.
  4832  func (s *NewGatingRule) SetRuleConfig(v *RuleConfig) *NewGatingRule {
  4833  	s.RuleConfig = v
  4834  	return s
  4835  }
  4836  
  4837  // SetTargetControls sets the TargetControls field's value.
  4838  func (s *NewGatingRule) SetTargetControls(v []*string) *NewGatingRule {
  4839  	s.TargetControls = v
  4840  	return s
  4841  }
  4842  
  4843  // SetWaitPeriodMs sets the WaitPeriodMs field's value.
  4844  func (s *NewGatingRule) SetWaitPeriodMs(v int64) *NewGatingRule {
  4845  	s.WaitPeriodMs = &v
  4846  	return s
  4847  }
  4848  
  4849  // 404 response - The query string contains a syntax error or resource not found.
  4850  type ResourceNotFoundException struct {
  4851  	_            struct{}                  `type:"structure"`
  4852  	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
  4853  
  4854  	Message_ *string `locationName:"message" type:"string"`
  4855  }
  4856  
  4857  // String returns the string representation.
  4858  //
  4859  // API parameter values that are decorated as "sensitive" in the API will not
  4860  // be included in the string output. The member name will be present, but the
  4861  // value will be replaced with "sensitive".
  4862  func (s ResourceNotFoundException) String() string {
  4863  	return awsutil.Prettify(s)
  4864  }
  4865  
  4866  // GoString returns the string representation.
  4867  //
  4868  // API parameter values that are decorated as "sensitive" in the API will not
  4869  // be included in the string output. The member name will be present, but the
  4870  // value will be replaced with "sensitive".
  4871  func (s ResourceNotFoundException) GoString() string {
  4872  	return s.String()
  4873  }
  4874  
  4875  func newErrorResourceNotFoundException(v protocol.ResponseMetadata) error {
  4876  	return &ResourceNotFoundException{
  4877  		RespMetadata: v,
  4878  	}
  4879  }
  4880  
  4881  // Code returns the exception type name.
  4882  func (s *ResourceNotFoundException) Code() string {
  4883  	return "ResourceNotFoundException"
  4884  }
  4885  
  4886  // Message returns the exception's message.
  4887  func (s *ResourceNotFoundException) Message() string {
  4888  	if s.Message_ != nil {
  4889  		return *s.Message_
  4890  	}
  4891  	return ""
  4892  }
  4893  
  4894  // OrigErr always returns nil, satisfies awserr.Error interface.
  4895  func (s *ResourceNotFoundException) OrigErr() error {
  4896  	return nil
  4897  }
  4898  
  4899  func (s *ResourceNotFoundException) Error() string {
  4900  	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
  4901  }
  4902  
  4903  // Status code returns the HTTP status code for the request's response error.
  4904  func (s *ResourceNotFoundException) StatusCode() int {
  4905  	return s.RespMetadata.StatusCode
  4906  }
  4907  
  4908  // RequestID returns the service's response RequestID for request.
  4909  func (s *ResourceNotFoundException) RequestID() string {
  4910  	return s.RespMetadata.RequestID
  4911  }
  4912  
  4913  // A routing control has one of two states: ON and OFF. You can map the routing
  4914  // control state to the state of an Amazon Route 53 health check, which can
  4915  // be used to control traffic routing.
  4916  type RoutingControl struct {
  4917  	_ struct{} `type:"structure"`
  4918  
  4919  	// The Amazon Resource Name (ARN) of the control panel that includes the routing
  4920  	// control.
  4921  	ControlPanelArn *string `type:"string"`
  4922  
  4923  	// The name of the routing control.
  4924  	Name *string `min:"1" type:"string"`
  4925  
  4926  	// The Amazon Resource Name (ARN) of the routing control.
  4927  	RoutingControlArn *string `type:"string"`
  4928  
  4929  	// The deployment status of a routing control. Status can be one of the following:
  4930  	// PENDING, DEPLOYED, PENDING_DELETION.
  4931  	Status *string `type:"string" enum:"Status"`
  4932  }
  4933  
  4934  // String returns the string representation.
  4935  //
  4936  // API parameter values that are decorated as "sensitive" in the API will not
  4937  // be included in the string output. The member name will be present, but the
  4938  // value will be replaced with "sensitive".
  4939  func (s RoutingControl) String() string {
  4940  	return awsutil.Prettify(s)
  4941  }
  4942  
  4943  // GoString returns the string representation.
  4944  //
  4945  // API parameter values that are decorated as "sensitive" in the API will not
  4946  // be included in the string output. The member name will be present, but the
  4947  // value will be replaced with "sensitive".
  4948  func (s RoutingControl) GoString() string {
  4949  	return s.String()
  4950  }
  4951  
  4952  // SetControlPanelArn sets the ControlPanelArn field's value.
  4953  func (s *RoutingControl) SetControlPanelArn(v string) *RoutingControl {
  4954  	s.ControlPanelArn = &v
  4955  	return s
  4956  }
  4957  
  4958  // SetName sets the Name field's value.
  4959  func (s *RoutingControl) SetName(v string) *RoutingControl {
  4960  	s.Name = &v
  4961  	return s
  4962  }
  4963  
  4964  // SetRoutingControlArn sets the RoutingControlArn field's value.
  4965  func (s *RoutingControl) SetRoutingControlArn(v string) *RoutingControl {
  4966  	s.RoutingControlArn = &v
  4967  	return s
  4968  }
  4969  
  4970  // SetStatus sets the Status field's value.
  4971  func (s *RoutingControl) SetStatus(v string) *RoutingControl {
  4972  	s.Status = &v
  4973  	return s
  4974  }
  4975  
  4976  // A safety rule. A safety rule can be an assertion rule or a gating rule.
  4977  type Rule struct {
  4978  	_ struct{} `type:"structure"`
  4979  
  4980  	// An assertion rule enforces that, when a routing control state is changed,
  4981  	// the criteria set by the rule configuration is met. Otherwise, the change
  4982  	// to the routing control is not accepted.
  4983  	ASSERTION *AssertionRule `type:"structure"`
  4984  
  4985  	// A gating rule verifies that a set of gating controls evaluates as true, based
  4986  	// on a rule configuration that you specify. If the gating rule evaluates to
  4987  	// true, Amazon Route 53 Application Recovery Controller allows a set of routing
  4988  	// control state changes to run and complete against the set of target controls.
  4989  	GATING *GatingRule `type:"structure"`
  4990  }
  4991  
  4992  // String returns the string representation.
  4993  //
  4994  // API parameter values that are decorated as "sensitive" in the API will not
  4995  // be included in the string output. The member name will be present, but the
  4996  // value will be replaced with "sensitive".
  4997  func (s Rule) String() string {
  4998  	return awsutil.Prettify(s)
  4999  }
  5000  
  5001  // GoString returns the string representation.
  5002  //
  5003  // API parameter values that are decorated as "sensitive" in the API will not
  5004  // be included in the string output. The member name will be present, but the
  5005  // value will be replaced with "sensitive".
  5006  func (s Rule) GoString() string {
  5007  	return s.String()
  5008  }
  5009  
  5010  // SetASSERTION sets the ASSERTION field's value.
  5011  func (s *Rule) SetASSERTION(v *AssertionRule) *Rule {
  5012  	s.ASSERTION = v
  5013  	return s
  5014  }
  5015  
  5016  // SetGATING sets the GATING field's value.
  5017  func (s *Rule) SetGATING(v *GatingRule) *Rule {
  5018  	s.GATING = v
  5019  	return s
  5020  }
  5021  
  5022  // The rule configuration for an assertion rule. That is, the criteria that
  5023  // you set for specific assertion controls (routing controls) that specify how
  5024  // many controls must be enabled after a transaction completes.
  5025  type RuleConfig struct {
  5026  	_ struct{} `type:"structure"`
  5027  
  5028  	// Logical negation of the rule. If the rule would usually evaluate true, it's
  5029  	// evaluated as false, and vice versa.
  5030  	//
  5031  	// Inverted is a required field
  5032  	Inverted *bool `type:"boolean" required:"true"`
  5033  
  5034  	// The value of N, when you specify an ATLEAST rule type. That is, Threshold
  5035  	// is the number of controls that must be set when you specify an ATLEAST type.
  5036  	//
  5037  	// Threshold is a required field
  5038  	Threshold *int64 `type:"integer" required:"true"`
  5039  
  5040  	// A rule can be one of the following: ATLEAST, AND, or OR.
  5041  	//
  5042  	// Type is a required field
  5043  	Type *string `type:"string" required:"true" enum:"RuleType"`
  5044  }
  5045  
  5046  // String returns the string representation.
  5047  //
  5048  // API parameter values that are decorated as "sensitive" in the API will not
  5049  // be included in the string output. The member name will be present, but the
  5050  // value will be replaced with "sensitive".
  5051  func (s RuleConfig) String() string {
  5052  	return awsutil.Prettify(s)
  5053  }
  5054  
  5055  // GoString returns the string representation.
  5056  //
  5057  // API parameter values that are decorated as "sensitive" in the API will not
  5058  // be included in the string output. The member name will be present, but the
  5059  // value will be replaced with "sensitive".
  5060  func (s RuleConfig) GoString() string {
  5061  	return s.String()
  5062  }
  5063  
  5064  // Validate inspects the fields of the type to determine if they are valid.
  5065  func (s *RuleConfig) Validate() error {
  5066  	invalidParams := request.ErrInvalidParams{Context: "RuleConfig"}
  5067  	if s.Inverted == nil {
  5068  		invalidParams.Add(request.NewErrParamRequired("Inverted"))
  5069  	}
  5070  	if s.Threshold == nil {
  5071  		invalidParams.Add(request.NewErrParamRequired("Threshold"))
  5072  	}
  5073  	if s.Type == nil {
  5074  		invalidParams.Add(request.NewErrParamRequired("Type"))
  5075  	}
  5076  
  5077  	if invalidParams.Len() > 0 {
  5078  		return invalidParams
  5079  	}
  5080  	return nil
  5081  }
  5082  
  5083  // SetInverted sets the Inverted field's value.
  5084  func (s *RuleConfig) SetInverted(v bool) *RuleConfig {
  5085  	s.Inverted = &v
  5086  	return s
  5087  }
  5088  
  5089  // SetThreshold sets the Threshold field's value.
  5090  func (s *RuleConfig) SetThreshold(v int64) *RuleConfig {
  5091  	s.Threshold = &v
  5092  	return s
  5093  }
  5094  
  5095  // SetType sets the Type field's value.
  5096  func (s *RuleConfig) SetType(v string) *RuleConfig {
  5097  	s.Type = &v
  5098  	return s
  5099  }
  5100  
  5101  // 402 response
  5102  type ServiceQuotaExceededException struct {
  5103  	_            struct{}                  `type:"structure"`
  5104  	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
  5105  
  5106  	Message_ *string `locationName:"message" type:"string"`
  5107  }
  5108  
  5109  // String returns the string representation.
  5110  //
  5111  // API parameter values that are decorated as "sensitive" in the API will not
  5112  // be included in the string output. The member name will be present, but the
  5113  // value will be replaced with "sensitive".
  5114  func (s ServiceQuotaExceededException) String() string {
  5115  	return awsutil.Prettify(s)
  5116  }
  5117  
  5118  // GoString returns the string representation.
  5119  //
  5120  // API parameter values that are decorated as "sensitive" in the API will not
  5121  // be included in the string output. The member name will be present, but the
  5122  // value will be replaced with "sensitive".
  5123  func (s ServiceQuotaExceededException) GoString() string {
  5124  	return s.String()
  5125  }
  5126  
  5127  func newErrorServiceQuotaExceededException(v protocol.ResponseMetadata) error {
  5128  	return &ServiceQuotaExceededException{
  5129  		RespMetadata: v,
  5130  	}
  5131  }
  5132  
  5133  // Code returns the exception type name.
  5134  func (s *ServiceQuotaExceededException) Code() string {
  5135  	return "ServiceQuotaExceededException"
  5136  }
  5137  
  5138  // Message returns the exception's message.
  5139  func (s *ServiceQuotaExceededException) Message() string {
  5140  	if s.Message_ != nil {
  5141  		return *s.Message_
  5142  	}
  5143  	return ""
  5144  }
  5145  
  5146  // OrigErr always returns nil, satisfies awserr.Error interface.
  5147  func (s *ServiceQuotaExceededException) OrigErr() error {
  5148  	return nil
  5149  }
  5150  
  5151  func (s *ServiceQuotaExceededException) Error() string {
  5152  	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
  5153  }
  5154  
  5155  // Status code returns the HTTP status code for the request's response error.
  5156  func (s *ServiceQuotaExceededException) StatusCode() int {
  5157  	return s.RespMetadata.StatusCode
  5158  }
  5159  
  5160  // RequestID returns the service's response RequestID for request.
  5161  func (s *ServiceQuotaExceededException) RequestID() string {
  5162  	return s.RespMetadata.RequestID
  5163  }
  5164  
  5165  // 429 response - ThrottlingException.
  5166  type ThrottlingException struct {
  5167  	_            struct{}                  `type:"structure"`
  5168  	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
  5169  
  5170  	Message_ *string `locationName:"message" type:"string"`
  5171  }
  5172  
  5173  // String returns the string representation.
  5174  //
  5175  // API parameter values that are decorated as "sensitive" in the API will not
  5176  // be included in the string output. The member name will be present, but the
  5177  // value will be replaced with "sensitive".
  5178  func (s ThrottlingException) String() string {
  5179  	return awsutil.Prettify(s)
  5180  }
  5181  
  5182  // GoString returns the string representation.
  5183  //
  5184  // API parameter values that are decorated as "sensitive" in the API will not
  5185  // be included in the string output. The member name will be present, but the
  5186  // value will be replaced with "sensitive".
  5187  func (s ThrottlingException) GoString() string {
  5188  	return s.String()
  5189  }
  5190  
  5191  func newErrorThrottlingException(v protocol.ResponseMetadata) error {
  5192  	return &ThrottlingException{
  5193  		RespMetadata: v,
  5194  	}
  5195  }
  5196  
  5197  // Code returns the exception type name.
  5198  func (s *ThrottlingException) Code() string {
  5199  	return "ThrottlingException"
  5200  }
  5201  
  5202  // Message returns the exception's message.
  5203  func (s *ThrottlingException) Message() string {
  5204  	if s.Message_ != nil {
  5205  		return *s.Message_
  5206  	}
  5207  	return ""
  5208  }
  5209  
  5210  // OrigErr always returns nil, satisfies awserr.Error interface.
  5211  func (s *ThrottlingException) OrigErr() error {
  5212  	return nil
  5213  }
  5214  
  5215  func (s *ThrottlingException) Error() string {
  5216  	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
  5217  }
  5218  
  5219  // Status code returns the HTTP status code for the request's response error.
  5220  func (s *ThrottlingException) StatusCode() int {
  5221  	return s.RespMetadata.StatusCode
  5222  }
  5223  
  5224  // RequestID returns the service's response RequestID for request.
  5225  func (s *ThrottlingException) RequestID() string {
  5226  	return s.RespMetadata.RequestID
  5227  }
  5228  
  5229  // Updates an existing control panel.
  5230  type UpdateControlPanelInput struct {
  5231  	_ struct{} `type:"structure"`
  5232  
  5233  	// The Amazon Resource Name (ARN) of the control panel.
  5234  	//
  5235  	// ControlPanelArn is a required field
  5236  	ControlPanelArn *string `type:"string" required:"true"`
  5237  
  5238  	// The name of the control panel.
  5239  	//
  5240  	// ControlPanelName is a required field
  5241  	ControlPanelName *string `min:"1" type:"string" required:"true"`
  5242  }
  5243  
  5244  // String returns the string representation.
  5245  //
  5246  // API parameter values that are decorated as "sensitive" in the API will not
  5247  // be included in the string output. The member name will be present, but the
  5248  // value will be replaced with "sensitive".
  5249  func (s UpdateControlPanelInput) String() string {
  5250  	return awsutil.Prettify(s)
  5251  }
  5252  
  5253  // GoString returns the string representation.
  5254  //
  5255  // API parameter values that are decorated as "sensitive" in the API will not
  5256  // be included in the string output. The member name will be present, but the
  5257  // value will be replaced with "sensitive".
  5258  func (s UpdateControlPanelInput) GoString() string {
  5259  	return s.String()
  5260  }
  5261  
  5262  // Validate inspects the fields of the type to determine if they are valid.
  5263  func (s *UpdateControlPanelInput) Validate() error {
  5264  	invalidParams := request.ErrInvalidParams{Context: "UpdateControlPanelInput"}
  5265  	if s.ControlPanelArn == nil {
  5266  		invalidParams.Add(request.NewErrParamRequired("ControlPanelArn"))
  5267  	}
  5268  	if s.ControlPanelName == nil {
  5269  		invalidParams.Add(request.NewErrParamRequired("ControlPanelName"))
  5270  	}
  5271  	if s.ControlPanelName != nil && len(*s.ControlPanelName) < 1 {
  5272  		invalidParams.Add(request.NewErrParamMinLen("ControlPanelName", 1))
  5273  	}
  5274  
  5275  	if invalidParams.Len() > 0 {
  5276  		return invalidParams
  5277  	}
  5278  	return nil
  5279  }
  5280  
  5281  // SetControlPanelArn sets the ControlPanelArn field's value.
  5282  func (s *UpdateControlPanelInput) SetControlPanelArn(v string) *UpdateControlPanelInput {
  5283  	s.ControlPanelArn = &v
  5284  	return s
  5285  }
  5286  
  5287  // SetControlPanelName sets the ControlPanelName field's value.
  5288  func (s *UpdateControlPanelInput) SetControlPanelName(v string) *UpdateControlPanelInput {
  5289  	s.ControlPanelName = &v
  5290  	return s
  5291  }
  5292  
  5293  // The result of a successful UpdateControlPanel request.
  5294  type UpdateControlPanelOutput struct {
  5295  	_ struct{} `type:"structure"`
  5296  
  5297  	// The control panel to update.
  5298  	ControlPanel *ControlPanel `type:"structure"`
  5299  }
  5300  
  5301  // String returns the string representation.
  5302  //
  5303  // API parameter values that are decorated as "sensitive" in the API will not
  5304  // be included in the string output. The member name will be present, but the
  5305  // value will be replaced with "sensitive".
  5306  func (s UpdateControlPanelOutput) String() string {
  5307  	return awsutil.Prettify(s)
  5308  }
  5309  
  5310  // GoString returns the string representation.
  5311  //
  5312  // API parameter values that are decorated as "sensitive" in the API will not
  5313  // be included in the string output. The member name will be present, but the
  5314  // value will be replaced with "sensitive".
  5315  func (s UpdateControlPanelOutput) GoString() string {
  5316  	return s.String()
  5317  }
  5318  
  5319  // SetControlPanel sets the ControlPanel field's value.
  5320  func (s *UpdateControlPanelOutput) SetControlPanel(v *ControlPanel) *UpdateControlPanelOutput {
  5321  	s.ControlPanel = v
  5322  	return s
  5323  }
  5324  
  5325  // A request to update a routing control.
  5326  type UpdateRoutingControlInput struct {
  5327  	_ struct{} `type:"structure"`
  5328  
  5329  	// The Amazon Resource Name (ARN) of the routing control.
  5330  	//
  5331  	// RoutingControlArn is a required field
  5332  	RoutingControlArn *string `type:"string" required:"true"`
  5333  
  5334  	// The name of the routing control.
  5335  	//
  5336  	// RoutingControlName is a required field
  5337  	RoutingControlName *string `min:"1" type:"string" required:"true"`
  5338  }
  5339  
  5340  // String returns the string representation.
  5341  //
  5342  // API parameter values that are decorated as "sensitive" in the API will not
  5343  // be included in the string output. The member name will be present, but the
  5344  // value will be replaced with "sensitive".
  5345  func (s UpdateRoutingControlInput) String() string {
  5346  	return awsutil.Prettify(s)
  5347  }
  5348  
  5349  // GoString returns the string representation.
  5350  //
  5351  // API parameter values that are decorated as "sensitive" in the API will not
  5352  // be included in the string output. The member name will be present, but the
  5353  // value will be replaced with "sensitive".
  5354  func (s UpdateRoutingControlInput) GoString() string {
  5355  	return s.String()
  5356  }
  5357  
  5358  // Validate inspects the fields of the type to determine if they are valid.
  5359  func (s *UpdateRoutingControlInput) Validate() error {
  5360  	invalidParams := request.ErrInvalidParams{Context: "UpdateRoutingControlInput"}
  5361  	if s.RoutingControlArn == nil {
  5362  		invalidParams.Add(request.NewErrParamRequired("RoutingControlArn"))
  5363  	}
  5364  	if s.RoutingControlName == nil {
  5365  		invalidParams.Add(request.NewErrParamRequired("RoutingControlName"))
  5366  	}
  5367  	if s.RoutingControlName != nil && len(*s.RoutingControlName) < 1 {
  5368  		invalidParams.Add(request.NewErrParamMinLen("RoutingControlName", 1))
  5369  	}
  5370  
  5371  	if invalidParams.Len() > 0 {
  5372  		return invalidParams
  5373  	}
  5374  	return nil
  5375  }
  5376  
  5377  // SetRoutingControlArn sets the RoutingControlArn field's value.
  5378  func (s *UpdateRoutingControlInput) SetRoutingControlArn(v string) *UpdateRoutingControlInput {
  5379  	s.RoutingControlArn = &v
  5380  	return s
  5381  }
  5382  
  5383  // SetRoutingControlName sets the RoutingControlName field's value.
  5384  func (s *UpdateRoutingControlInput) SetRoutingControlName(v string) *UpdateRoutingControlInput {
  5385  	s.RoutingControlName = &v
  5386  	return s
  5387  }
  5388  
  5389  // The result of a successful UpdateRoutingControl request.
  5390  type UpdateRoutingControlOutput struct {
  5391  	_ struct{} `type:"structure"`
  5392  
  5393  	// The routing control that was updated.
  5394  	RoutingControl *RoutingControl `type:"structure"`
  5395  }
  5396  
  5397  // String returns the string representation.
  5398  //
  5399  // API parameter values that are decorated as "sensitive" in the API will not
  5400  // be included in the string output. The member name will be present, but the
  5401  // value will be replaced with "sensitive".
  5402  func (s UpdateRoutingControlOutput) String() string {
  5403  	return awsutil.Prettify(s)
  5404  }
  5405  
  5406  // GoString returns the string representation.
  5407  //
  5408  // API parameter values that are decorated as "sensitive" in the API will not
  5409  // be included in the string output. The member name will be present, but the
  5410  // value will be replaced with "sensitive".
  5411  func (s UpdateRoutingControlOutput) GoString() string {
  5412  	return s.String()
  5413  }
  5414  
  5415  // SetRoutingControl sets the RoutingControl field's value.
  5416  func (s *UpdateRoutingControlOutput) SetRoutingControl(v *RoutingControl) *UpdateRoutingControlOutput {
  5417  	s.RoutingControl = v
  5418  	return s
  5419  }
  5420  
  5421  // Request to update a safety rule. A safety rule can be an assertion rule or
  5422  // a gating rule.
  5423  type UpdateSafetyRuleInput struct {
  5424  	_ struct{} `type:"structure"`
  5425  
  5426  	// An update to an assertion rule. You can update the name or the evaluation
  5427  	// period (wait period). If you don't specify one of the items to update, the
  5428  	// item is unchanged.
  5429  	AssertionRuleUpdate *AssertionRuleUpdate `type:"structure"`
  5430  
  5431  	// Update to a gating rule. You can update the name or the evaluation period
  5432  	// (wait period). If you don't specify one of the items to update, the item
  5433  	// is unchanged.
  5434  	GatingRuleUpdate *GatingRuleUpdate `type:"structure"`
  5435  }
  5436  
  5437  // String returns the string representation.
  5438  //
  5439  // API parameter values that are decorated as "sensitive" in the API will not
  5440  // be included in the string output. The member name will be present, but the
  5441  // value will be replaced with "sensitive".
  5442  func (s UpdateSafetyRuleInput) String() string {
  5443  	return awsutil.Prettify(s)
  5444  }
  5445  
  5446  // GoString returns the string representation.
  5447  //
  5448  // API parameter values that are decorated as "sensitive" in the API will not
  5449  // be included in the string output. The member name will be present, but the
  5450  // value will be replaced with "sensitive".
  5451  func (s UpdateSafetyRuleInput) GoString() string {
  5452  	return s.String()
  5453  }
  5454  
  5455  // Validate inspects the fields of the type to determine if they are valid.
  5456  func (s *UpdateSafetyRuleInput) Validate() error {
  5457  	invalidParams := request.ErrInvalidParams{Context: "UpdateSafetyRuleInput"}
  5458  	if s.AssertionRuleUpdate != nil {
  5459  		if err := s.AssertionRuleUpdate.Validate(); err != nil {
  5460  			invalidParams.AddNested("AssertionRuleUpdate", err.(request.ErrInvalidParams))
  5461  		}
  5462  	}
  5463  	if s.GatingRuleUpdate != nil {
  5464  		if err := s.GatingRuleUpdate.Validate(); err != nil {
  5465  			invalidParams.AddNested("GatingRuleUpdate", err.(request.ErrInvalidParams))
  5466  		}
  5467  	}
  5468  
  5469  	if invalidParams.Len() > 0 {
  5470  		return invalidParams
  5471  	}
  5472  	return nil
  5473  }
  5474  
  5475  // SetAssertionRuleUpdate sets the AssertionRuleUpdate field's value.
  5476  func (s *UpdateSafetyRuleInput) SetAssertionRuleUpdate(v *AssertionRuleUpdate) *UpdateSafetyRuleInput {
  5477  	s.AssertionRuleUpdate = v
  5478  	return s
  5479  }
  5480  
  5481  // SetGatingRuleUpdate sets the GatingRuleUpdate field's value.
  5482  func (s *UpdateSafetyRuleInput) SetGatingRuleUpdate(v *GatingRuleUpdate) *UpdateSafetyRuleInput {
  5483  	s.GatingRuleUpdate = v
  5484  	return s
  5485  }
  5486  
  5487  // The result of a successful UpdateSafetyRule request.
  5488  type UpdateSafetyRuleOutput struct {
  5489  	_ struct{} `type:"structure"`
  5490  
  5491  	// An assertion rule enforces that, when a routing control state is changed,
  5492  	// the criteria set by the rule configuration is met. Otherwise, the change
  5493  	// to the routing control is not accepted.
  5494  	AssertionRule *AssertionRule `type:"structure"`
  5495  
  5496  	// A gating rule verifies that a set of gating controls evaluates as true, based
  5497  	// on a rule configuration that you specify. If the gating rule evaluates to
  5498  	// true, Amazon Route 53 Application Recovery Controller allows a set of routing
  5499  	// control state changes to run and complete against the set of target controls.
  5500  	GatingRule *GatingRule `type:"structure"`
  5501  }
  5502  
  5503  // String returns the string representation.
  5504  //
  5505  // API parameter values that are decorated as "sensitive" in the API will not
  5506  // be included in the string output. The member name will be present, but the
  5507  // value will be replaced with "sensitive".
  5508  func (s UpdateSafetyRuleOutput) String() string {
  5509  	return awsutil.Prettify(s)
  5510  }
  5511  
  5512  // GoString returns the string representation.
  5513  //
  5514  // API parameter values that are decorated as "sensitive" in the API will not
  5515  // be included in the string output. The member name will be present, but the
  5516  // value will be replaced with "sensitive".
  5517  func (s UpdateSafetyRuleOutput) GoString() string {
  5518  	return s.String()
  5519  }
  5520  
  5521  // SetAssertionRule sets the AssertionRule field's value.
  5522  func (s *UpdateSafetyRuleOutput) SetAssertionRule(v *AssertionRule) *UpdateSafetyRuleOutput {
  5523  	s.AssertionRule = v
  5524  	return s
  5525  }
  5526  
  5527  // SetGatingRule sets the GatingRule field's value.
  5528  func (s *UpdateSafetyRuleOutput) SetGatingRule(v *GatingRule) *UpdateSafetyRuleOutput {
  5529  	s.GatingRule = v
  5530  	return s
  5531  }
  5532  
  5533  // 400 response - Multiple causes. For example, you might have a malformed query
  5534  // string and input parameter might be out of range, or you used parameters
  5535  // together incorrectly.
  5536  type ValidationException struct {
  5537  	_            struct{}                  `type:"structure"`
  5538  	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
  5539  
  5540  	Message_ *string `locationName:"message" type:"string"`
  5541  }
  5542  
  5543  // String returns the string representation.
  5544  //
  5545  // API parameter values that are decorated as "sensitive" in the API will not
  5546  // be included in the string output. The member name will be present, but the
  5547  // value will be replaced with "sensitive".
  5548  func (s ValidationException) String() string {
  5549  	return awsutil.Prettify(s)
  5550  }
  5551  
  5552  // GoString returns the string representation.
  5553  //
  5554  // API parameter values that are decorated as "sensitive" in the API will not
  5555  // be included in the string output. The member name will be present, but the
  5556  // value will be replaced with "sensitive".
  5557  func (s ValidationException) GoString() string {
  5558  	return s.String()
  5559  }
  5560  
  5561  func newErrorValidationException(v protocol.ResponseMetadata) error {
  5562  	return &ValidationException{
  5563  		RespMetadata: v,
  5564  	}
  5565  }
  5566  
  5567  // Code returns the exception type name.
  5568  func (s *ValidationException) Code() string {
  5569  	return "ValidationException"
  5570  }
  5571  
  5572  // Message returns the exception's message.
  5573  func (s *ValidationException) Message() string {
  5574  	if s.Message_ != nil {
  5575  		return *s.Message_
  5576  	}
  5577  	return ""
  5578  }
  5579  
  5580  // OrigErr always returns nil, satisfies awserr.Error interface.
  5581  func (s *ValidationException) OrigErr() error {
  5582  	return nil
  5583  }
  5584  
  5585  func (s *ValidationException) Error() string {
  5586  	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
  5587  }
  5588  
  5589  // Status code returns the HTTP status code for the request's response error.
  5590  func (s *ValidationException) StatusCode() int {
  5591  	return s.RespMetadata.StatusCode
  5592  }
  5593  
  5594  // RequestID returns the service's response RequestID for request.
  5595  func (s *ValidationException) RequestID() string {
  5596  	return s.RespMetadata.RequestID
  5597  }
  5598  
  5599  // An enumerated type that determines how the evaluated rules are processed.
  5600  // RuleType can be one of the following:
  5601  //
  5602  // ATLEAST - At least N routing controls must be set. You specify N as the Threshold
  5603  // in the rule configuration.
  5604  //
  5605  // AND - All routing controls must be set. This is a shortcut for "At least
  5606  // N," where N is the total number of controls in the rule.
  5607  //
  5608  // OR - Any control must be set. This is a shortcut for "At least N," where
  5609  // N is 1.
  5610  const (
  5611  	// RuleTypeAtleast is a RuleType enum value
  5612  	RuleTypeAtleast = "ATLEAST"
  5613  
  5614  	// RuleTypeAnd is a RuleType enum value
  5615  	RuleTypeAnd = "AND"
  5616  
  5617  	// RuleTypeOr is a RuleType enum value
  5618  	RuleTypeOr = "OR"
  5619  )
  5620  
  5621  // RuleType_Values returns all elements of the RuleType enum
  5622  func RuleType_Values() []string {
  5623  	return []string{
  5624  		RuleTypeAtleast,
  5625  		RuleTypeAnd,
  5626  		RuleTypeOr,
  5627  	}
  5628  }
  5629  
  5630  // The deployment status of a resource. Status can be one of the following:
  5631  //
  5632  // PENDING: Amazon Route 53 Application Recovery Controller is creating the
  5633  // resource.
  5634  //
  5635  // DEPLOYED: The resource is deployed and ready to use.
  5636  //
  5637  // PENDING_DELETION: Amazon Route 53 Application Recovery Controller is deleting
  5638  // the resource.
  5639  const (
  5640  	// StatusPending is a Status enum value
  5641  	StatusPending = "PENDING"
  5642  
  5643  	// StatusDeployed is a Status enum value
  5644  	StatusDeployed = "DEPLOYED"
  5645  
  5646  	// StatusPendingDeletion is a Status enum value
  5647  	StatusPendingDeletion = "PENDING_DELETION"
  5648  )
  5649  
  5650  // Status_Values returns all elements of the Status enum
  5651  func Status_Values() []string {
  5652  	return []string{
  5653  		StatusPending,
  5654  		StatusDeployed,
  5655  		StatusPendingDeletion,
  5656  	}
  5657  }