From 2d352b9afc62f4ea0ab19e1f3208c3771c38cc4f Mon Sep 17 00:00:00 2001 From: Lucian Date: Thu, 8 Jun 2023 17:29:01 +0300 Subject: [PATCH 01/23] feat(resource): add support for AWS GameLift builds, fleets, queues, mm configs and mm rule sets --- resources/gamelift-builds.go | 52 ++++++++++++++++++++++++++++++++ resources/gamelift-fleets.go | 53 +++++++++++++++++++++++++++++++++ resources/gamelift-mm-config.go | 53 +++++++++++++++++++++++++++++++++ resources/gamelift-mm-rule.go | 53 +++++++++++++++++++++++++++++++++ resources/gamelift-queues.go | 53 +++++++++++++++++++++++++++++++++ 5 files changed, 264 insertions(+) create mode 100644 resources/gamelift-builds.go create mode 100644 resources/gamelift-fleets.go create mode 100644 resources/gamelift-mm-config.go create mode 100644 resources/gamelift-mm-rule.go create mode 100644 resources/gamelift-queues.go diff --git a/resources/gamelift-builds.go b/resources/gamelift-builds.go new file mode 100644 index 00000000..42c8e874 --- /dev/null +++ b/resources/gamelift-builds.go @@ -0,0 +1,52 @@ +package resources + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/gamelift" +) + +type GameLiftBuild struct { + svc *gamelift.GameLift + BuildId string +} + +func init() { + register("GameLiftBuild", ListGameLiftBuilds) +} + +func ListGameLiftBuilds(sess *session.Session) ([]Resource, error) { + svc := gamelift.New(sess) + + resp, err := svc.ListBuilds(&gamelift.ListBuildsInput{}) + if err != nil { + return nil, err + } + + builds := make([]Resource, 0) + for _, build := range resp.Builds { + builds = append(builds, &GameLiftBuild{ + svc: svc, + BuildId: aws.StringValue(build.BuildId), + }) + } + + return builds, nil +} + +func (build *GameLiftBuild) Remove() error { + params := &gamelift.DeleteBuildInput{ + BuildId: aws.String(build.BuildId), + } + + _, err := build.svc.DeleteBuild(params) + if err != nil { + return err + } + + return nil +} + +func (i *GameLiftBuild) String() string { + return i.BuildId +} diff --git a/resources/gamelift-fleets.go b/resources/gamelift-fleets.go new file mode 100644 index 00000000..50d8e909 --- /dev/null +++ b/resources/gamelift-fleets.go @@ -0,0 +1,53 @@ +package resources + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/gamelift" +) + +type GameLiftFleet struct { + svc *gamelift.GameLift + FleetId string +} + +func init() { + register("GameLiftFleet", ListGameLiftFleets) +} + +func ListGameLiftFleets(sess *session.Session) ([]Resource, error) { + svc := gamelift.New(sess) + + resp, err := svc.ListFleets(&gamelift.ListFleetsInput{}) + if err != nil { + return nil, err + } + + fleets := make([]Resource, 0) + for _, fleetId := range resp.FleetIds { + fleet := &GameLiftFleet{ + svc: svc, + FleetId: *fleetId, // Dereference the fleetId pointer + } + fleets = append(fleets, fleet) + } + + return fleets, nil +} + +func (fleet *GameLiftFleet) Remove() error { + params := &gamelift.DeleteFleetInput{ + FleetId: aws.String(fleet.FleetId), + } + + _, err := fleet.svc.DeleteFleet(params) + if err != nil { + return err + } + + return nil +} + +func (i *GameLiftFleet) String() string { + return i.FleetId +} diff --git a/resources/gamelift-mm-config.go b/resources/gamelift-mm-config.go new file mode 100644 index 00000000..9638e12b --- /dev/null +++ b/resources/gamelift-mm-config.go @@ -0,0 +1,53 @@ +package resources + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/gamelift" +) + +type GameLiftMatchmakingConfiguration struct { + svc *gamelift.GameLift + Name string +} + +func init() { + register("GameLiftMatchmakingConfiguration", ListMatchmakingConfigurations) +} + +func ListMatchmakingConfigurations(sess *session.Session) ([]Resource, error) { + svc := gamelift.New(sess) + + resp, err := svc.DescribeMatchmakingConfigurations(&gamelift.DescribeMatchmakingConfigurationsInput{}) + if err != nil { + return nil, err + } + + configs := make([]Resource, 0) + for _, config := range resp.Configurations { + q := &GameLiftMatchmakingConfiguration{ + svc: svc, + Name: *config.Name, + } + configs = append(configs, q) + } + + return configs, nil +} + +func (config *GameLiftMatchmakingConfiguration) Remove() error { + params := &gamelift.DeleteMatchmakingConfigurationInput{ + Name: aws.String(config.Name), + } + + _, err := config.svc.DeleteMatchmakingConfiguration(params) + if err != nil { + return err + } + + return nil +} + +func (i *GameLiftMatchmakingConfiguration) String() string { + return i.Name +} diff --git a/resources/gamelift-mm-rule.go b/resources/gamelift-mm-rule.go new file mode 100644 index 00000000..2535821f --- /dev/null +++ b/resources/gamelift-mm-rule.go @@ -0,0 +1,53 @@ +package resources + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/gamelift" +) + +type GameLiftMatchmakingRuleSet struct { + svc *gamelift.GameLift + Name string +} + +func init() { + register("GameLiftMatchmakingRuleSet", ListMatchmakingRuleSets) +} + +func ListMatchmakingRuleSets(sess *session.Session) ([]Resource, error) { + svc := gamelift.New(sess) + + resp, err := svc.DescribeMatchmakingRuleSets(&gamelift.DescribeMatchmakingRuleSetsInput{}) + if err != nil { + return nil, err + } + + rules := make([]Resource, 0) + for _, ruleSet := range resp.RuleSets { + q := &GameLiftMatchmakingRuleSet{ + svc: svc, + Name: *ruleSet.RuleSetName, + } + rules = append(rules, q) + } + + return rules, nil +} + +func (ruleSet *GameLiftMatchmakingRuleSet) Remove() error { + params := &gamelift.DeleteMatchmakingRuleSetInput{ + Name: aws.String(ruleSet.Name), + } + + _, err := ruleSet.svc.DeleteMatchmakingRuleSet(params) + if err != nil { + return err + } + + return nil +} + +func (ruleSet *GameLiftMatchmakingRuleSet) String() string { + return ruleSet.Name +} diff --git a/resources/gamelift-queues.go b/resources/gamelift-queues.go new file mode 100644 index 00000000..b9d2c270 --- /dev/null +++ b/resources/gamelift-queues.go @@ -0,0 +1,53 @@ +package resources + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/gamelift" +) + +type GameLiftQueue struct { + svc *gamelift.GameLift + Name string +} + +func init() { + register("GameLiftQueue", ListGameLiftQueues) +} + +func ListGameLiftQueues(sess *session.Session) ([]Resource, error) { + svc := gamelift.New(sess) + + resp, err := svc.DescribeGameSessionQueues(&gamelift.DescribeGameSessionQueuesInput{}) + if err != nil { + return nil, err + } + + queues := make([]Resource, 0) + for _, queue := range resp.GameSessionQueues { + q := &GameLiftQueue{ + svc: svc, + Name: *queue.Name, + } + queues = append(queues, q) + } + + return queues, nil +} + +func (queue *GameLiftQueue) Remove() error { + params := &gamelift.DeleteGameSessionQueueInput{ + Name: aws.String(queue.Name), + } + + _, err := queue.svc.DeleteGameSessionQueue(params) + if err != nil { + return err + } + + return nil +} + +func (i *GameLiftQueue) String() string { + return i.Name +} From 11d0bec86c584a0dd42eba51db5d09f85b92325c Mon Sep 17 00:00:00 2001 From: Lucian Date: Thu, 8 Jun 2023 19:22:00 +0300 Subject: [PATCH 02/23] feat(resource): add Pinpoint Apps and Phone Numbers support --- resources/pinpoint-app.go | 52 ++++++++++++++++++++++++++++++ resources/pinpoint-phone-number.go | 52 ++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+) create mode 100644 resources/pinpoint-app.go create mode 100644 resources/pinpoint-phone-number.go diff --git a/resources/pinpoint-app.go b/resources/pinpoint-app.go new file mode 100644 index 00000000..ec2c5cbb --- /dev/null +++ b/resources/pinpoint-app.go @@ -0,0 +1,52 @@ +package resources + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/pinpoint" +) + +type PinpointApp struct { + svc *pinpoint.Pinpoint + app string +} + +func init() { + register("PinpointApp", ListPinpointApps) +} + +func ListPinpointApps(sess *session.Session) ([]Resource, error) { + svc := pinpoint.New(sess) + + resp, err := svc.GetApps(&pinpoint.GetAppsInput{}) + if err != nil { + return nil, err + } + + apps := make([]Resource, 0) + for _, appResponse := range resp.ApplicationsResponse.Item { + apps = append(apps, &PinpointApp{ + svc: svc, + app: aws.StringValue(appResponse.Id), + }) + } + + return apps, nil +} + +func (p *PinpointApp) Remove() error { + params := &pinpoint.DeleteAppInput{ + ApplicationId: aws.String(p.app), + } + + _, err := p.svc.DeleteApp(params) + if err != nil { + return err + } + + return nil +} + +func (p *PinpointApp) String() string { + return p.app +} diff --git a/resources/pinpoint-phone-number.go b/resources/pinpoint-phone-number.go new file mode 100644 index 00000000..4db212fa --- /dev/null +++ b/resources/pinpoint-phone-number.go @@ -0,0 +1,52 @@ +package resources + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/pinpointsmsvoicev2" +) + +type PinpointPhoneNumber struct { + svc *pinpointsmsvoicev2.PinpointSMSVoiceV2 + phone string +} + +func init() { + register("PinpointPhoneNumber", ListPinpointPhoneNumbers) +} + +func ListPinpointPhoneNumbers(sess *session.Session) ([]Resource, error) { + svc := pinpointsmsvoicev2.New(sess) + + resp, err := svc.DescribePhoneNumbers(&pinpointsmsvoicev2.DescribePhoneNumbersInput{}) + if err != nil { + return nil, err + } + + numbers := make([]Resource, 0) + for _, number := range resp.PhoneNumbers { + numbers = append(numbers, &PinpointPhoneNumber{ + svc: svc, + phone: aws.StringValue(number.PhoneNumberId), + }) + } + + return numbers, nil +} + +func (p *PinpointPhoneNumber) Remove() error { + params := &pinpointsmsvoicev2.ReleasePhoneNumberInput{ + PhoneNumberId: aws.String(p.phone), + } + + _, err := p.svc.ReleasePhoneNumber(params) + if err != nil { + return err + } + + return nil +} + +func (p *PinpointPhoneNumber) String() string { + return p.phone +} From 85abfee12a9d17f025d27226a72ebbbf4a286e36 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:07:14 -0500 Subject: [PATCH 03/23] refactor(gamelift-build): convert to libnuke resource format --- resources/gamelift-build.go | 67 ++++++++++++++++++++++++++++++++++++ resources/gamelift-builds.go | 52 ---------------------------- 2 files changed, 67 insertions(+), 52 deletions(-) create mode 100644 resources/gamelift-build.go delete mode 100644 resources/gamelift-builds.go diff --git a/resources/gamelift-build.go b/resources/gamelift-build.go new file mode 100644 index 00000000..1953a364 --- /dev/null +++ b/resources/gamelift-build.go @@ -0,0 +1,67 @@ +package resources + +import ( + "context" + + "github.com/aws/aws-sdk-go/service/gamelift" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +const GameLiftBuildResource = "GameLiftBuild" + +func init() { + registry.Register(®istry.Registration{ + Name: GameLiftBuildResource, + Scope: nuke.Account, + Lister: &GameLiftBuildLister{}, + }) +} + +type GameLiftBuildLister struct{} + +func (l *GameLiftBuildLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + svc := gamelift.New(opts.Session) + + resp, err := svc.ListBuilds(&gamelift.ListBuildsInput{}) + if err != nil { + return nil, err + } + + builds := make([]resource.Resource, 0) + for _, build := range resp.Builds { + builds = append(builds, &GameLiftBuild{ + svc: svc, + BuildID: build.BuildId, + }) + } + + return builds, nil +} + +type GameLiftBuild struct { + svc *gamelift.GameLift + BuildID *string +} + +func (r *GameLiftBuild) Remove(_ context.Context) error { + params := &gamelift.DeleteBuildInput{ + BuildId: r.BuildID, + } + + _, err := r.svc.DeleteBuild(params) + if err != nil { + return err + } + + return nil +} + +func (r *GameLiftBuild) String() string { + return *r.BuildID +} diff --git a/resources/gamelift-builds.go b/resources/gamelift-builds.go deleted file mode 100644 index 42c8e874..00000000 --- a/resources/gamelift-builds.go +++ /dev/null @@ -1,52 +0,0 @@ -package resources - -import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/gamelift" -) - -type GameLiftBuild struct { - svc *gamelift.GameLift - BuildId string -} - -func init() { - register("GameLiftBuild", ListGameLiftBuilds) -} - -func ListGameLiftBuilds(sess *session.Session) ([]Resource, error) { - svc := gamelift.New(sess) - - resp, err := svc.ListBuilds(&gamelift.ListBuildsInput{}) - if err != nil { - return nil, err - } - - builds := make([]Resource, 0) - for _, build := range resp.Builds { - builds = append(builds, &GameLiftBuild{ - svc: svc, - BuildId: aws.StringValue(build.BuildId), - }) - } - - return builds, nil -} - -func (build *GameLiftBuild) Remove() error { - params := &gamelift.DeleteBuildInput{ - BuildId: aws.String(build.BuildId), - } - - _, err := build.svc.DeleteBuild(params) - if err != nil { - return err - } - - return nil -} - -func (i *GameLiftBuild) String() string { - return i.BuildId -} From 6784e0a744c8a82ead65f751389b35aa0f3f9769 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:08:18 -0500 Subject: [PATCH 04/23] refactor(gamelift-fleet): convert to libnuke resource format --- resources/gamelift-fleet.go | 69 ++++++++++++++++++++++++++++++++++++ resources/gamelift-fleets.go | 53 --------------------------- 2 files changed, 69 insertions(+), 53 deletions(-) create mode 100644 resources/gamelift-fleet.go delete mode 100644 resources/gamelift-fleets.go diff --git a/resources/gamelift-fleet.go b/resources/gamelift-fleet.go new file mode 100644 index 00000000..1e161e7d --- /dev/null +++ b/resources/gamelift-fleet.go @@ -0,0 +1,69 @@ +package resources + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/gamelift" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +const GameLiftFleetResource = "GameLiftFleet" + +func init() { + registry.Register(®istry.Registration{ + Name: GameLiftFleetResource, + Scope: nuke.Account, + Lister: &GameLiftFleetLister{}, + }) +} + +type GameLiftFleetLister struct{} + +func (l *GameLiftFleetLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + svc := gamelift.New(opts.Session) + + resp, err := svc.ListFleets(&gamelift.ListFleetsInput{}) + if err != nil { + return nil, err + } + + fleets := make([]resource.Resource, 0) + for _, fleetId := range resp.FleetIds { + fleet := &GameLiftFleet{ + svc: svc, + FleetId: *fleetId, // Dereference the fleetId pointer + } + fleets = append(fleets, fleet) + } + + return fleets, nil +} + +type GameLiftFleet struct { + svc *gamelift.GameLift + FleetId string +} + +func (r *GameLiftFleet) Remove(_ context.Context) error { + params := &gamelift.DeleteFleetInput{ + FleetId: aws.String(r.FleetId), + } + + _, err := r.svc.DeleteFleet(params) + if err != nil { + return err + } + + return nil +} + +func (r *GameLiftFleet) String() string { + return r.FleetId +} diff --git a/resources/gamelift-fleets.go b/resources/gamelift-fleets.go deleted file mode 100644 index 50d8e909..00000000 --- a/resources/gamelift-fleets.go +++ /dev/null @@ -1,53 +0,0 @@ -package resources - -import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/gamelift" -) - -type GameLiftFleet struct { - svc *gamelift.GameLift - FleetId string -} - -func init() { - register("GameLiftFleet", ListGameLiftFleets) -} - -func ListGameLiftFleets(sess *session.Session) ([]Resource, error) { - svc := gamelift.New(sess) - - resp, err := svc.ListFleets(&gamelift.ListFleetsInput{}) - if err != nil { - return nil, err - } - - fleets := make([]Resource, 0) - for _, fleetId := range resp.FleetIds { - fleet := &GameLiftFleet{ - svc: svc, - FleetId: *fleetId, // Dereference the fleetId pointer - } - fleets = append(fleets, fleet) - } - - return fleets, nil -} - -func (fleet *GameLiftFleet) Remove() error { - params := &gamelift.DeleteFleetInput{ - FleetId: aws.String(fleet.FleetId), - } - - _, err := fleet.svc.DeleteFleet(params) - if err != nil { - return err - } - - return nil -} - -func (i *GameLiftFleet) String() string { - return i.FleetId -} From 30461092ae4a926b4170b9390a06789df741052d Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:09:40 -0500 Subject: [PATCH 05/23] refactor(gamelift-mm-config): convert to libnuke resource format --- resources/gamelift-mm-config.go | 47 ++++++++++++++++++++++----------- 1 file changed, 31 insertions(+), 16 deletions(-) diff --git a/resources/gamelift-mm-config.go b/resources/gamelift-mm-config.go index 9638e12b..8d792dbb 100644 --- a/resources/gamelift-mm-config.go +++ b/resources/gamelift-mm-config.go @@ -1,33 +1,43 @@ package resources import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" + "context" + "github.com/aws/aws-sdk-go/service/gamelift" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) -type GameLiftMatchmakingConfiguration struct { - svc *gamelift.GameLift - Name string -} +const GameLiftMatchmakingConfigurationResource = "GameLiftMatchmakingConfiguration" func init() { - register("GameLiftMatchmakingConfiguration", ListMatchmakingConfigurations) + registry.Register(®istry.Registration{ + Name: GameLiftMatchmakingConfigurationResource, + Scope: nuke.Account, + Lister: &GameLiftMatchmakingConfigurationLister{}, + }) } -func ListMatchmakingConfigurations(sess *session.Session) ([]Resource, error) { - svc := gamelift.New(sess) +type GameLiftMatchmakingConfigurationLister struct{} + +func (l *GameLiftMatchmakingConfigurationLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + svc := gamelift.New(opts.Session) resp, err := svc.DescribeMatchmakingConfigurations(&gamelift.DescribeMatchmakingConfigurationsInput{}) if err != nil { return nil, err } - configs := make([]Resource, 0) + configs := make([]resource.Resource, 0) for _, config := range resp.Configurations { q := &GameLiftMatchmakingConfiguration{ svc: svc, - Name: *config.Name, + Name: config.Name, } configs = append(configs, q) } @@ -35,12 +45,17 @@ func ListMatchmakingConfigurations(sess *session.Session) ([]Resource, error) { return configs, nil } -func (config *GameLiftMatchmakingConfiguration) Remove() error { +type GameLiftMatchmakingConfiguration struct { + svc *gamelift.GameLift + Name *string +} + +func (r *GameLiftMatchmakingConfiguration) Remove(_ context.Context) error { params := &gamelift.DeleteMatchmakingConfigurationInput{ - Name: aws.String(config.Name), + Name: r.Name, } - _, err := config.svc.DeleteMatchmakingConfiguration(params) + _, err := r.svc.DeleteMatchmakingConfiguration(params) if err != nil { return err } @@ -48,6 +63,6 @@ func (config *GameLiftMatchmakingConfiguration) Remove() error { return nil } -func (i *GameLiftMatchmakingConfiguration) String() string { - return i.Name +func (r *GameLiftMatchmakingConfiguration) String() string { + return *r.Name } From 750d9405f13500f074865c6e5a797c56111c6d08 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:10:59 -0500 Subject: [PATCH 06/23] refactor(gamelift-mm-rule): convert to libnuke resource format --- resources/gamelift-mm-rule.go | 47 +++++++++++++++++++++++------------ 1 file changed, 31 insertions(+), 16 deletions(-) diff --git a/resources/gamelift-mm-rule.go b/resources/gamelift-mm-rule.go index 2535821f..42946cf8 100644 --- a/resources/gamelift-mm-rule.go +++ b/resources/gamelift-mm-rule.go @@ -1,33 +1,43 @@ package resources import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" + "context" + "github.com/aws/aws-sdk-go/service/gamelift" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) -type GameLiftMatchmakingRuleSet struct { - svc *gamelift.GameLift - Name string -} +const GameLiftMatchmakingRuleSetResource = "GameLiftMatchmakingRuleSet" func init() { - register("GameLiftMatchmakingRuleSet", ListMatchmakingRuleSets) + registry.Register(®istry.Registration{ + Name: GameLiftMatchmakingRuleSetResource, + Scope: nuke.Account, + Lister: &GameLiftMatchmakingRuleSetLister{}, + }) } -func ListMatchmakingRuleSets(sess *session.Session) ([]Resource, error) { - svc := gamelift.New(sess) +type GameLiftMatchmakingRuleSetLister struct{} + +func (l *GameLiftMatchmakingRuleSetLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + svc := gamelift.New(opts.Session) resp, err := svc.DescribeMatchmakingRuleSets(&gamelift.DescribeMatchmakingRuleSetsInput{}) if err != nil { return nil, err } - rules := make([]Resource, 0) + rules := make([]resource.Resource, 0) for _, ruleSet := range resp.RuleSets { q := &GameLiftMatchmakingRuleSet{ svc: svc, - Name: *ruleSet.RuleSetName, + Name: ruleSet.RuleSetName, } rules = append(rules, q) } @@ -35,12 +45,17 @@ func ListMatchmakingRuleSets(sess *session.Session) ([]Resource, error) { return rules, nil } -func (ruleSet *GameLiftMatchmakingRuleSet) Remove() error { +type GameLiftMatchmakingRuleSet struct { + svc *gamelift.GameLift + Name *string +} + +func (r *GameLiftMatchmakingRuleSet) Remove(_ context.Context) error { params := &gamelift.DeleteMatchmakingRuleSetInput{ - Name: aws.String(ruleSet.Name), + Name: r.Name, } - _, err := ruleSet.svc.DeleteMatchmakingRuleSet(params) + _, err := r.svc.DeleteMatchmakingRuleSet(params) if err != nil { return err } @@ -48,6 +63,6 @@ func (ruleSet *GameLiftMatchmakingRuleSet) Remove() error { return nil } -func (ruleSet *GameLiftMatchmakingRuleSet) String() string { - return ruleSet.Name +func (r *GameLiftMatchmakingRuleSet) String() string { + return *r.Name } From 6afe671db3287ad1c49baeac1c1b2b47d72c632d Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:12:18 -0500 Subject: [PATCH 07/23] refactor(gamelift-queue): convert to libnuke resource format --- resources/gamelift-queue.go | 68 ++++++++++++++++++++++++++++++++++++ resources/gamelift-queues.go | 53 ---------------------------- 2 files changed, 68 insertions(+), 53 deletions(-) create mode 100644 resources/gamelift-queue.go delete mode 100644 resources/gamelift-queues.go diff --git a/resources/gamelift-queue.go b/resources/gamelift-queue.go new file mode 100644 index 00000000..4e2a81c1 --- /dev/null +++ b/resources/gamelift-queue.go @@ -0,0 +1,68 @@ +package resources + +import ( + "context" + + "github.com/aws/aws-sdk-go/service/gamelift" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +const GameLiftQueueResource = "GameLiftQueue" + +func init() { + registry.Register(®istry.Registration{ + Name: GameLiftQueueResource, + Scope: nuke.Account, + Lister: &GameLiftQueueLister{}, + }) +} + +type GameLiftQueueLister struct{} + +func (l *GameLiftQueueLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + svc := gamelift.New(opts.Session) + + resp, err := svc.DescribeGameSessionQueues(&gamelift.DescribeGameSessionQueuesInput{}) + if err != nil { + return nil, err + } + + queues := make([]resource.Resource, 0) + for _, queue := range resp.GameSessionQueues { + q := &GameLiftQueue{ + svc: svc, + Name: queue.Name, + } + queues = append(queues, q) + } + + return queues, nil +} + +type GameLiftQueue struct { + svc *gamelift.GameLift + Name *string +} + +func (r *GameLiftQueue) Remove(_ context.Context) error { + params := &gamelift.DeleteGameSessionQueueInput{ + Name: r.Name, + } + + _, err := r.svc.DeleteGameSessionQueue(params) + if err != nil { + return err + } + + return nil +} + +func (r *GameLiftQueue) String() string { + return *r.Name +} diff --git a/resources/gamelift-queues.go b/resources/gamelift-queues.go deleted file mode 100644 index b9d2c270..00000000 --- a/resources/gamelift-queues.go +++ /dev/null @@ -1,53 +0,0 @@ -package resources - -import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/gamelift" -) - -type GameLiftQueue struct { - svc *gamelift.GameLift - Name string -} - -func init() { - register("GameLiftQueue", ListGameLiftQueues) -} - -func ListGameLiftQueues(sess *session.Session) ([]Resource, error) { - svc := gamelift.New(sess) - - resp, err := svc.DescribeGameSessionQueues(&gamelift.DescribeGameSessionQueuesInput{}) - if err != nil { - return nil, err - } - - queues := make([]Resource, 0) - for _, queue := range resp.GameSessionQueues { - q := &GameLiftQueue{ - svc: svc, - Name: *queue.Name, - } - queues = append(queues, q) - } - - return queues, nil -} - -func (queue *GameLiftQueue) Remove() error { - params := &gamelift.DeleteGameSessionQueueInput{ - Name: aws.String(queue.Name), - } - - _, err := queue.svc.DeleteGameSessionQueue(params) - if err != nil { - return err - } - - return nil -} - -func (i *GameLiftQueue) String() string { - return i.Name -} From 2b6ab4a99e701c21bc619d60e82fd0a5da22dc69 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:13:51 -0500 Subject: [PATCH 08/23] refactor(pinpoint-app): convert to libnuke resource format --- resources/pinpoint-app.go | 43 ++++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/resources/pinpoint-app.go b/resources/pinpoint-app.go index ec2c5cbb..127d1980 100644 --- a/resources/pinpoint-app.go +++ b/resources/pinpoint-app.go @@ -1,42 +1,57 @@ package resources import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" + "context" + "github.com/aws/aws-sdk-go/service/pinpoint" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) -type PinpointApp struct { - svc *pinpoint.Pinpoint - app string -} +const PinpointAppResource = "PinpointApp" func init() { - register("PinpointApp", ListPinpointApps) + registry.Register(®istry.Registration{ + Name: PinpointAppResource, + Scope: nuke.Account, + Lister: &PinpointAppLister{}, + }) } -func ListPinpointApps(sess *session.Session) ([]Resource, error) { - svc := pinpoint.New(sess) +type PinpointAppLister struct{} + +func (l *PinpointAppLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + svc := pinpoint.New(opts.Session) resp, err := svc.GetApps(&pinpoint.GetAppsInput{}) if err != nil { return nil, err } - apps := make([]Resource, 0) + apps := make([]resource.Resource, 0) for _, appResponse := range resp.ApplicationsResponse.Item { apps = append(apps, &PinpointApp{ svc: svc, - app: aws.StringValue(appResponse.Id), + ID: appResponse.Id, }) } return apps, nil } -func (p *PinpointApp) Remove() error { +type PinpointApp struct { + svc *pinpoint.Pinpoint + ID *string +} + +func (p *PinpointApp) Remove(_ context.Context) error { params := &pinpoint.DeleteAppInput{ - ApplicationId: aws.String(p.app), + ApplicationId: p.ID, } _, err := p.svc.DeleteApp(params) @@ -48,5 +63,5 @@ func (p *PinpointApp) Remove() error { } func (p *PinpointApp) String() string { - return p.app + return *p.ID } From fbc851661110b48b9584c8c1ed5df7c9e857ce00 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:15:26 -0500 Subject: [PATCH 09/23] refactor(pinpoint-phone-number): convert to libnuke resource format --- resources/pinpoint-phone-number.go | 45 ++++++++++++++++++++---------- 1 file changed, 30 insertions(+), 15 deletions(-) diff --git a/resources/pinpoint-phone-number.go b/resources/pinpoint-phone-number.go index 4db212fa..9a0f87f7 100644 --- a/resources/pinpoint-phone-number.go +++ b/resources/pinpoint-phone-number.go @@ -1,42 +1,57 @@ package resources import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" + "context" + "github.com/aws/aws-sdk-go/service/pinpointsmsvoicev2" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) -type PinpointPhoneNumber struct { - svc *pinpointsmsvoicev2.PinpointSMSVoiceV2 - phone string -} +const PinpointPhoneNumberResource = "PinpointPhoneNumber" func init() { - register("PinpointPhoneNumber", ListPinpointPhoneNumbers) + registry.Register(®istry.Registration{ + Name: PinpointPhoneNumberResource, + Scope: nuke.Account, + Lister: &PinpointPhoneNumberLister{}, + }) } -func ListPinpointPhoneNumbers(sess *session.Session) ([]Resource, error) { - svc := pinpointsmsvoicev2.New(sess) +type PinpointPhoneNumberLister struct{} + +func (l *PinpointPhoneNumberLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + svc := pinpointsmsvoicev2.New(opts.Session) resp, err := svc.DescribePhoneNumbers(&pinpointsmsvoicev2.DescribePhoneNumbersInput{}) if err != nil { return nil, err } - numbers := make([]Resource, 0) + numbers := make([]resource.Resource, 0) for _, number := range resp.PhoneNumbers { numbers = append(numbers, &PinpointPhoneNumber{ - svc: svc, - phone: aws.StringValue(number.PhoneNumberId), + svc: svc, + ID: number.PhoneNumberId, }) } return numbers, nil } -func (p *PinpointPhoneNumber) Remove() error { +type PinpointPhoneNumber struct { + svc *pinpointsmsvoicev2.PinpointSMSVoiceV2 + ID *string +} + +func (p *PinpointPhoneNumber) Remove(_ context.Context) error { params := &pinpointsmsvoicev2.ReleasePhoneNumberInput{ - PhoneNumberId: aws.String(p.phone), + PhoneNumberId: p.ID, } _, err := p.svc.ReleasePhoneNumber(params) @@ -48,5 +63,5 @@ func (p *PinpointPhoneNumber) Remove() error { } func (p *PinpointPhoneNumber) String() string { - return p.phone + return *p.ID } From ffaaa30f1c8c207a1727960799ef778fbe00bab9 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:17:07 -0500 Subject: [PATCH 10/23] refactor(pinpoint-app): rename all receivers --- resources/pinpoint-app.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/resources/pinpoint-app.go b/resources/pinpoint-app.go index 127d1980..bcbccb26 100644 --- a/resources/pinpoint-app.go +++ b/resources/pinpoint-app.go @@ -49,12 +49,12 @@ type PinpointApp struct { ID *string } -func (p *PinpointApp) Remove(_ context.Context) error { +func (r *PinpointApp) Remove(_ context.Context) error { params := &pinpoint.DeleteAppInput{ - ApplicationId: p.ID, + ApplicationId: r.ID, } - _, err := p.svc.DeleteApp(params) + _, err := r.svc.DeleteApp(params) if err != nil { return err } @@ -62,6 +62,6 @@ func (p *PinpointApp) Remove(_ context.Context) error { return nil } -func (p *PinpointApp) String() string { - return *p.ID +func (r *PinpointApp) String() string { + return *r.ID } From b703e066ec8baf016c7e63260c525b513a86e9bb Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 25 Sep 2024 21:17:16 -0500 Subject: [PATCH 11/23] refactor(pinpoint-phone-number): rename all receivers --- resources/pinpoint-phone-number.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/resources/pinpoint-phone-number.go b/resources/pinpoint-phone-number.go index 9a0f87f7..2565ba85 100644 --- a/resources/pinpoint-phone-number.go +++ b/resources/pinpoint-phone-number.go @@ -49,12 +49,12 @@ type PinpointPhoneNumber struct { ID *string } -func (p *PinpointPhoneNumber) Remove(_ context.Context) error { +func (r *PinpointPhoneNumber) Remove(_ context.Context) error { params := &pinpointsmsvoicev2.ReleasePhoneNumberInput{ - PhoneNumberId: p.ID, + PhoneNumberId: r.ID, } - _, err := p.svc.ReleasePhoneNumber(params) + _, err := r.svc.ReleasePhoneNumber(params) if err != nil { return err } @@ -62,6 +62,6 @@ func (p *PinpointPhoneNumber) Remove(_ context.Context) error { return nil } -func (p *PinpointPhoneNumber) String() string { - return *p.ID +func (r *PinpointPhoneNumber) String() string { + return *r.ID } From d98fa97002621880300929d5faf91e6241a315c2 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 08:40:42 -0600 Subject: [PATCH 12/23] feat(pinpoint-app): adding properties --- resources/pinpoint-app.go | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/resources/pinpoint-app.go b/resources/pinpoint-app.go index bcbccb26..a5524be1 100644 --- a/resources/pinpoint-app.go +++ b/resources/pinpoint-app.go @@ -2,11 +2,13 @@ package resources import ( "context" + "time" "github.com/aws/aws-sdk-go/service/pinpoint" "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) @@ -36,8 +38,10 @@ func (l *PinpointAppLister) List(_ context.Context, o interface{}) ([]resource.R apps := make([]resource.Resource, 0) for _, appResponse := range resp.ApplicationsResponse.Item { apps = append(apps, &PinpointApp{ - svc: svc, - ID: appResponse.Id, + svc: svc, + ID: appResponse.Id, + Name: appResponse.Name, + Tags: appResponse.Tags, }) } @@ -45,8 +49,15 @@ func (l *PinpointAppLister) List(_ context.Context, o interface{}) ([]resource.R } type PinpointApp struct { - svc *pinpoint.Pinpoint - ID *string + svc *pinpoint.Pinpoint + ID *string + Name *string + CreationDate *time.Time + Tags map[string]*string +} + +func (r *PinpointApp) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) } func (r *PinpointApp) Remove(_ context.Context) error { @@ -63,5 +74,5 @@ func (r *PinpointApp) Remove(_ context.Context) error { } func (r *PinpointApp) String() string { - return *r.ID + return *r.Name } From 570177f4c7b97b8158d9d01f84314d7f940331e0 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 08:46:35 -0600 Subject: [PATCH 13/23] feat(pinpoint-phone-number): add pagination and properties --- resources/pinpoint-phone-number.go | 75 +++++++++++++++++++++++------- 1 file changed, 58 insertions(+), 17 deletions(-) diff --git a/resources/pinpoint-phone-number.go b/resources/pinpoint-phone-number.go index 2565ba85..e17a83a9 100644 --- a/resources/pinpoint-phone-number.go +++ b/resources/pinpoint-phone-number.go @@ -2,11 +2,16 @@ package resources import ( "context" + "time" + + "github.com/gotidy/ptr" "github.com/aws/aws-sdk-go/service/pinpointsmsvoicev2" "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/settings" + "github.com/ekristen/libnuke/pkg/types" "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) @@ -18,6 +23,9 @@ func init() { Name: PinpointPhoneNumberResource, Scope: nuke.Account, Lister: &PinpointPhoneNumberLister{}, + Settings: []string{ + "DisableDeletionProtection", + }, }) } @@ -25,36 +33,65 @@ type PinpointPhoneNumberLister struct{} func (l *PinpointPhoneNumberLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := pinpointsmsvoicev2.New(opts.Session) - resp, err := svc.DescribePhoneNumbers(&pinpointsmsvoicev2.DescribePhoneNumbersInput{}) - if err != nil { - return nil, err + params := &pinpointsmsvoicev2.DescribePhoneNumbersInput{} + + for { + resp, err := svc.DescribePhoneNumbers(params) + if err != nil { + return nil, err + } + + for _, number := range resp.PhoneNumbers { + resources = append(resources, &PinpointPhoneNumber{ + svc: svc, + settings: &settings.Setting{}, + ID: number.PhoneNumberId, + Status: number.Status, + CreatedDate: number.CreatedTimestamp, + }) + } + + if resp.NextToken == nil { + break + } + + params.NextToken = resp.NextToken } - numbers := make([]resource.Resource, 0) - for _, number := range resp.PhoneNumbers { - numbers = append(numbers, &PinpointPhoneNumber{ - svc: svc, - ID: number.PhoneNumberId, - }) - } - - return numbers, nil + return resources, nil } type PinpointPhoneNumber struct { - svc *pinpointsmsvoicev2.PinpointSMSVoiceV2 - ID *string + svc *pinpointsmsvoicev2.PinpointSMSVoiceV2 + settings *settings.Setting + ID *string + Status *string + CreatedDate *time.Time + deletionProtectionEnabled *bool +} + +func (r *PinpointPhoneNumber) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) } func (r *PinpointPhoneNumber) Remove(_ context.Context) error { - params := &pinpointsmsvoicev2.ReleasePhoneNumberInput{ - PhoneNumberId: r.ID, + if r.settings.GetBool("DisableDeletionProtection") { + _, err := r.svc.UpdatePhoneNumber(&pinpointsmsvoicev2.UpdatePhoneNumberInput{ + PhoneNumberId: r.ID, + DeletionProtectionEnabled: ptr.Bool(false), + }) + if err != nil { + return err + } } - _, err := r.svc.ReleasePhoneNumber(params) + _, err := r.svc.ReleasePhoneNumber(&pinpointsmsvoicev2.ReleasePhoneNumberInput{ + PhoneNumberId: r.ID, + }) if err != nil { return err } @@ -62,6 +99,10 @@ func (r *PinpointPhoneNumber) Remove(_ context.Context) error { return nil } +func (r *PinpointPhoneNumber) Settings(settings *settings.Setting) { + r.settings = settings +} + func (r *PinpointPhoneNumber) String() string { return *r.ID } From 9b7ff605e8adad0290ef2aa309f2a499232fe440 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 08:47:41 -0600 Subject: [PATCH 14/23] feat(pinpoint-app): add pagination support --- resources/pinpoint-app.go | 36 +++++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/resources/pinpoint-app.go b/resources/pinpoint-app.go index a5524be1..e9040fe3 100644 --- a/resources/pinpoint-app.go +++ b/resources/pinpoint-app.go @@ -27,25 +27,35 @@ type PinpointAppLister struct{} func (l *PinpointAppLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := pinpoint.New(opts.Session) - resp, err := svc.GetApps(&pinpoint.GetAppsInput{}) - if err != nil { - return nil, err - } + params := &pinpoint.GetAppsInput{} + + for { + resp, err := svc.GetApps(params) + if err != nil { + return nil, err + } + + for _, appResponse := range resp.ApplicationsResponse.Item { + resources = append(resources, &PinpointApp{ + svc: svc, + ID: appResponse.Id, + Name: appResponse.Name, + Tags: appResponse.Tags, + }) + } + + if resp.ApplicationsResponse.NextToken == nil { + break + } - apps := make([]resource.Resource, 0) - for _, appResponse := range resp.ApplicationsResponse.Item { - apps = append(apps, &PinpointApp{ - svc: svc, - ID: appResponse.Id, - Name: appResponse.Name, - Tags: appResponse.Tags, - }) + params.Token = resp.ApplicationsResponse.NextToken } - return apps, nil + return resources, nil } type PinpointApp struct { From 9ff39fa263dbc59584c216c63ca1a1992d2e8b6c Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 08:49:25 -0600 Subject: [PATCH 15/23] test(pinpoint): adding mocks --- mocks/mock_pinpointsmsvoicev2iface/mock.go | 4830 ++++++++++++++++++++ resources/pinpoint_mock_test.go | 4 + 2 files changed, 4834 insertions(+) create mode 100644 mocks/mock_pinpointsmsvoicev2iface/mock.go create mode 100644 resources/pinpoint_mock_test.go diff --git a/mocks/mock_pinpointsmsvoicev2iface/mock.go b/mocks/mock_pinpointsmsvoicev2iface/mock.go new file mode 100644 index 00000000..7eb1916d --- /dev/null +++ b/mocks/mock_pinpointsmsvoicev2iface/mock.go @@ -0,0 +1,4830 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.54.20/service/pinpointsmsvoicev2/pinpointsmsvoicev2iface/interface.go + +// Package mock_pinpointsmsvoicev2iface is a generated GoMock package. +package mock_pinpointsmsvoicev2iface + +import ( + reflect "reflect" + + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + pinpointsmsvoicev2 "github.com/aws/aws-sdk-go/service/pinpointsmsvoicev2" + gomock "github.com/golang/mock/gomock" +) + +// MockPinpointSMSVoiceV2API is a mock of PinpointSMSVoiceV2API interface. +type MockPinpointSMSVoiceV2API struct { + ctrl *gomock.Controller + recorder *MockPinpointSMSVoiceV2APIMockRecorder +} + +// MockPinpointSMSVoiceV2APIMockRecorder is the mock recorder for MockPinpointSMSVoiceV2API. +type MockPinpointSMSVoiceV2APIMockRecorder struct { + mock *MockPinpointSMSVoiceV2API +} + +// NewMockPinpointSMSVoiceV2API creates a new mock instance. +func NewMockPinpointSMSVoiceV2API(ctrl *gomock.Controller) *MockPinpointSMSVoiceV2API { + mock := &MockPinpointSMSVoiceV2API{ctrl: ctrl} + mock.recorder = &MockPinpointSMSVoiceV2APIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPinpointSMSVoiceV2API) EXPECT() *MockPinpointSMSVoiceV2APIMockRecorder { + return m.recorder +} + +// AssociateOriginationIdentity mocks base method. +func (m *MockPinpointSMSVoiceV2API) AssociateOriginationIdentity(arg0 *pinpointsmsvoicev2.AssociateOriginationIdentityInput) (*pinpointsmsvoicev2.AssociateOriginationIdentityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateOriginationIdentity", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.AssociateOriginationIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateOriginationIdentity indicates an expected call of AssociateOriginationIdentity. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) AssociateOriginationIdentity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateOriginationIdentity", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).AssociateOriginationIdentity), arg0) +} + +// AssociateOriginationIdentityRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) AssociateOriginationIdentityRequest(arg0 *pinpointsmsvoicev2.AssociateOriginationIdentityInput) (*request.Request, *pinpointsmsvoicev2.AssociateOriginationIdentityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateOriginationIdentityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.AssociateOriginationIdentityOutput) + return ret0, ret1 +} + +// AssociateOriginationIdentityRequest indicates an expected call of AssociateOriginationIdentityRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) AssociateOriginationIdentityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateOriginationIdentityRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).AssociateOriginationIdentityRequest), arg0) +} + +// AssociateOriginationIdentityWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) AssociateOriginationIdentityWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.AssociateOriginationIdentityInput, arg2 ...request.Option) (*pinpointsmsvoicev2.AssociateOriginationIdentityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateOriginationIdentityWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.AssociateOriginationIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateOriginationIdentityWithContext indicates an expected call of AssociateOriginationIdentityWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) AssociateOriginationIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateOriginationIdentityWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).AssociateOriginationIdentityWithContext), varargs...) +} + +// AssociateProtectConfiguration mocks base method. +func (m *MockPinpointSMSVoiceV2API) AssociateProtectConfiguration(arg0 *pinpointsmsvoicev2.AssociateProtectConfigurationInput) (*pinpointsmsvoicev2.AssociateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateProtectConfiguration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.AssociateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateProtectConfiguration indicates an expected call of AssociateProtectConfiguration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) AssociateProtectConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateProtectConfiguration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).AssociateProtectConfiguration), arg0) +} + +// AssociateProtectConfigurationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) AssociateProtectConfigurationRequest(arg0 *pinpointsmsvoicev2.AssociateProtectConfigurationInput) (*request.Request, *pinpointsmsvoicev2.AssociateProtectConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateProtectConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.AssociateProtectConfigurationOutput) + return ret0, ret1 +} + +// AssociateProtectConfigurationRequest indicates an expected call of AssociateProtectConfigurationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) AssociateProtectConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateProtectConfigurationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).AssociateProtectConfigurationRequest), arg0) +} + +// AssociateProtectConfigurationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) AssociateProtectConfigurationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.AssociateProtectConfigurationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.AssociateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateProtectConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.AssociateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateProtectConfigurationWithContext indicates an expected call of AssociateProtectConfigurationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) AssociateProtectConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateProtectConfigurationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).AssociateProtectConfigurationWithContext), varargs...) +} + +// CreateConfigurationSet mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateConfigurationSet(arg0 *pinpointsmsvoicev2.CreateConfigurationSetInput) (*pinpointsmsvoicev2.CreateConfigurationSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateConfigurationSet", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateConfigurationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateConfigurationSet indicates an expected call of CreateConfigurationSet. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateConfigurationSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigurationSet", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateConfigurationSet), arg0) +} + +// CreateConfigurationSetRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateConfigurationSetRequest(arg0 *pinpointsmsvoicev2.CreateConfigurationSetInput) (*request.Request, *pinpointsmsvoicev2.CreateConfigurationSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateConfigurationSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateConfigurationSetOutput) + return ret0, ret1 +} + +// CreateConfigurationSetRequest indicates an expected call of CreateConfigurationSetRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateConfigurationSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigurationSetRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateConfigurationSetRequest), arg0) +} + +// CreateConfigurationSetWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateConfigurationSetWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateConfigurationSetInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateConfigurationSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateConfigurationSetWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateConfigurationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateConfigurationSetWithContext indicates an expected call of CreateConfigurationSetWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateConfigurationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigurationSetWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateConfigurationSetWithContext), varargs...) +} + +// CreateEventDestination mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateEventDestination(arg0 *pinpointsmsvoicev2.CreateEventDestinationInput) (*pinpointsmsvoicev2.CreateEventDestinationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateEventDestination", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateEventDestinationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateEventDestination indicates an expected call of CreateEventDestination. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateEventDestination(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventDestination", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateEventDestination), arg0) +} + +// CreateEventDestinationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateEventDestinationRequest(arg0 *pinpointsmsvoicev2.CreateEventDestinationInput) (*request.Request, *pinpointsmsvoicev2.CreateEventDestinationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateEventDestinationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateEventDestinationOutput) + return ret0, ret1 +} + +// CreateEventDestinationRequest indicates an expected call of CreateEventDestinationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateEventDestinationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventDestinationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateEventDestinationRequest), arg0) +} + +// CreateEventDestinationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateEventDestinationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateEventDestinationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateEventDestinationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateEventDestinationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateEventDestinationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateEventDestinationWithContext indicates an expected call of CreateEventDestinationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateEventDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventDestinationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateEventDestinationWithContext), varargs...) +} + +// CreateOptOutList mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateOptOutList(arg0 *pinpointsmsvoicev2.CreateOptOutListInput) (*pinpointsmsvoicev2.CreateOptOutListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOptOutList", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateOptOutListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOptOutList indicates an expected call of CreateOptOutList. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateOptOutList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOptOutList", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateOptOutList), arg0) +} + +// CreateOptOutListRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateOptOutListRequest(arg0 *pinpointsmsvoicev2.CreateOptOutListInput) (*request.Request, *pinpointsmsvoicev2.CreateOptOutListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOptOutListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateOptOutListOutput) + return ret0, ret1 +} + +// CreateOptOutListRequest indicates an expected call of CreateOptOutListRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateOptOutListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOptOutListRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateOptOutListRequest), arg0) +} + +// CreateOptOutListWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateOptOutListWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateOptOutListInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateOptOutListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateOptOutListWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateOptOutListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOptOutListWithContext indicates an expected call of CreateOptOutListWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateOptOutListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOptOutListWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateOptOutListWithContext), varargs...) +} + +// CreatePool mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreatePool(arg0 *pinpointsmsvoicev2.CreatePoolInput) (*pinpointsmsvoicev2.CreatePoolOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePool", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreatePoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePool indicates an expected call of CreatePool. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreatePool(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePool", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreatePool), arg0) +} + +// CreatePoolRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreatePoolRequest(arg0 *pinpointsmsvoicev2.CreatePoolInput) (*request.Request, *pinpointsmsvoicev2.CreatePoolOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePoolRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreatePoolOutput) + return ret0, ret1 +} + +// CreatePoolRequest indicates an expected call of CreatePoolRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreatePoolRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePoolRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreatePoolRequest), arg0) +} + +// CreatePoolWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreatePoolWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreatePoolInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreatePoolOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePoolWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreatePoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePoolWithContext indicates an expected call of CreatePoolWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreatePoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePoolWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreatePoolWithContext), varargs...) +} + +// CreateProtectConfiguration mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateProtectConfiguration(arg0 *pinpointsmsvoicev2.CreateProtectConfigurationInput) (*pinpointsmsvoicev2.CreateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateProtectConfiguration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateProtectConfiguration indicates an expected call of CreateProtectConfiguration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateProtectConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtectConfiguration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateProtectConfiguration), arg0) +} + +// CreateProtectConfigurationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateProtectConfigurationRequest(arg0 *pinpointsmsvoicev2.CreateProtectConfigurationInput) (*request.Request, *pinpointsmsvoicev2.CreateProtectConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateProtectConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateProtectConfigurationOutput) + return ret0, ret1 +} + +// CreateProtectConfigurationRequest indicates an expected call of CreateProtectConfigurationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateProtectConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtectConfigurationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateProtectConfigurationRequest), arg0) +} + +// CreateProtectConfigurationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateProtectConfigurationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateProtectConfigurationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateProtectConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateProtectConfigurationWithContext indicates an expected call of CreateProtectConfigurationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateProtectConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtectConfigurationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateProtectConfigurationWithContext), varargs...) +} + +// CreateRegistration mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistration(arg0 *pinpointsmsvoicev2.CreateRegistrationInput) (*pinpointsmsvoicev2.CreateRegistrationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistration indicates an expected call of CreateRegistration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistration), arg0) +} + +// CreateRegistrationAssociation mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationAssociation(arg0 *pinpointsmsvoicev2.CreateRegistrationAssociationInput) (*pinpointsmsvoicev2.CreateRegistrationAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistrationAssociation", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistrationAssociation indicates an expected call of CreateRegistrationAssociation. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationAssociation", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationAssociation), arg0) +} + +// CreateRegistrationAssociationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationAssociationRequest(arg0 *pinpointsmsvoicev2.CreateRegistrationAssociationInput) (*request.Request, *pinpointsmsvoicev2.CreateRegistrationAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistrationAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateRegistrationAssociationOutput) + return ret0, ret1 +} + +// CreateRegistrationAssociationRequest indicates an expected call of CreateRegistrationAssociationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationAssociationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationAssociationRequest), arg0) +} + +// CreateRegistrationAssociationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationAssociationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateRegistrationAssociationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateRegistrationAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRegistrationAssociationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistrationAssociationWithContext indicates an expected call of CreateRegistrationAssociationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationAssociationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationAssociationWithContext), varargs...) +} + +// CreateRegistrationAttachment mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationAttachment(arg0 *pinpointsmsvoicev2.CreateRegistrationAttachmentInput) (*pinpointsmsvoicev2.CreateRegistrationAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistrationAttachment", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistrationAttachment indicates an expected call of CreateRegistrationAttachment. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationAttachment", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationAttachment), arg0) +} + +// CreateRegistrationAttachmentRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationAttachmentRequest(arg0 *pinpointsmsvoicev2.CreateRegistrationAttachmentInput) (*request.Request, *pinpointsmsvoicev2.CreateRegistrationAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistrationAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateRegistrationAttachmentOutput) + return ret0, ret1 +} + +// CreateRegistrationAttachmentRequest indicates an expected call of CreateRegistrationAttachmentRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationAttachmentRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationAttachmentRequest), arg0) +} + +// CreateRegistrationAttachmentWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationAttachmentWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateRegistrationAttachmentInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateRegistrationAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRegistrationAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistrationAttachmentWithContext indicates an expected call of CreateRegistrationAttachmentWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationAttachmentWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationAttachmentWithContext), varargs...) +} + +// CreateRegistrationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationRequest(arg0 *pinpointsmsvoicev2.CreateRegistrationInput) (*request.Request, *pinpointsmsvoicev2.CreateRegistrationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistrationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateRegistrationOutput) + return ret0, ret1 +} + +// CreateRegistrationRequest indicates an expected call of CreateRegistrationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationRequest), arg0) +} + +// CreateRegistrationVersion mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationVersion(arg0 *pinpointsmsvoicev2.CreateRegistrationVersionInput) (*pinpointsmsvoicev2.CreateRegistrationVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistrationVersion", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistrationVersion indicates an expected call of CreateRegistrationVersion. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationVersion", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationVersion), arg0) +} + +// CreateRegistrationVersionRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationVersionRequest(arg0 *pinpointsmsvoicev2.CreateRegistrationVersionInput) (*request.Request, *pinpointsmsvoicev2.CreateRegistrationVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRegistrationVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateRegistrationVersionOutput) + return ret0, ret1 +} + +// CreateRegistrationVersionRequest indicates an expected call of CreateRegistrationVersionRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationVersionRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationVersionRequest), arg0) +} + +// CreateRegistrationVersionWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationVersionWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateRegistrationVersionInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateRegistrationVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRegistrationVersionWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistrationVersionWithContext indicates an expected call of CreateRegistrationVersionWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationVersionWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationVersionWithContext), varargs...) +} + +// CreateRegistrationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateRegistrationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateRegistrationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateRegistrationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRegistrationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateRegistrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRegistrationWithContext indicates an expected call of CreateRegistrationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateRegistrationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRegistrationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateRegistrationWithContext), varargs...) +} + +// CreateVerifiedDestinationNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateVerifiedDestinationNumber(arg0 *pinpointsmsvoicev2.CreateVerifiedDestinationNumberInput) (*pinpointsmsvoicev2.CreateVerifiedDestinationNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVerifiedDestinationNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateVerifiedDestinationNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVerifiedDestinationNumber indicates an expected call of CreateVerifiedDestinationNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateVerifiedDestinationNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedDestinationNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateVerifiedDestinationNumber), arg0) +} + +// CreateVerifiedDestinationNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateVerifiedDestinationNumberRequest(arg0 *pinpointsmsvoicev2.CreateVerifiedDestinationNumberInput) (*request.Request, *pinpointsmsvoicev2.CreateVerifiedDestinationNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVerifiedDestinationNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.CreateVerifiedDestinationNumberOutput) + return ret0, ret1 +} + +// CreateVerifiedDestinationNumberRequest indicates an expected call of CreateVerifiedDestinationNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateVerifiedDestinationNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedDestinationNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateVerifiedDestinationNumberRequest), arg0) +} + +// CreateVerifiedDestinationNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) CreateVerifiedDestinationNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.CreateVerifiedDestinationNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.CreateVerifiedDestinationNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVerifiedDestinationNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.CreateVerifiedDestinationNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVerifiedDestinationNumberWithContext indicates an expected call of CreateVerifiedDestinationNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) CreateVerifiedDestinationNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedDestinationNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).CreateVerifiedDestinationNumberWithContext), varargs...) +} + +// DeleteAccountDefaultProtectConfiguration mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteAccountDefaultProtectConfiguration(arg0 *pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationInput) (*pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccountDefaultProtectConfiguration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccountDefaultProtectConfiguration indicates an expected call of DeleteAccountDefaultProtectConfiguration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteAccountDefaultProtectConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountDefaultProtectConfiguration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteAccountDefaultProtectConfiguration), arg0) +} + +// DeleteAccountDefaultProtectConfigurationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteAccountDefaultProtectConfigurationRequest(arg0 *pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationInput) (*request.Request, *pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccountDefaultProtectConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationOutput) + return ret0, ret1 +} + +// DeleteAccountDefaultProtectConfigurationRequest indicates an expected call of DeleteAccountDefaultProtectConfigurationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteAccountDefaultProtectConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountDefaultProtectConfigurationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteAccountDefaultProtectConfigurationRequest), arg0) +} + +// DeleteAccountDefaultProtectConfigurationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteAccountDefaultProtectConfigurationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAccountDefaultProtectConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteAccountDefaultProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccountDefaultProtectConfigurationWithContext indicates an expected call of DeleteAccountDefaultProtectConfigurationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteAccountDefaultProtectConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountDefaultProtectConfigurationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteAccountDefaultProtectConfigurationWithContext), varargs...) +} + +// DeleteConfigurationSet mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteConfigurationSet(arg0 *pinpointsmsvoicev2.DeleteConfigurationSetInput) (*pinpointsmsvoicev2.DeleteConfigurationSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigurationSet", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteConfigurationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigurationSet indicates an expected call of DeleteConfigurationSet. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteConfigurationSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationSet", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteConfigurationSet), arg0) +} + +// DeleteConfigurationSetRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteConfigurationSetRequest(arg0 *pinpointsmsvoicev2.DeleteConfigurationSetInput) (*request.Request, *pinpointsmsvoicev2.DeleteConfigurationSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigurationSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteConfigurationSetOutput) + return ret0, ret1 +} + +// DeleteConfigurationSetRequest indicates an expected call of DeleteConfigurationSetRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteConfigurationSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationSetRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteConfigurationSetRequest), arg0) +} + +// DeleteConfigurationSetWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteConfigurationSetWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteConfigurationSetInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteConfigurationSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteConfigurationSetWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteConfigurationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigurationSetWithContext indicates an expected call of DeleteConfigurationSetWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteConfigurationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationSetWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteConfigurationSetWithContext), varargs...) +} + +// DeleteDefaultMessageType mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteDefaultMessageType(arg0 *pinpointsmsvoicev2.DeleteDefaultMessageTypeInput) (*pinpointsmsvoicev2.DeleteDefaultMessageTypeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDefaultMessageType", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteDefaultMessageTypeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDefaultMessageType indicates an expected call of DeleteDefaultMessageType. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteDefaultMessageType(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefaultMessageType", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteDefaultMessageType), arg0) +} + +// DeleteDefaultMessageTypeRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteDefaultMessageTypeRequest(arg0 *pinpointsmsvoicev2.DeleteDefaultMessageTypeInput) (*request.Request, *pinpointsmsvoicev2.DeleteDefaultMessageTypeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDefaultMessageTypeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteDefaultMessageTypeOutput) + return ret0, ret1 +} + +// DeleteDefaultMessageTypeRequest indicates an expected call of DeleteDefaultMessageTypeRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteDefaultMessageTypeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefaultMessageTypeRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteDefaultMessageTypeRequest), arg0) +} + +// DeleteDefaultMessageTypeWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteDefaultMessageTypeWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteDefaultMessageTypeInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteDefaultMessageTypeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteDefaultMessageTypeWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteDefaultMessageTypeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDefaultMessageTypeWithContext indicates an expected call of DeleteDefaultMessageTypeWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteDefaultMessageTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefaultMessageTypeWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteDefaultMessageTypeWithContext), varargs...) +} + +// DeleteDefaultSenderId mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteDefaultSenderId(arg0 *pinpointsmsvoicev2.DeleteDefaultSenderIdInput) (*pinpointsmsvoicev2.DeleteDefaultSenderIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDefaultSenderId", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteDefaultSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDefaultSenderId indicates an expected call of DeleteDefaultSenderId. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteDefaultSenderId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefaultSenderId", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteDefaultSenderId), arg0) +} + +// DeleteDefaultSenderIdRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteDefaultSenderIdRequest(arg0 *pinpointsmsvoicev2.DeleteDefaultSenderIdInput) (*request.Request, *pinpointsmsvoicev2.DeleteDefaultSenderIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDefaultSenderIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteDefaultSenderIdOutput) + return ret0, ret1 +} + +// DeleteDefaultSenderIdRequest indicates an expected call of DeleteDefaultSenderIdRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteDefaultSenderIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefaultSenderIdRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteDefaultSenderIdRequest), arg0) +} + +// DeleteDefaultSenderIdWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteDefaultSenderIdWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteDefaultSenderIdInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteDefaultSenderIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteDefaultSenderIdWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteDefaultSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDefaultSenderIdWithContext indicates an expected call of DeleteDefaultSenderIdWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteDefaultSenderIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefaultSenderIdWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteDefaultSenderIdWithContext), varargs...) +} + +// DeleteEventDestination mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteEventDestination(arg0 *pinpointsmsvoicev2.DeleteEventDestinationInput) (*pinpointsmsvoicev2.DeleteEventDestinationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteEventDestination", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteEventDestinationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteEventDestination indicates an expected call of DeleteEventDestination. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteEventDestination(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventDestination", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteEventDestination), arg0) +} + +// DeleteEventDestinationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteEventDestinationRequest(arg0 *pinpointsmsvoicev2.DeleteEventDestinationInput) (*request.Request, *pinpointsmsvoicev2.DeleteEventDestinationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteEventDestinationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteEventDestinationOutput) + return ret0, ret1 +} + +// DeleteEventDestinationRequest indicates an expected call of DeleteEventDestinationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteEventDestinationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventDestinationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteEventDestinationRequest), arg0) +} + +// DeleteEventDestinationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteEventDestinationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteEventDestinationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteEventDestinationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteEventDestinationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteEventDestinationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteEventDestinationWithContext indicates an expected call of DeleteEventDestinationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteEventDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventDestinationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteEventDestinationWithContext), varargs...) +} + +// DeleteKeyword mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteKeyword(arg0 *pinpointsmsvoicev2.DeleteKeywordInput) (*pinpointsmsvoicev2.DeleteKeywordOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteKeyword", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteKeywordOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteKeyword indicates an expected call of DeleteKeyword. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteKeyword(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyword", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteKeyword), arg0) +} + +// DeleteKeywordRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteKeywordRequest(arg0 *pinpointsmsvoicev2.DeleteKeywordInput) (*request.Request, *pinpointsmsvoicev2.DeleteKeywordOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteKeywordRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteKeywordOutput) + return ret0, ret1 +} + +// DeleteKeywordRequest indicates an expected call of DeleteKeywordRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteKeywordRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeywordRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteKeywordRequest), arg0) +} + +// DeleteKeywordWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteKeywordWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteKeywordInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteKeywordOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteKeywordWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteKeywordOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteKeywordWithContext indicates an expected call of DeleteKeywordWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteKeywordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeywordWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteKeywordWithContext), varargs...) +} + +// DeleteMediaMessageSpendLimitOverride mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteMediaMessageSpendLimitOverride(arg0 *pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideInput) (*pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMediaMessageSpendLimitOverride", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMediaMessageSpendLimitOverride indicates an expected call of DeleteMediaMessageSpendLimitOverride. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteMediaMessageSpendLimitOverride(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMediaMessageSpendLimitOverride", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteMediaMessageSpendLimitOverride), arg0) +} + +// DeleteMediaMessageSpendLimitOverrideRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteMediaMessageSpendLimitOverrideRequest(arg0 *pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideInput) (*request.Request, *pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMediaMessageSpendLimitOverrideRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideOutput) + return ret0, ret1 +} + +// DeleteMediaMessageSpendLimitOverrideRequest indicates an expected call of DeleteMediaMessageSpendLimitOverrideRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteMediaMessageSpendLimitOverrideRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMediaMessageSpendLimitOverrideRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteMediaMessageSpendLimitOverrideRequest), arg0) +} + +// DeleteMediaMessageSpendLimitOverrideWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteMediaMessageSpendLimitOverrideWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteMediaMessageSpendLimitOverrideWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteMediaMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMediaMessageSpendLimitOverrideWithContext indicates an expected call of DeleteMediaMessageSpendLimitOverrideWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteMediaMessageSpendLimitOverrideWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMediaMessageSpendLimitOverrideWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteMediaMessageSpendLimitOverrideWithContext), varargs...) +} + +// DeleteOptOutList mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteOptOutList(arg0 *pinpointsmsvoicev2.DeleteOptOutListInput) (*pinpointsmsvoicev2.DeleteOptOutListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOptOutList", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteOptOutListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOptOutList indicates an expected call of DeleteOptOutList. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteOptOutList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptOutList", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteOptOutList), arg0) +} + +// DeleteOptOutListRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteOptOutListRequest(arg0 *pinpointsmsvoicev2.DeleteOptOutListInput) (*request.Request, *pinpointsmsvoicev2.DeleteOptOutListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOptOutListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteOptOutListOutput) + return ret0, ret1 +} + +// DeleteOptOutListRequest indicates an expected call of DeleteOptOutListRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteOptOutListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptOutListRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteOptOutListRequest), arg0) +} + +// DeleteOptOutListWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteOptOutListWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteOptOutListInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteOptOutListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteOptOutListWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteOptOutListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOptOutListWithContext indicates an expected call of DeleteOptOutListWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteOptOutListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptOutListWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteOptOutListWithContext), varargs...) +} + +// DeleteOptedOutNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteOptedOutNumber(arg0 *pinpointsmsvoicev2.DeleteOptedOutNumberInput) (*pinpointsmsvoicev2.DeleteOptedOutNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOptedOutNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteOptedOutNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOptedOutNumber indicates an expected call of DeleteOptedOutNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteOptedOutNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptedOutNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteOptedOutNumber), arg0) +} + +// DeleteOptedOutNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteOptedOutNumberRequest(arg0 *pinpointsmsvoicev2.DeleteOptedOutNumberInput) (*request.Request, *pinpointsmsvoicev2.DeleteOptedOutNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOptedOutNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteOptedOutNumberOutput) + return ret0, ret1 +} + +// DeleteOptedOutNumberRequest indicates an expected call of DeleteOptedOutNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteOptedOutNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptedOutNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteOptedOutNumberRequest), arg0) +} + +// DeleteOptedOutNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteOptedOutNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteOptedOutNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteOptedOutNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteOptedOutNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteOptedOutNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOptedOutNumberWithContext indicates an expected call of DeleteOptedOutNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteOptedOutNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOptedOutNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteOptedOutNumberWithContext), varargs...) +} + +// DeletePool mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeletePool(arg0 *pinpointsmsvoicev2.DeletePoolInput) (*pinpointsmsvoicev2.DeletePoolOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePool", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeletePoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePool indicates an expected call of DeletePool. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeletePool(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePool", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeletePool), arg0) +} + +// DeletePoolRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeletePoolRequest(arg0 *pinpointsmsvoicev2.DeletePoolInput) (*request.Request, *pinpointsmsvoicev2.DeletePoolOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePoolRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeletePoolOutput) + return ret0, ret1 +} + +// DeletePoolRequest indicates an expected call of DeletePoolRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeletePoolRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePoolRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeletePoolRequest), arg0) +} + +// DeletePoolWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeletePoolWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeletePoolInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeletePoolOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePoolWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeletePoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePoolWithContext indicates an expected call of DeletePoolWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeletePoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePoolWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeletePoolWithContext), varargs...) +} + +// DeleteProtectConfiguration mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteProtectConfiguration(arg0 *pinpointsmsvoicev2.DeleteProtectConfigurationInput) (*pinpointsmsvoicev2.DeleteProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteProtectConfiguration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteProtectConfiguration indicates an expected call of DeleteProtectConfiguration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteProtectConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtectConfiguration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteProtectConfiguration), arg0) +} + +// DeleteProtectConfigurationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteProtectConfigurationRequest(arg0 *pinpointsmsvoicev2.DeleteProtectConfigurationInput) (*request.Request, *pinpointsmsvoicev2.DeleteProtectConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteProtectConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteProtectConfigurationOutput) + return ret0, ret1 +} + +// DeleteProtectConfigurationRequest indicates an expected call of DeleteProtectConfigurationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteProtectConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtectConfigurationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteProtectConfigurationRequest), arg0) +} + +// DeleteProtectConfigurationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteProtectConfigurationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteProtectConfigurationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteProtectConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteProtectConfigurationWithContext indicates an expected call of DeleteProtectConfigurationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteProtectConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtectConfigurationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteProtectConfigurationWithContext), varargs...) +} + +// DeleteRegistration mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistration(arg0 *pinpointsmsvoicev2.DeleteRegistrationInput) (*pinpointsmsvoicev2.DeleteRegistrationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRegistration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteRegistrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRegistration indicates an expected call of DeleteRegistration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistration), arg0) +} + +// DeleteRegistrationAttachment mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationAttachment(arg0 *pinpointsmsvoicev2.DeleteRegistrationAttachmentInput) (*pinpointsmsvoicev2.DeleteRegistrationAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRegistrationAttachment", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteRegistrationAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRegistrationAttachment indicates an expected call of DeleteRegistrationAttachment. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationAttachment", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationAttachment), arg0) +} + +// DeleteRegistrationAttachmentRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationAttachmentRequest(arg0 *pinpointsmsvoicev2.DeleteRegistrationAttachmentInput) (*request.Request, *pinpointsmsvoicev2.DeleteRegistrationAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRegistrationAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteRegistrationAttachmentOutput) + return ret0, ret1 +} + +// DeleteRegistrationAttachmentRequest indicates an expected call of DeleteRegistrationAttachmentRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationAttachmentRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationAttachmentRequest), arg0) +} + +// DeleteRegistrationAttachmentWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationAttachmentWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteRegistrationAttachmentInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteRegistrationAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRegistrationAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteRegistrationAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRegistrationAttachmentWithContext indicates an expected call of DeleteRegistrationAttachmentWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationAttachmentWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationAttachmentWithContext), varargs...) +} + +// DeleteRegistrationFieldValue mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationFieldValue(arg0 *pinpointsmsvoicev2.DeleteRegistrationFieldValueInput) (*pinpointsmsvoicev2.DeleteRegistrationFieldValueOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRegistrationFieldValue", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteRegistrationFieldValueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRegistrationFieldValue indicates an expected call of DeleteRegistrationFieldValue. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationFieldValue(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationFieldValue", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationFieldValue), arg0) +} + +// DeleteRegistrationFieldValueRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationFieldValueRequest(arg0 *pinpointsmsvoicev2.DeleteRegistrationFieldValueInput) (*request.Request, *pinpointsmsvoicev2.DeleteRegistrationFieldValueOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRegistrationFieldValueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteRegistrationFieldValueOutput) + return ret0, ret1 +} + +// DeleteRegistrationFieldValueRequest indicates an expected call of DeleteRegistrationFieldValueRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationFieldValueRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationFieldValueRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationFieldValueRequest), arg0) +} + +// DeleteRegistrationFieldValueWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationFieldValueWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteRegistrationFieldValueInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteRegistrationFieldValueOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRegistrationFieldValueWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteRegistrationFieldValueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRegistrationFieldValueWithContext indicates an expected call of DeleteRegistrationFieldValueWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationFieldValueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationFieldValueWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationFieldValueWithContext), varargs...) +} + +// DeleteRegistrationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationRequest(arg0 *pinpointsmsvoicev2.DeleteRegistrationInput) (*request.Request, *pinpointsmsvoicev2.DeleteRegistrationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRegistrationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteRegistrationOutput) + return ret0, ret1 +} + +// DeleteRegistrationRequest indicates an expected call of DeleteRegistrationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationRequest), arg0) +} + +// DeleteRegistrationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteRegistrationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteRegistrationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteRegistrationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRegistrationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteRegistrationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRegistrationWithContext indicates an expected call of DeleteRegistrationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteRegistrationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistrationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteRegistrationWithContext), varargs...) +} + +// DeleteTextMessageSpendLimitOverride mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteTextMessageSpendLimitOverride(arg0 *pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideInput) (*pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTextMessageSpendLimitOverride", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTextMessageSpendLimitOverride indicates an expected call of DeleteTextMessageSpendLimitOverride. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteTextMessageSpendLimitOverride(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTextMessageSpendLimitOverride", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteTextMessageSpendLimitOverride), arg0) +} + +// DeleteTextMessageSpendLimitOverrideRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteTextMessageSpendLimitOverrideRequest(arg0 *pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideInput) (*request.Request, *pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTextMessageSpendLimitOverrideRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideOutput) + return ret0, ret1 +} + +// DeleteTextMessageSpendLimitOverrideRequest indicates an expected call of DeleteTextMessageSpendLimitOverrideRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteTextMessageSpendLimitOverrideRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTextMessageSpendLimitOverrideRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteTextMessageSpendLimitOverrideRequest), arg0) +} + +// DeleteTextMessageSpendLimitOverrideWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteTextMessageSpendLimitOverrideWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTextMessageSpendLimitOverrideWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteTextMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTextMessageSpendLimitOverrideWithContext indicates an expected call of DeleteTextMessageSpendLimitOverrideWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteTextMessageSpendLimitOverrideWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTextMessageSpendLimitOverrideWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteTextMessageSpendLimitOverrideWithContext), varargs...) +} + +// DeleteVerifiedDestinationNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteVerifiedDestinationNumber(arg0 *pinpointsmsvoicev2.DeleteVerifiedDestinationNumberInput) (*pinpointsmsvoicev2.DeleteVerifiedDestinationNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVerifiedDestinationNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteVerifiedDestinationNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVerifiedDestinationNumber indicates an expected call of DeleteVerifiedDestinationNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteVerifiedDestinationNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedDestinationNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteVerifiedDestinationNumber), arg0) +} + +// DeleteVerifiedDestinationNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteVerifiedDestinationNumberRequest(arg0 *pinpointsmsvoicev2.DeleteVerifiedDestinationNumberInput) (*request.Request, *pinpointsmsvoicev2.DeleteVerifiedDestinationNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVerifiedDestinationNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteVerifiedDestinationNumberOutput) + return ret0, ret1 +} + +// DeleteVerifiedDestinationNumberRequest indicates an expected call of DeleteVerifiedDestinationNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteVerifiedDestinationNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedDestinationNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteVerifiedDestinationNumberRequest), arg0) +} + +// DeleteVerifiedDestinationNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteVerifiedDestinationNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteVerifiedDestinationNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteVerifiedDestinationNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVerifiedDestinationNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteVerifiedDestinationNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVerifiedDestinationNumberWithContext indicates an expected call of DeleteVerifiedDestinationNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteVerifiedDestinationNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedDestinationNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteVerifiedDestinationNumberWithContext), varargs...) +} + +// DeleteVoiceMessageSpendLimitOverride mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteVoiceMessageSpendLimitOverride(arg0 *pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideInput) (*pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVoiceMessageSpendLimitOverride", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVoiceMessageSpendLimitOverride indicates an expected call of DeleteVoiceMessageSpendLimitOverride. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteVoiceMessageSpendLimitOverride(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVoiceMessageSpendLimitOverride", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteVoiceMessageSpendLimitOverride), arg0) +} + +// DeleteVoiceMessageSpendLimitOverrideRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteVoiceMessageSpendLimitOverrideRequest(arg0 *pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideInput) (*request.Request, *pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVoiceMessageSpendLimitOverrideRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideOutput) + return ret0, ret1 +} + +// DeleteVoiceMessageSpendLimitOverrideRequest indicates an expected call of DeleteVoiceMessageSpendLimitOverrideRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteVoiceMessageSpendLimitOverrideRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVoiceMessageSpendLimitOverrideRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteVoiceMessageSpendLimitOverrideRequest), arg0) +} + +// DeleteVoiceMessageSpendLimitOverrideWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DeleteVoiceMessageSpendLimitOverrideWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVoiceMessageSpendLimitOverrideWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DeleteVoiceMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVoiceMessageSpendLimitOverrideWithContext indicates an expected call of DeleteVoiceMessageSpendLimitOverrideWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DeleteVoiceMessageSpendLimitOverrideWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVoiceMessageSpendLimitOverrideWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DeleteVoiceMessageSpendLimitOverrideWithContext), varargs...) +} + +// DescribeAccountAttributes mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountAttributes(arg0 *pinpointsmsvoicev2.DescribeAccountAttributesInput) (*pinpointsmsvoicev2.DescribeAccountAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountAttributes", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeAccountAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountAttributes indicates an expected call of DescribeAccountAttributes. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountAttributes), arg0) +} + +// DescribeAccountAttributesPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountAttributesPages(arg0 *pinpointsmsvoicev2.DescribeAccountAttributesInput, arg1 func(*pinpointsmsvoicev2.DescribeAccountAttributesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountAttributesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAccountAttributesPages indicates an expected call of DescribeAccountAttributesPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountAttributesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountAttributesPages), arg0, arg1) +} + +// DescribeAccountAttributesPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountAttributesPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeAccountAttributesInput, arg2 func(*pinpointsmsvoicev2.DescribeAccountAttributesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAccountAttributesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAccountAttributesPagesWithContext indicates an expected call of DescribeAccountAttributesPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountAttributesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountAttributesPagesWithContext), varargs...) +} + +// DescribeAccountAttributesRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountAttributesRequest(arg0 *pinpointsmsvoicev2.DescribeAccountAttributesInput) (*request.Request, *pinpointsmsvoicev2.DescribeAccountAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeAccountAttributesOutput) + return ret0, ret1 +} + +// DescribeAccountAttributesRequest indicates an expected call of DescribeAccountAttributesRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountAttributesRequest), arg0) +} + +// DescribeAccountAttributesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountAttributesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeAccountAttributesInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeAccountAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAccountAttributesWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeAccountAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountAttributesWithContext indicates an expected call of DescribeAccountAttributesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountAttributesWithContext), varargs...) +} + +// DescribeAccountLimits mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountLimits(arg0 *pinpointsmsvoicev2.DescribeAccountLimitsInput) (*pinpointsmsvoicev2.DescribeAccountLimitsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeAccountLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountLimits indicates an expected call of DescribeAccountLimits. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountLimits), arg0) +} + +// DescribeAccountLimitsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountLimitsPages(arg0 *pinpointsmsvoicev2.DescribeAccountLimitsInput, arg1 func(*pinpointsmsvoicev2.DescribeAccountLimitsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountLimitsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAccountLimitsPages indicates an expected call of DescribeAccountLimitsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountLimitsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountLimitsPages), arg0, arg1) +} + +// DescribeAccountLimitsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountLimitsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeAccountLimitsInput, arg2 func(*pinpointsmsvoicev2.DescribeAccountLimitsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAccountLimitsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAccountLimitsPagesWithContext indicates an expected call of DescribeAccountLimitsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountLimitsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountLimitsPagesWithContext), varargs...) +} + +// DescribeAccountLimitsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountLimitsRequest(arg0 *pinpointsmsvoicev2.DescribeAccountLimitsInput) (*request.Request, *pinpointsmsvoicev2.DescribeAccountLimitsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeAccountLimitsOutput) + return ret0, ret1 +} + +// DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountLimitsRequest), arg0) +} + +// DescribeAccountLimitsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeAccountLimitsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeAccountLimitsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeAccountLimitsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAccountLimitsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeAccountLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeAccountLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeAccountLimitsWithContext), varargs...) +} + +// DescribeConfigurationSets mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeConfigurationSets(arg0 *pinpointsmsvoicev2.DescribeConfigurationSetsInput) (*pinpointsmsvoicev2.DescribeConfigurationSetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationSets", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeConfigurationSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationSets indicates an expected call of DescribeConfigurationSets. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeConfigurationSets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationSets", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeConfigurationSets), arg0) +} + +// DescribeConfigurationSetsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeConfigurationSetsPages(arg0 *pinpointsmsvoicev2.DescribeConfigurationSetsInput, arg1 func(*pinpointsmsvoicev2.DescribeConfigurationSetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationSetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeConfigurationSetsPages indicates an expected call of DescribeConfigurationSetsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeConfigurationSetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationSetsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeConfigurationSetsPages), arg0, arg1) +} + +// DescribeConfigurationSetsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeConfigurationSetsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeConfigurationSetsInput, arg2 func(*pinpointsmsvoicev2.DescribeConfigurationSetsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigurationSetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeConfigurationSetsPagesWithContext indicates an expected call of DescribeConfigurationSetsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeConfigurationSetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationSetsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeConfigurationSetsPagesWithContext), varargs...) +} + +// DescribeConfigurationSetsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeConfigurationSetsRequest(arg0 *pinpointsmsvoicev2.DescribeConfigurationSetsInput) (*request.Request, *pinpointsmsvoicev2.DescribeConfigurationSetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationSetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeConfigurationSetsOutput) + return ret0, ret1 +} + +// DescribeConfigurationSetsRequest indicates an expected call of DescribeConfigurationSetsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeConfigurationSetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationSetsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeConfigurationSetsRequest), arg0) +} + +// DescribeConfigurationSetsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeConfigurationSetsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeConfigurationSetsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeConfigurationSetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigurationSetsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeConfigurationSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationSetsWithContext indicates an expected call of DescribeConfigurationSetsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeConfigurationSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationSetsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeConfigurationSetsWithContext), varargs...) +} + +// DescribeKeywords mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeKeywords(arg0 *pinpointsmsvoicev2.DescribeKeywordsInput) (*pinpointsmsvoicev2.DescribeKeywordsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeKeywords", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeKeywordsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeKeywords indicates an expected call of DescribeKeywords. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeKeywords(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeywords", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeKeywords), arg0) +} + +// DescribeKeywordsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeKeywordsPages(arg0 *pinpointsmsvoicev2.DescribeKeywordsInput, arg1 func(*pinpointsmsvoicev2.DescribeKeywordsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeKeywordsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeKeywordsPages indicates an expected call of DescribeKeywordsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeKeywordsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeywordsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeKeywordsPages), arg0, arg1) +} + +// DescribeKeywordsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeKeywordsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeKeywordsInput, arg2 func(*pinpointsmsvoicev2.DescribeKeywordsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeKeywordsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeKeywordsPagesWithContext indicates an expected call of DescribeKeywordsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeKeywordsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeywordsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeKeywordsPagesWithContext), varargs...) +} + +// DescribeKeywordsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeKeywordsRequest(arg0 *pinpointsmsvoicev2.DescribeKeywordsInput) (*request.Request, *pinpointsmsvoicev2.DescribeKeywordsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeKeywordsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeKeywordsOutput) + return ret0, ret1 +} + +// DescribeKeywordsRequest indicates an expected call of DescribeKeywordsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeKeywordsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeywordsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeKeywordsRequest), arg0) +} + +// DescribeKeywordsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeKeywordsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeKeywordsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeKeywordsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeKeywordsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeKeywordsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeKeywordsWithContext indicates an expected call of DescribeKeywordsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeKeywordsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeywordsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeKeywordsWithContext), varargs...) +} + +// DescribeOptOutLists mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptOutLists(arg0 *pinpointsmsvoicev2.DescribeOptOutListsInput) (*pinpointsmsvoicev2.DescribeOptOutListsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOptOutLists", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeOptOutListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOptOutLists indicates an expected call of DescribeOptOutLists. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptOutLists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptOutLists", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptOutLists), arg0) +} + +// DescribeOptOutListsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptOutListsPages(arg0 *pinpointsmsvoicev2.DescribeOptOutListsInput, arg1 func(*pinpointsmsvoicev2.DescribeOptOutListsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOptOutListsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeOptOutListsPages indicates an expected call of DescribeOptOutListsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptOutListsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptOutListsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptOutListsPages), arg0, arg1) +} + +// DescribeOptOutListsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptOutListsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeOptOutListsInput, arg2 func(*pinpointsmsvoicev2.DescribeOptOutListsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOptOutListsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeOptOutListsPagesWithContext indicates an expected call of DescribeOptOutListsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptOutListsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptOutListsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptOutListsPagesWithContext), varargs...) +} + +// DescribeOptOutListsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptOutListsRequest(arg0 *pinpointsmsvoicev2.DescribeOptOutListsInput) (*request.Request, *pinpointsmsvoicev2.DescribeOptOutListsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOptOutListsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeOptOutListsOutput) + return ret0, ret1 +} + +// DescribeOptOutListsRequest indicates an expected call of DescribeOptOutListsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptOutListsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptOutListsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptOutListsRequest), arg0) +} + +// DescribeOptOutListsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptOutListsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeOptOutListsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeOptOutListsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOptOutListsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeOptOutListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOptOutListsWithContext indicates an expected call of DescribeOptOutListsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptOutListsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptOutListsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptOutListsWithContext), varargs...) +} + +// DescribeOptedOutNumbers mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptedOutNumbers(arg0 *pinpointsmsvoicev2.DescribeOptedOutNumbersInput) (*pinpointsmsvoicev2.DescribeOptedOutNumbersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOptedOutNumbers", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeOptedOutNumbersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOptedOutNumbers indicates an expected call of DescribeOptedOutNumbers. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptedOutNumbers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptedOutNumbers", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptedOutNumbers), arg0) +} + +// DescribeOptedOutNumbersPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptedOutNumbersPages(arg0 *pinpointsmsvoicev2.DescribeOptedOutNumbersInput, arg1 func(*pinpointsmsvoicev2.DescribeOptedOutNumbersOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOptedOutNumbersPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeOptedOutNumbersPages indicates an expected call of DescribeOptedOutNumbersPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptedOutNumbersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptedOutNumbersPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptedOutNumbersPages), arg0, arg1) +} + +// DescribeOptedOutNumbersPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptedOutNumbersPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeOptedOutNumbersInput, arg2 func(*pinpointsmsvoicev2.DescribeOptedOutNumbersOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOptedOutNumbersPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeOptedOutNumbersPagesWithContext indicates an expected call of DescribeOptedOutNumbersPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptedOutNumbersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptedOutNumbersPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptedOutNumbersPagesWithContext), varargs...) +} + +// DescribeOptedOutNumbersRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptedOutNumbersRequest(arg0 *pinpointsmsvoicev2.DescribeOptedOutNumbersInput) (*request.Request, *pinpointsmsvoicev2.DescribeOptedOutNumbersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOptedOutNumbersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeOptedOutNumbersOutput) + return ret0, ret1 +} + +// DescribeOptedOutNumbersRequest indicates an expected call of DescribeOptedOutNumbersRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptedOutNumbersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptedOutNumbersRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptedOutNumbersRequest), arg0) +} + +// DescribeOptedOutNumbersWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeOptedOutNumbersWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeOptedOutNumbersInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeOptedOutNumbersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOptedOutNumbersWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeOptedOutNumbersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOptedOutNumbersWithContext indicates an expected call of DescribeOptedOutNumbersWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeOptedOutNumbersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOptedOutNumbersWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeOptedOutNumbersWithContext), varargs...) +} + +// DescribePhoneNumbers mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePhoneNumbers(arg0 *pinpointsmsvoicev2.DescribePhoneNumbersInput) (*pinpointsmsvoicev2.DescribePhoneNumbersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePhoneNumbers", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribePhoneNumbersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePhoneNumbers indicates an expected call of DescribePhoneNumbers. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePhoneNumbers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePhoneNumbers", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePhoneNumbers), arg0) +} + +// DescribePhoneNumbersPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePhoneNumbersPages(arg0 *pinpointsmsvoicev2.DescribePhoneNumbersInput, arg1 func(*pinpointsmsvoicev2.DescribePhoneNumbersOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePhoneNumbersPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePhoneNumbersPages indicates an expected call of DescribePhoneNumbersPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePhoneNumbersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePhoneNumbersPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePhoneNumbersPages), arg0, arg1) +} + +// DescribePhoneNumbersPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePhoneNumbersPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribePhoneNumbersInput, arg2 func(*pinpointsmsvoicev2.DescribePhoneNumbersOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePhoneNumbersPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePhoneNumbersPagesWithContext indicates an expected call of DescribePhoneNumbersPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePhoneNumbersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePhoneNumbersPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePhoneNumbersPagesWithContext), varargs...) +} + +// DescribePhoneNumbersRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePhoneNumbersRequest(arg0 *pinpointsmsvoicev2.DescribePhoneNumbersInput) (*request.Request, *pinpointsmsvoicev2.DescribePhoneNumbersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePhoneNumbersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribePhoneNumbersOutput) + return ret0, ret1 +} + +// DescribePhoneNumbersRequest indicates an expected call of DescribePhoneNumbersRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePhoneNumbersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePhoneNumbersRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePhoneNumbersRequest), arg0) +} + +// DescribePhoneNumbersWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePhoneNumbersWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribePhoneNumbersInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribePhoneNumbersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePhoneNumbersWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribePhoneNumbersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePhoneNumbersWithContext indicates an expected call of DescribePhoneNumbersWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePhoneNumbersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePhoneNumbersWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePhoneNumbersWithContext), varargs...) +} + +// DescribePools mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePools(arg0 *pinpointsmsvoicev2.DescribePoolsInput) (*pinpointsmsvoicev2.DescribePoolsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePools", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribePoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePools indicates an expected call of DescribePools. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePools(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePools", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePools), arg0) +} + +// DescribePoolsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePoolsPages(arg0 *pinpointsmsvoicev2.DescribePoolsInput, arg1 func(*pinpointsmsvoicev2.DescribePoolsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePoolsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePoolsPages indicates an expected call of DescribePoolsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePoolsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoolsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePoolsPages), arg0, arg1) +} + +// DescribePoolsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePoolsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribePoolsInput, arg2 func(*pinpointsmsvoicev2.DescribePoolsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePoolsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePoolsPagesWithContext indicates an expected call of DescribePoolsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePoolsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoolsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePoolsPagesWithContext), varargs...) +} + +// DescribePoolsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePoolsRequest(arg0 *pinpointsmsvoicev2.DescribePoolsInput) (*request.Request, *pinpointsmsvoicev2.DescribePoolsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePoolsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribePoolsOutput) + return ret0, ret1 +} + +// DescribePoolsRequest indicates an expected call of DescribePoolsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePoolsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoolsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePoolsRequest), arg0) +} + +// DescribePoolsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribePoolsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribePoolsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribePoolsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePoolsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribePoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePoolsWithContext indicates an expected call of DescribePoolsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribePoolsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoolsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribePoolsWithContext), varargs...) +} + +// DescribeProtectConfigurations mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeProtectConfigurations(arg0 *pinpointsmsvoicev2.DescribeProtectConfigurationsInput) (*pinpointsmsvoicev2.DescribeProtectConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeProtectConfigurations", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeProtectConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeProtectConfigurations indicates an expected call of DescribeProtectConfigurations. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeProtectConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectConfigurations", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeProtectConfigurations), arg0) +} + +// DescribeProtectConfigurationsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeProtectConfigurationsPages(arg0 *pinpointsmsvoicev2.DescribeProtectConfigurationsInput, arg1 func(*pinpointsmsvoicev2.DescribeProtectConfigurationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeProtectConfigurationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeProtectConfigurationsPages indicates an expected call of DescribeProtectConfigurationsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeProtectConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectConfigurationsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeProtectConfigurationsPages), arg0, arg1) +} + +// DescribeProtectConfigurationsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeProtectConfigurationsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeProtectConfigurationsInput, arg2 func(*pinpointsmsvoicev2.DescribeProtectConfigurationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeProtectConfigurationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeProtectConfigurationsPagesWithContext indicates an expected call of DescribeProtectConfigurationsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeProtectConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectConfigurationsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeProtectConfigurationsPagesWithContext), varargs...) +} + +// DescribeProtectConfigurationsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeProtectConfigurationsRequest(arg0 *pinpointsmsvoicev2.DescribeProtectConfigurationsInput) (*request.Request, *pinpointsmsvoicev2.DescribeProtectConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeProtectConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeProtectConfigurationsOutput) + return ret0, ret1 +} + +// DescribeProtectConfigurationsRequest indicates an expected call of DescribeProtectConfigurationsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeProtectConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectConfigurationsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeProtectConfigurationsRequest), arg0) +} + +// DescribeProtectConfigurationsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeProtectConfigurationsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeProtectConfigurationsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeProtectConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeProtectConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeProtectConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeProtectConfigurationsWithContext indicates an expected call of DescribeProtectConfigurationsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeProtectConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectConfigurationsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeProtectConfigurationsWithContext), varargs...) +} + +// DescribeRegistrationAttachments mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationAttachments(arg0 *pinpointsmsvoicev2.DescribeRegistrationAttachmentsInput) (*pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationAttachments", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationAttachments indicates an expected call of DescribeRegistrationAttachments. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationAttachments(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationAttachments", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationAttachments), arg0) +} + +// DescribeRegistrationAttachmentsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationAttachmentsPages(arg0 *pinpointsmsvoicev2.DescribeRegistrationAttachmentsInput, arg1 func(*pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationAttachmentsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationAttachmentsPages indicates an expected call of DescribeRegistrationAttachmentsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationAttachmentsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationAttachmentsPages), arg0, arg1) +} + +// DescribeRegistrationAttachmentsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationAttachmentsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationAttachmentsInput, arg2 func(*pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationAttachmentsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationAttachmentsPagesWithContext indicates an expected call of DescribeRegistrationAttachmentsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationAttachmentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationAttachmentsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationAttachmentsPagesWithContext), varargs...) +} + +// DescribeRegistrationAttachmentsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationAttachmentsRequest(arg0 *pinpointsmsvoicev2.DescribeRegistrationAttachmentsInput) (*request.Request, *pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationAttachmentsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput) + return ret0, ret1 +} + +// DescribeRegistrationAttachmentsRequest indicates an expected call of DescribeRegistrationAttachmentsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationAttachmentsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationAttachmentsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationAttachmentsRequest), arg0) +} + +// DescribeRegistrationAttachmentsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationAttachmentsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationAttachmentsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationAttachmentsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationAttachmentsWithContext indicates an expected call of DescribeRegistrationAttachmentsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationAttachmentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationAttachmentsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationAttachmentsWithContext), varargs...) +} + +// DescribeRegistrationFieldDefinitions mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldDefinitions(arg0 *pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsInput) (*pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationFieldDefinitions", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationFieldDefinitions indicates an expected call of DescribeRegistrationFieldDefinitions. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldDefinitions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldDefinitions", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldDefinitions), arg0) +} + +// DescribeRegistrationFieldDefinitionsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldDefinitionsPages(arg0 *pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsInput, arg1 func(*pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationFieldDefinitionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationFieldDefinitionsPages indicates an expected call of DescribeRegistrationFieldDefinitionsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldDefinitionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldDefinitionsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldDefinitionsPages), arg0, arg1) +} + +// DescribeRegistrationFieldDefinitionsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldDefinitionsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsInput, arg2 func(*pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationFieldDefinitionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationFieldDefinitionsPagesWithContext indicates an expected call of DescribeRegistrationFieldDefinitionsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldDefinitionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldDefinitionsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldDefinitionsPagesWithContext), varargs...) +} + +// DescribeRegistrationFieldDefinitionsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldDefinitionsRequest(arg0 *pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsInput) (*request.Request, *pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationFieldDefinitionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput) + return ret0, ret1 +} + +// DescribeRegistrationFieldDefinitionsRequest indicates an expected call of DescribeRegistrationFieldDefinitionsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldDefinitionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldDefinitionsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldDefinitionsRequest), arg0) +} + +// DescribeRegistrationFieldDefinitionsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldDefinitionsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationFieldDefinitionsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationFieldDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationFieldDefinitionsWithContext indicates an expected call of DescribeRegistrationFieldDefinitionsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldDefinitionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldDefinitionsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldDefinitionsWithContext), varargs...) +} + +// DescribeRegistrationFieldValues mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldValues(arg0 *pinpointsmsvoicev2.DescribeRegistrationFieldValuesInput) (*pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationFieldValues", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationFieldValues indicates an expected call of DescribeRegistrationFieldValues. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldValues(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldValues", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldValues), arg0) +} + +// DescribeRegistrationFieldValuesPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldValuesPages(arg0 *pinpointsmsvoicev2.DescribeRegistrationFieldValuesInput, arg1 func(*pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationFieldValuesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationFieldValuesPages indicates an expected call of DescribeRegistrationFieldValuesPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldValuesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldValuesPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldValuesPages), arg0, arg1) +} + +// DescribeRegistrationFieldValuesPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldValuesPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationFieldValuesInput, arg2 func(*pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationFieldValuesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationFieldValuesPagesWithContext indicates an expected call of DescribeRegistrationFieldValuesPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldValuesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldValuesPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldValuesPagesWithContext), varargs...) +} + +// DescribeRegistrationFieldValuesRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldValuesRequest(arg0 *pinpointsmsvoicev2.DescribeRegistrationFieldValuesInput) (*request.Request, *pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationFieldValuesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput) + return ret0, ret1 +} + +// DescribeRegistrationFieldValuesRequest indicates an expected call of DescribeRegistrationFieldValuesRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldValuesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldValuesRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldValuesRequest), arg0) +} + +// DescribeRegistrationFieldValuesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationFieldValuesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationFieldValuesInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationFieldValuesWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationFieldValuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationFieldValuesWithContext indicates an expected call of DescribeRegistrationFieldValuesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationFieldValuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationFieldValuesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationFieldValuesWithContext), varargs...) +} + +// DescribeRegistrationSectionDefinitions mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationSectionDefinitions(arg0 *pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsInput) (*pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationSectionDefinitions", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationSectionDefinitions indicates an expected call of DescribeRegistrationSectionDefinitions. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationSectionDefinitions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationSectionDefinitions", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationSectionDefinitions), arg0) +} + +// DescribeRegistrationSectionDefinitionsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationSectionDefinitionsPages(arg0 *pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsInput, arg1 func(*pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationSectionDefinitionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationSectionDefinitionsPages indicates an expected call of DescribeRegistrationSectionDefinitionsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationSectionDefinitionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationSectionDefinitionsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationSectionDefinitionsPages), arg0, arg1) +} + +// DescribeRegistrationSectionDefinitionsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationSectionDefinitionsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsInput, arg2 func(*pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationSectionDefinitionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationSectionDefinitionsPagesWithContext indicates an expected call of DescribeRegistrationSectionDefinitionsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationSectionDefinitionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationSectionDefinitionsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationSectionDefinitionsPagesWithContext), varargs...) +} + +// DescribeRegistrationSectionDefinitionsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationSectionDefinitionsRequest(arg0 *pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsInput) (*request.Request, *pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationSectionDefinitionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput) + return ret0, ret1 +} + +// DescribeRegistrationSectionDefinitionsRequest indicates an expected call of DescribeRegistrationSectionDefinitionsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationSectionDefinitionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationSectionDefinitionsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationSectionDefinitionsRequest), arg0) +} + +// DescribeRegistrationSectionDefinitionsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationSectionDefinitionsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationSectionDefinitionsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationSectionDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationSectionDefinitionsWithContext indicates an expected call of DescribeRegistrationSectionDefinitionsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationSectionDefinitionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationSectionDefinitionsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationSectionDefinitionsWithContext), varargs...) +} + +// DescribeRegistrationTypeDefinitions mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationTypeDefinitions(arg0 *pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsInput) (*pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationTypeDefinitions", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationTypeDefinitions indicates an expected call of DescribeRegistrationTypeDefinitions. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationTypeDefinitions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationTypeDefinitions", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationTypeDefinitions), arg0) +} + +// DescribeRegistrationTypeDefinitionsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationTypeDefinitionsPages(arg0 *pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsInput, arg1 func(*pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationTypeDefinitionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationTypeDefinitionsPages indicates an expected call of DescribeRegistrationTypeDefinitionsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationTypeDefinitionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationTypeDefinitionsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationTypeDefinitionsPages), arg0, arg1) +} + +// DescribeRegistrationTypeDefinitionsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationTypeDefinitionsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsInput, arg2 func(*pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationTypeDefinitionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationTypeDefinitionsPagesWithContext indicates an expected call of DescribeRegistrationTypeDefinitionsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationTypeDefinitionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationTypeDefinitionsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationTypeDefinitionsPagesWithContext), varargs...) +} + +// DescribeRegistrationTypeDefinitionsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationTypeDefinitionsRequest(arg0 *pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsInput) (*request.Request, *pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationTypeDefinitionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput) + return ret0, ret1 +} + +// DescribeRegistrationTypeDefinitionsRequest indicates an expected call of DescribeRegistrationTypeDefinitionsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationTypeDefinitionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationTypeDefinitionsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationTypeDefinitionsRequest), arg0) +} + +// DescribeRegistrationTypeDefinitionsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationTypeDefinitionsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationTypeDefinitionsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationTypeDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationTypeDefinitionsWithContext indicates an expected call of DescribeRegistrationTypeDefinitionsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationTypeDefinitionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationTypeDefinitionsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationTypeDefinitionsWithContext), varargs...) +} + +// DescribeRegistrationVersions mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationVersions(arg0 *pinpointsmsvoicev2.DescribeRegistrationVersionsInput) (*pinpointsmsvoicev2.DescribeRegistrationVersionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationVersions", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationVersions indicates an expected call of DescribeRegistrationVersions. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationVersions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationVersions", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationVersions), arg0) +} + +// DescribeRegistrationVersionsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationVersionsPages(arg0 *pinpointsmsvoicev2.DescribeRegistrationVersionsInput, arg1 func(*pinpointsmsvoicev2.DescribeRegistrationVersionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationVersionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationVersionsPages indicates an expected call of DescribeRegistrationVersionsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationVersionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationVersionsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationVersionsPages), arg0, arg1) +} + +// DescribeRegistrationVersionsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationVersionsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationVersionsInput, arg2 func(*pinpointsmsvoicev2.DescribeRegistrationVersionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationVersionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationVersionsPagesWithContext indicates an expected call of DescribeRegistrationVersionsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationVersionsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationVersionsPagesWithContext), varargs...) +} + +// DescribeRegistrationVersionsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationVersionsRequest(arg0 *pinpointsmsvoicev2.DescribeRegistrationVersionsInput) (*request.Request, *pinpointsmsvoicev2.DescribeRegistrationVersionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationVersionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeRegistrationVersionsOutput) + return ret0, ret1 +} + +// DescribeRegistrationVersionsRequest indicates an expected call of DescribeRegistrationVersionsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationVersionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationVersionsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationVersionsRequest), arg0) +} + +// DescribeRegistrationVersionsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationVersionsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationVersionsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeRegistrationVersionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationVersionsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationVersionsWithContext indicates an expected call of DescribeRegistrationVersionsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationVersionsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationVersionsWithContext), varargs...) +} + +// DescribeRegistrations mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrations(arg0 *pinpointsmsvoicev2.DescribeRegistrationsInput) (*pinpointsmsvoicev2.DescribeRegistrationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrations", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrations indicates an expected call of DescribeRegistrations. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrations", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrations), arg0) +} + +// DescribeRegistrationsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationsPages(arg0 *pinpointsmsvoicev2.DescribeRegistrationsInput, arg1 func(*pinpointsmsvoicev2.DescribeRegistrationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationsPages indicates an expected call of DescribeRegistrationsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationsPages), arg0, arg1) +} + +// DescribeRegistrationsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationsInput, arg2 func(*pinpointsmsvoicev2.DescribeRegistrationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRegistrationsPagesWithContext indicates an expected call of DescribeRegistrationsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationsPagesWithContext), varargs...) +} + +// DescribeRegistrationsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationsRequest(arg0 *pinpointsmsvoicev2.DescribeRegistrationsInput) (*request.Request, *pinpointsmsvoicev2.DescribeRegistrationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegistrationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeRegistrationsOutput) + return ret0, ret1 +} + +// DescribeRegistrationsRequest indicates an expected call of DescribeRegistrationsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationsRequest), arg0) +} + +// DescribeRegistrationsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeRegistrationsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeRegistrationsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeRegistrationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegistrationsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeRegistrationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegistrationsWithContext indicates an expected call of DescribeRegistrationsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeRegistrationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegistrationsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeRegistrationsWithContext), varargs...) +} + +// DescribeSenderIds mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSenderIds(arg0 *pinpointsmsvoicev2.DescribeSenderIdsInput) (*pinpointsmsvoicev2.DescribeSenderIdsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSenderIds", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeSenderIdsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSenderIds indicates an expected call of DescribeSenderIds. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSenderIds(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSenderIds", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSenderIds), arg0) +} + +// DescribeSenderIdsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSenderIdsPages(arg0 *pinpointsmsvoicev2.DescribeSenderIdsInput, arg1 func(*pinpointsmsvoicev2.DescribeSenderIdsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSenderIdsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSenderIdsPages indicates an expected call of DescribeSenderIdsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSenderIdsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSenderIdsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSenderIdsPages), arg0, arg1) +} + +// DescribeSenderIdsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSenderIdsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeSenderIdsInput, arg2 func(*pinpointsmsvoicev2.DescribeSenderIdsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSenderIdsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSenderIdsPagesWithContext indicates an expected call of DescribeSenderIdsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSenderIdsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSenderIdsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSenderIdsPagesWithContext), varargs...) +} + +// DescribeSenderIdsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSenderIdsRequest(arg0 *pinpointsmsvoicev2.DescribeSenderIdsInput) (*request.Request, *pinpointsmsvoicev2.DescribeSenderIdsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSenderIdsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeSenderIdsOutput) + return ret0, ret1 +} + +// DescribeSenderIdsRequest indicates an expected call of DescribeSenderIdsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSenderIdsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSenderIdsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSenderIdsRequest), arg0) +} + +// DescribeSenderIdsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSenderIdsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeSenderIdsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeSenderIdsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSenderIdsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeSenderIdsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSenderIdsWithContext indicates an expected call of DescribeSenderIdsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSenderIdsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSenderIdsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSenderIdsWithContext), varargs...) +} + +// DescribeSpendLimits mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSpendLimits(arg0 *pinpointsmsvoicev2.DescribeSpendLimitsInput) (*pinpointsmsvoicev2.DescribeSpendLimitsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpendLimits", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeSpendLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpendLimits indicates an expected call of DescribeSpendLimits. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSpendLimits(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpendLimits", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSpendLimits), arg0) +} + +// DescribeSpendLimitsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSpendLimitsPages(arg0 *pinpointsmsvoicev2.DescribeSpendLimitsInput, arg1 func(*pinpointsmsvoicev2.DescribeSpendLimitsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpendLimitsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpendLimitsPages indicates an expected call of DescribeSpendLimitsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSpendLimitsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpendLimitsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSpendLimitsPages), arg0, arg1) +} + +// DescribeSpendLimitsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSpendLimitsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeSpendLimitsInput, arg2 func(*pinpointsmsvoicev2.DescribeSpendLimitsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpendLimitsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpendLimitsPagesWithContext indicates an expected call of DescribeSpendLimitsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSpendLimitsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpendLimitsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSpendLimitsPagesWithContext), varargs...) +} + +// DescribeSpendLimitsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSpendLimitsRequest(arg0 *pinpointsmsvoicev2.DescribeSpendLimitsInput) (*request.Request, *pinpointsmsvoicev2.DescribeSpendLimitsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpendLimitsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeSpendLimitsOutput) + return ret0, ret1 +} + +// DescribeSpendLimitsRequest indicates an expected call of DescribeSpendLimitsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSpendLimitsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpendLimitsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSpendLimitsRequest), arg0) +} + +// DescribeSpendLimitsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeSpendLimitsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeSpendLimitsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeSpendLimitsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpendLimitsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeSpendLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpendLimitsWithContext indicates an expected call of DescribeSpendLimitsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeSpendLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpendLimitsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeSpendLimitsWithContext), varargs...) +} + +// DescribeVerifiedDestinationNumbers mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeVerifiedDestinationNumbers(arg0 *pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersInput) (*pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVerifiedDestinationNumbers", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVerifiedDestinationNumbers indicates an expected call of DescribeVerifiedDestinationNumbers. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeVerifiedDestinationNumbers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedDestinationNumbers", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeVerifiedDestinationNumbers), arg0) +} + +// DescribeVerifiedDestinationNumbersPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeVerifiedDestinationNumbersPages(arg0 *pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersInput, arg1 func(*pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVerifiedDestinationNumbersPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVerifiedDestinationNumbersPages indicates an expected call of DescribeVerifiedDestinationNumbersPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeVerifiedDestinationNumbersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedDestinationNumbersPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeVerifiedDestinationNumbersPages), arg0, arg1) +} + +// DescribeVerifiedDestinationNumbersPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeVerifiedDestinationNumbersPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersInput, arg2 func(*pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVerifiedDestinationNumbersPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVerifiedDestinationNumbersPagesWithContext indicates an expected call of DescribeVerifiedDestinationNumbersPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeVerifiedDestinationNumbersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedDestinationNumbersPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeVerifiedDestinationNumbersPagesWithContext), varargs...) +} + +// DescribeVerifiedDestinationNumbersRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeVerifiedDestinationNumbersRequest(arg0 *pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersInput) (*request.Request, *pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVerifiedDestinationNumbersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput) + return ret0, ret1 +} + +// DescribeVerifiedDestinationNumbersRequest indicates an expected call of DescribeVerifiedDestinationNumbersRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeVerifiedDestinationNumbersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedDestinationNumbersRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeVerifiedDestinationNumbersRequest), arg0) +} + +// DescribeVerifiedDestinationNumbersWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DescribeVerifiedDestinationNumbersWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVerifiedDestinationNumbersWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DescribeVerifiedDestinationNumbersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVerifiedDestinationNumbersWithContext indicates an expected call of DescribeVerifiedDestinationNumbersWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DescribeVerifiedDestinationNumbersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedDestinationNumbersWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DescribeVerifiedDestinationNumbersWithContext), varargs...) +} + +// DisassociateOriginationIdentity mocks base method. +func (m *MockPinpointSMSVoiceV2API) DisassociateOriginationIdentity(arg0 *pinpointsmsvoicev2.DisassociateOriginationIdentityInput) (*pinpointsmsvoicev2.DisassociateOriginationIdentityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateOriginationIdentity", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DisassociateOriginationIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateOriginationIdentity indicates an expected call of DisassociateOriginationIdentity. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DisassociateOriginationIdentity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateOriginationIdentity", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DisassociateOriginationIdentity), arg0) +} + +// DisassociateOriginationIdentityRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DisassociateOriginationIdentityRequest(arg0 *pinpointsmsvoicev2.DisassociateOriginationIdentityInput) (*request.Request, *pinpointsmsvoicev2.DisassociateOriginationIdentityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateOriginationIdentityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DisassociateOriginationIdentityOutput) + return ret0, ret1 +} + +// DisassociateOriginationIdentityRequest indicates an expected call of DisassociateOriginationIdentityRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DisassociateOriginationIdentityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateOriginationIdentityRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DisassociateOriginationIdentityRequest), arg0) +} + +// DisassociateOriginationIdentityWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DisassociateOriginationIdentityWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DisassociateOriginationIdentityInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DisassociateOriginationIdentityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateOriginationIdentityWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DisassociateOriginationIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateOriginationIdentityWithContext indicates an expected call of DisassociateOriginationIdentityWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DisassociateOriginationIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateOriginationIdentityWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DisassociateOriginationIdentityWithContext), varargs...) +} + +// DisassociateProtectConfiguration mocks base method. +func (m *MockPinpointSMSVoiceV2API) DisassociateProtectConfiguration(arg0 *pinpointsmsvoicev2.DisassociateProtectConfigurationInput) (*pinpointsmsvoicev2.DisassociateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateProtectConfiguration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DisassociateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateProtectConfiguration indicates an expected call of DisassociateProtectConfiguration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DisassociateProtectConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateProtectConfiguration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DisassociateProtectConfiguration), arg0) +} + +// DisassociateProtectConfigurationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DisassociateProtectConfigurationRequest(arg0 *pinpointsmsvoicev2.DisassociateProtectConfigurationInput) (*request.Request, *pinpointsmsvoicev2.DisassociateProtectConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateProtectConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DisassociateProtectConfigurationOutput) + return ret0, ret1 +} + +// DisassociateProtectConfigurationRequest indicates an expected call of DisassociateProtectConfigurationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DisassociateProtectConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateProtectConfigurationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DisassociateProtectConfigurationRequest), arg0) +} + +// DisassociateProtectConfigurationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DisassociateProtectConfigurationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DisassociateProtectConfigurationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DisassociateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateProtectConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DisassociateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateProtectConfigurationWithContext indicates an expected call of DisassociateProtectConfigurationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DisassociateProtectConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateProtectConfigurationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DisassociateProtectConfigurationWithContext), varargs...) +} + +// DiscardRegistrationVersion mocks base method. +func (m *MockPinpointSMSVoiceV2API) DiscardRegistrationVersion(arg0 *pinpointsmsvoicev2.DiscardRegistrationVersionInput) (*pinpointsmsvoicev2.DiscardRegistrationVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DiscardRegistrationVersion", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DiscardRegistrationVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DiscardRegistrationVersion indicates an expected call of DiscardRegistrationVersion. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DiscardRegistrationVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscardRegistrationVersion", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DiscardRegistrationVersion), arg0) +} + +// DiscardRegistrationVersionRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) DiscardRegistrationVersionRequest(arg0 *pinpointsmsvoicev2.DiscardRegistrationVersionInput) (*request.Request, *pinpointsmsvoicev2.DiscardRegistrationVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DiscardRegistrationVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.DiscardRegistrationVersionOutput) + return ret0, ret1 +} + +// DiscardRegistrationVersionRequest indicates an expected call of DiscardRegistrationVersionRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DiscardRegistrationVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscardRegistrationVersionRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DiscardRegistrationVersionRequest), arg0) +} + +// DiscardRegistrationVersionWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) DiscardRegistrationVersionWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.DiscardRegistrationVersionInput, arg2 ...request.Option) (*pinpointsmsvoicev2.DiscardRegistrationVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DiscardRegistrationVersionWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.DiscardRegistrationVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DiscardRegistrationVersionWithContext indicates an expected call of DiscardRegistrationVersionWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) DiscardRegistrationVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscardRegistrationVersionWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).DiscardRegistrationVersionWithContext), varargs...) +} + +// GetProtectConfigurationCountryRuleSet mocks base method. +func (m *MockPinpointSMSVoiceV2API) GetProtectConfigurationCountryRuleSet(arg0 *pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetInput) (*pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProtectConfigurationCountryRuleSet", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProtectConfigurationCountryRuleSet indicates an expected call of GetProtectConfigurationCountryRuleSet. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) GetProtectConfigurationCountryRuleSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProtectConfigurationCountryRuleSet", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).GetProtectConfigurationCountryRuleSet), arg0) +} + +// GetProtectConfigurationCountryRuleSetRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) GetProtectConfigurationCountryRuleSetRequest(arg0 *pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetInput) (*request.Request, *pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProtectConfigurationCountryRuleSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetOutput) + return ret0, ret1 +} + +// GetProtectConfigurationCountryRuleSetRequest indicates an expected call of GetProtectConfigurationCountryRuleSetRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) GetProtectConfigurationCountryRuleSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProtectConfigurationCountryRuleSetRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).GetProtectConfigurationCountryRuleSetRequest), arg0) +} + +// GetProtectConfigurationCountryRuleSetWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) GetProtectConfigurationCountryRuleSetWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetInput, arg2 ...request.Option) (*pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetProtectConfigurationCountryRuleSetWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.GetProtectConfigurationCountryRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProtectConfigurationCountryRuleSetWithContext indicates an expected call of GetProtectConfigurationCountryRuleSetWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) GetProtectConfigurationCountryRuleSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProtectConfigurationCountryRuleSetWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).GetProtectConfigurationCountryRuleSetWithContext), varargs...) +} + +// ListPoolOriginationIdentities mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListPoolOriginationIdentities(arg0 *pinpointsmsvoicev2.ListPoolOriginationIdentitiesInput) (*pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPoolOriginationIdentities", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPoolOriginationIdentities indicates an expected call of ListPoolOriginationIdentities. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListPoolOriginationIdentities(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoolOriginationIdentities", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListPoolOriginationIdentities), arg0) +} + +// ListPoolOriginationIdentitiesPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListPoolOriginationIdentitiesPages(arg0 *pinpointsmsvoicev2.ListPoolOriginationIdentitiesInput, arg1 func(*pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPoolOriginationIdentitiesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPoolOriginationIdentitiesPages indicates an expected call of ListPoolOriginationIdentitiesPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListPoolOriginationIdentitiesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoolOriginationIdentitiesPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListPoolOriginationIdentitiesPages), arg0, arg1) +} + +// ListPoolOriginationIdentitiesPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListPoolOriginationIdentitiesPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.ListPoolOriginationIdentitiesInput, arg2 func(*pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPoolOriginationIdentitiesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPoolOriginationIdentitiesPagesWithContext indicates an expected call of ListPoolOriginationIdentitiesPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListPoolOriginationIdentitiesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoolOriginationIdentitiesPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListPoolOriginationIdentitiesPagesWithContext), varargs...) +} + +// ListPoolOriginationIdentitiesRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListPoolOriginationIdentitiesRequest(arg0 *pinpointsmsvoicev2.ListPoolOriginationIdentitiesInput) (*request.Request, *pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPoolOriginationIdentitiesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput) + return ret0, ret1 +} + +// ListPoolOriginationIdentitiesRequest indicates an expected call of ListPoolOriginationIdentitiesRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListPoolOriginationIdentitiesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoolOriginationIdentitiesRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListPoolOriginationIdentitiesRequest), arg0) +} + +// ListPoolOriginationIdentitiesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListPoolOriginationIdentitiesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.ListPoolOriginationIdentitiesInput, arg2 ...request.Option) (*pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPoolOriginationIdentitiesWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ListPoolOriginationIdentitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPoolOriginationIdentitiesWithContext indicates an expected call of ListPoolOriginationIdentitiesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListPoolOriginationIdentitiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoolOriginationIdentitiesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListPoolOriginationIdentitiesWithContext), varargs...) +} + +// ListRegistrationAssociations mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListRegistrationAssociations(arg0 *pinpointsmsvoicev2.ListRegistrationAssociationsInput) (*pinpointsmsvoicev2.ListRegistrationAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRegistrationAssociations", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ListRegistrationAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRegistrationAssociations indicates an expected call of ListRegistrationAssociations. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListRegistrationAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegistrationAssociations", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListRegistrationAssociations), arg0) +} + +// ListRegistrationAssociationsPages mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListRegistrationAssociationsPages(arg0 *pinpointsmsvoicev2.ListRegistrationAssociationsInput, arg1 func(*pinpointsmsvoicev2.ListRegistrationAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRegistrationAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRegistrationAssociationsPages indicates an expected call of ListRegistrationAssociationsPages. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListRegistrationAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegistrationAssociationsPages", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListRegistrationAssociationsPages), arg0, arg1) +} + +// ListRegistrationAssociationsPagesWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListRegistrationAssociationsPagesWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.ListRegistrationAssociationsInput, arg2 func(*pinpointsmsvoicev2.ListRegistrationAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRegistrationAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRegistrationAssociationsPagesWithContext indicates an expected call of ListRegistrationAssociationsPagesWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListRegistrationAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegistrationAssociationsPagesWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListRegistrationAssociationsPagesWithContext), varargs...) +} + +// ListRegistrationAssociationsRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListRegistrationAssociationsRequest(arg0 *pinpointsmsvoicev2.ListRegistrationAssociationsInput) (*request.Request, *pinpointsmsvoicev2.ListRegistrationAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRegistrationAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.ListRegistrationAssociationsOutput) + return ret0, ret1 +} + +// ListRegistrationAssociationsRequest indicates an expected call of ListRegistrationAssociationsRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListRegistrationAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegistrationAssociationsRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListRegistrationAssociationsRequest), arg0) +} + +// ListRegistrationAssociationsWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListRegistrationAssociationsWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.ListRegistrationAssociationsInput, arg2 ...request.Option) (*pinpointsmsvoicev2.ListRegistrationAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRegistrationAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ListRegistrationAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRegistrationAssociationsWithContext indicates an expected call of ListRegistrationAssociationsWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListRegistrationAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegistrationAssociationsWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListRegistrationAssociationsWithContext), varargs...) +} + +// ListTagsForResource mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListTagsForResource(arg0 *pinpointsmsvoicev2.ListTagsForResourceInput) (*pinpointsmsvoicev2.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourceRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListTagsForResourceRequest(arg0 *pinpointsmsvoicev2.ListTagsForResourceInput) (*request.Request, *pinpointsmsvoicev2.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.ListTagsForResourceInput, arg2 ...request.Option) (*pinpointsmsvoicev2.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ListTagsForResourceWithContext), varargs...) +} + +// PutKeyword mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutKeyword(arg0 *pinpointsmsvoicev2.PutKeywordInput) (*pinpointsmsvoicev2.PutKeywordOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutKeyword", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.PutKeywordOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutKeyword indicates an expected call of PutKeyword. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutKeyword(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeyword", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutKeyword), arg0) +} + +// PutKeywordRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutKeywordRequest(arg0 *pinpointsmsvoicev2.PutKeywordInput) (*request.Request, *pinpointsmsvoicev2.PutKeywordOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutKeywordRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.PutKeywordOutput) + return ret0, ret1 +} + +// PutKeywordRequest indicates an expected call of PutKeywordRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutKeywordRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeywordRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutKeywordRequest), arg0) +} + +// PutKeywordWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutKeywordWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.PutKeywordInput, arg2 ...request.Option) (*pinpointsmsvoicev2.PutKeywordOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutKeywordWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.PutKeywordOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutKeywordWithContext indicates an expected call of PutKeywordWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutKeywordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeywordWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutKeywordWithContext), varargs...) +} + +// PutOptedOutNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutOptedOutNumber(arg0 *pinpointsmsvoicev2.PutOptedOutNumberInput) (*pinpointsmsvoicev2.PutOptedOutNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutOptedOutNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.PutOptedOutNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutOptedOutNumber indicates an expected call of PutOptedOutNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutOptedOutNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOptedOutNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutOptedOutNumber), arg0) +} + +// PutOptedOutNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutOptedOutNumberRequest(arg0 *pinpointsmsvoicev2.PutOptedOutNumberInput) (*request.Request, *pinpointsmsvoicev2.PutOptedOutNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutOptedOutNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.PutOptedOutNumberOutput) + return ret0, ret1 +} + +// PutOptedOutNumberRequest indicates an expected call of PutOptedOutNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutOptedOutNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOptedOutNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutOptedOutNumberRequest), arg0) +} + +// PutOptedOutNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutOptedOutNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.PutOptedOutNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.PutOptedOutNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutOptedOutNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.PutOptedOutNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutOptedOutNumberWithContext indicates an expected call of PutOptedOutNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutOptedOutNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOptedOutNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutOptedOutNumberWithContext), varargs...) +} + +// PutRegistrationFieldValue mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutRegistrationFieldValue(arg0 *pinpointsmsvoicev2.PutRegistrationFieldValueInput) (*pinpointsmsvoicev2.PutRegistrationFieldValueOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRegistrationFieldValue", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.PutRegistrationFieldValueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRegistrationFieldValue indicates an expected call of PutRegistrationFieldValue. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutRegistrationFieldValue(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRegistrationFieldValue", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutRegistrationFieldValue), arg0) +} + +// PutRegistrationFieldValueRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutRegistrationFieldValueRequest(arg0 *pinpointsmsvoicev2.PutRegistrationFieldValueInput) (*request.Request, *pinpointsmsvoicev2.PutRegistrationFieldValueOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRegistrationFieldValueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.PutRegistrationFieldValueOutput) + return ret0, ret1 +} + +// PutRegistrationFieldValueRequest indicates an expected call of PutRegistrationFieldValueRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutRegistrationFieldValueRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRegistrationFieldValueRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutRegistrationFieldValueRequest), arg0) +} + +// PutRegistrationFieldValueWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) PutRegistrationFieldValueWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.PutRegistrationFieldValueInput, arg2 ...request.Option) (*pinpointsmsvoicev2.PutRegistrationFieldValueOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutRegistrationFieldValueWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.PutRegistrationFieldValueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRegistrationFieldValueWithContext indicates an expected call of PutRegistrationFieldValueWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) PutRegistrationFieldValueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRegistrationFieldValueWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).PutRegistrationFieldValueWithContext), varargs...) +} + +// ReleasePhoneNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) ReleasePhoneNumber(arg0 *pinpointsmsvoicev2.ReleasePhoneNumberInput) (*pinpointsmsvoicev2.ReleasePhoneNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleasePhoneNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ReleasePhoneNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleasePhoneNumber indicates an expected call of ReleasePhoneNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ReleasePhoneNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleasePhoneNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ReleasePhoneNumber), arg0) +} + +// ReleasePhoneNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) ReleasePhoneNumberRequest(arg0 *pinpointsmsvoicev2.ReleasePhoneNumberInput) (*request.Request, *pinpointsmsvoicev2.ReleasePhoneNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleasePhoneNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.ReleasePhoneNumberOutput) + return ret0, ret1 +} + +// ReleasePhoneNumberRequest indicates an expected call of ReleasePhoneNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ReleasePhoneNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleasePhoneNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ReleasePhoneNumberRequest), arg0) +} + +// ReleasePhoneNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) ReleasePhoneNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.ReleasePhoneNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.ReleasePhoneNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReleasePhoneNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ReleasePhoneNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleasePhoneNumberWithContext indicates an expected call of ReleasePhoneNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ReleasePhoneNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleasePhoneNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ReleasePhoneNumberWithContext), varargs...) +} + +// ReleaseSenderId mocks base method. +func (m *MockPinpointSMSVoiceV2API) ReleaseSenderId(arg0 *pinpointsmsvoicev2.ReleaseSenderIdInput) (*pinpointsmsvoicev2.ReleaseSenderIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleaseSenderId", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ReleaseSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleaseSenderId indicates an expected call of ReleaseSenderId. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ReleaseSenderId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseSenderId", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ReleaseSenderId), arg0) +} + +// ReleaseSenderIdRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) ReleaseSenderIdRequest(arg0 *pinpointsmsvoicev2.ReleaseSenderIdInput) (*request.Request, *pinpointsmsvoicev2.ReleaseSenderIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleaseSenderIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.ReleaseSenderIdOutput) + return ret0, ret1 +} + +// ReleaseSenderIdRequest indicates an expected call of ReleaseSenderIdRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ReleaseSenderIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseSenderIdRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ReleaseSenderIdRequest), arg0) +} + +// ReleaseSenderIdWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) ReleaseSenderIdWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.ReleaseSenderIdInput, arg2 ...request.Option) (*pinpointsmsvoicev2.ReleaseSenderIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReleaseSenderIdWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.ReleaseSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleaseSenderIdWithContext indicates an expected call of ReleaseSenderIdWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) ReleaseSenderIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseSenderIdWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).ReleaseSenderIdWithContext), varargs...) +} + +// RequestPhoneNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) RequestPhoneNumber(arg0 *pinpointsmsvoicev2.RequestPhoneNumberInput) (*pinpointsmsvoicev2.RequestPhoneNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestPhoneNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.RequestPhoneNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestPhoneNumber indicates an expected call of RequestPhoneNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) RequestPhoneNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestPhoneNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).RequestPhoneNumber), arg0) +} + +// RequestPhoneNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) RequestPhoneNumberRequest(arg0 *pinpointsmsvoicev2.RequestPhoneNumberInput) (*request.Request, *pinpointsmsvoicev2.RequestPhoneNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestPhoneNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.RequestPhoneNumberOutput) + return ret0, ret1 +} + +// RequestPhoneNumberRequest indicates an expected call of RequestPhoneNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) RequestPhoneNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestPhoneNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).RequestPhoneNumberRequest), arg0) +} + +// RequestPhoneNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) RequestPhoneNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.RequestPhoneNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.RequestPhoneNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestPhoneNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.RequestPhoneNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestPhoneNumberWithContext indicates an expected call of RequestPhoneNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) RequestPhoneNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestPhoneNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).RequestPhoneNumberWithContext), varargs...) +} + +// RequestSenderId mocks base method. +func (m *MockPinpointSMSVoiceV2API) RequestSenderId(arg0 *pinpointsmsvoicev2.RequestSenderIdInput) (*pinpointsmsvoicev2.RequestSenderIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestSenderId", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.RequestSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSenderId indicates an expected call of RequestSenderId. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) RequestSenderId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSenderId", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).RequestSenderId), arg0) +} + +// RequestSenderIdRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) RequestSenderIdRequest(arg0 *pinpointsmsvoicev2.RequestSenderIdInput) (*request.Request, *pinpointsmsvoicev2.RequestSenderIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestSenderIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.RequestSenderIdOutput) + return ret0, ret1 +} + +// RequestSenderIdRequest indicates an expected call of RequestSenderIdRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) RequestSenderIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSenderIdRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).RequestSenderIdRequest), arg0) +} + +// RequestSenderIdWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) RequestSenderIdWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.RequestSenderIdInput, arg2 ...request.Option) (*pinpointsmsvoicev2.RequestSenderIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestSenderIdWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.RequestSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSenderIdWithContext indicates an expected call of RequestSenderIdWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) RequestSenderIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSenderIdWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).RequestSenderIdWithContext), varargs...) +} + +// SendDestinationNumberVerificationCode mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendDestinationNumberVerificationCode(arg0 *pinpointsmsvoicev2.SendDestinationNumberVerificationCodeInput) (*pinpointsmsvoicev2.SendDestinationNumberVerificationCodeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendDestinationNumberVerificationCode", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendDestinationNumberVerificationCodeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendDestinationNumberVerificationCode indicates an expected call of SendDestinationNumberVerificationCode. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendDestinationNumberVerificationCode(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDestinationNumberVerificationCode", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendDestinationNumberVerificationCode), arg0) +} + +// SendDestinationNumberVerificationCodeRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendDestinationNumberVerificationCodeRequest(arg0 *pinpointsmsvoicev2.SendDestinationNumberVerificationCodeInput) (*request.Request, *pinpointsmsvoicev2.SendDestinationNumberVerificationCodeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendDestinationNumberVerificationCodeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SendDestinationNumberVerificationCodeOutput) + return ret0, ret1 +} + +// SendDestinationNumberVerificationCodeRequest indicates an expected call of SendDestinationNumberVerificationCodeRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendDestinationNumberVerificationCodeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDestinationNumberVerificationCodeRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendDestinationNumberVerificationCodeRequest), arg0) +} + +// SendDestinationNumberVerificationCodeWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendDestinationNumberVerificationCodeWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SendDestinationNumberVerificationCodeInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SendDestinationNumberVerificationCodeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendDestinationNumberVerificationCodeWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendDestinationNumberVerificationCodeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendDestinationNumberVerificationCodeWithContext indicates an expected call of SendDestinationNumberVerificationCodeWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendDestinationNumberVerificationCodeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDestinationNumberVerificationCodeWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendDestinationNumberVerificationCodeWithContext), varargs...) +} + +// SendMediaMessage mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendMediaMessage(arg0 *pinpointsmsvoicev2.SendMediaMessageInput) (*pinpointsmsvoicev2.SendMediaMessageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendMediaMessage", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendMediaMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMediaMessage indicates an expected call of SendMediaMessage. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendMediaMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMediaMessage", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendMediaMessage), arg0) +} + +// SendMediaMessageRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendMediaMessageRequest(arg0 *pinpointsmsvoicev2.SendMediaMessageInput) (*request.Request, *pinpointsmsvoicev2.SendMediaMessageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendMediaMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SendMediaMessageOutput) + return ret0, ret1 +} + +// SendMediaMessageRequest indicates an expected call of SendMediaMessageRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendMediaMessageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMediaMessageRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendMediaMessageRequest), arg0) +} + +// SendMediaMessageWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendMediaMessageWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SendMediaMessageInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SendMediaMessageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendMediaMessageWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendMediaMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendMediaMessageWithContext indicates an expected call of SendMediaMessageWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendMediaMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMediaMessageWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendMediaMessageWithContext), varargs...) +} + +// SendTextMessage mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendTextMessage(arg0 *pinpointsmsvoicev2.SendTextMessageInput) (*pinpointsmsvoicev2.SendTextMessageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendTextMessage", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendTextMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendTextMessage indicates an expected call of SendTextMessage. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendTextMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTextMessage", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendTextMessage), arg0) +} + +// SendTextMessageRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendTextMessageRequest(arg0 *pinpointsmsvoicev2.SendTextMessageInput) (*request.Request, *pinpointsmsvoicev2.SendTextMessageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendTextMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SendTextMessageOutput) + return ret0, ret1 +} + +// SendTextMessageRequest indicates an expected call of SendTextMessageRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendTextMessageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTextMessageRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendTextMessageRequest), arg0) +} + +// SendTextMessageWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendTextMessageWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SendTextMessageInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SendTextMessageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendTextMessageWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendTextMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendTextMessageWithContext indicates an expected call of SendTextMessageWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendTextMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTextMessageWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendTextMessageWithContext), varargs...) +} + +// SendVoiceMessage mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendVoiceMessage(arg0 *pinpointsmsvoicev2.SendVoiceMessageInput) (*pinpointsmsvoicev2.SendVoiceMessageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendVoiceMessage", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendVoiceMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendVoiceMessage indicates an expected call of SendVoiceMessage. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendVoiceMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendVoiceMessage", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendVoiceMessage), arg0) +} + +// SendVoiceMessageRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendVoiceMessageRequest(arg0 *pinpointsmsvoicev2.SendVoiceMessageInput) (*request.Request, *pinpointsmsvoicev2.SendVoiceMessageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendVoiceMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SendVoiceMessageOutput) + return ret0, ret1 +} + +// SendVoiceMessageRequest indicates an expected call of SendVoiceMessageRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendVoiceMessageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendVoiceMessageRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendVoiceMessageRequest), arg0) +} + +// SendVoiceMessageWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SendVoiceMessageWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SendVoiceMessageInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SendVoiceMessageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendVoiceMessageWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SendVoiceMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendVoiceMessageWithContext indicates an expected call of SendVoiceMessageWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SendVoiceMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendVoiceMessageWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SendVoiceMessageWithContext), varargs...) +} + +// SetAccountDefaultProtectConfiguration mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetAccountDefaultProtectConfiguration(arg0 *pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationInput) (*pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAccountDefaultProtectConfiguration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetAccountDefaultProtectConfiguration indicates an expected call of SetAccountDefaultProtectConfiguration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetAccountDefaultProtectConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccountDefaultProtectConfiguration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetAccountDefaultProtectConfiguration), arg0) +} + +// SetAccountDefaultProtectConfigurationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetAccountDefaultProtectConfigurationRequest(arg0 *pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationInput) (*request.Request, *pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAccountDefaultProtectConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationOutput) + return ret0, ret1 +} + +// SetAccountDefaultProtectConfigurationRequest indicates an expected call of SetAccountDefaultProtectConfigurationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetAccountDefaultProtectConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccountDefaultProtectConfigurationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetAccountDefaultProtectConfigurationRequest), arg0) +} + +// SetAccountDefaultProtectConfigurationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetAccountDefaultProtectConfigurationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetAccountDefaultProtectConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetAccountDefaultProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetAccountDefaultProtectConfigurationWithContext indicates an expected call of SetAccountDefaultProtectConfigurationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetAccountDefaultProtectConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccountDefaultProtectConfigurationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetAccountDefaultProtectConfigurationWithContext), varargs...) +} + +// SetDefaultMessageType mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetDefaultMessageType(arg0 *pinpointsmsvoicev2.SetDefaultMessageTypeInput) (*pinpointsmsvoicev2.SetDefaultMessageTypeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDefaultMessageType", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetDefaultMessageTypeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDefaultMessageType indicates an expected call of SetDefaultMessageType. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetDefaultMessageType(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultMessageType", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetDefaultMessageType), arg0) +} + +// SetDefaultMessageTypeRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetDefaultMessageTypeRequest(arg0 *pinpointsmsvoicev2.SetDefaultMessageTypeInput) (*request.Request, *pinpointsmsvoicev2.SetDefaultMessageTypeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDefaultMessageTypeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SetDefaultMessageTypeOutput) + return ret0, ret1 +} + +// SetDefaultMessageTypeRequest indicates an expected call of SetDefaultMessageTypeRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetDefaultMessageTypeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultMessageTypeRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetDefaultMessageTypeRequest), arg0) +} + +// SetDefaultMessageTypeWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetDefaultMessageTypeWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SetDefaultMessageTypeInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SetDefaultMessageTypeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetDefaultMessageTypeWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetDefaultMessageTypeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDefaultMessageTypeWithContext indicates an expected call of SetDefaultMessageTypeWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetDefaultMessageTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultMessageTypeWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetDefaultMessageTypeWithContext), varargs...) +} + +// SetDefaultSenderId mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetDefaultSenderId(arg0 *pinpointsmsvoicev2.SetDefaultSenderIdInput) (*pinpointsmsvoicev2.SetDefaultSenderIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDefaultSenderId", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetDefaultSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDefaultSenderId indicates an expected call of SetDefaultSenderId. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetDefaultSenderId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultSenderId", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetDefaultSenderId), arg0) +} + +// SetDefaultSenderIdRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetDefaultSenderIdRequest(arg0 *pinpointsmsvoicev2.SetDefaultSenderIdInput) (*request.Request, *pinpointsmsvoicev2.SetDefaultSenderIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDefaultSenderIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SetDefaultSenderIdOutput) + return ret0, ret1 +} + +// SetDefaultSenderIdRequest indicates an expected call of SetDefaultSenderIdRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetDefaultSenderIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultSenderIdRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetDefaultSenderIdRequest), arg0) +} + +// SetDefaultSenderIdWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetDefaultSenderIdWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SetDefaultSenderIdInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SetDefaultSenderIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetDefaultSenderIdWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetDefaultSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDefaultSenderIdWithContext indicates an expected call of SetDefaultSenderIdWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetDefaultSenderIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultSenderIdWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetDefaultSenderIdWithContext), varargs...) +} + +// SetMediaMessageSpendLimitOverride mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetMediaMessageSpendLimitOverride(arg0 *pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideInput) (*pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMediaMessageSpendLimitOverride", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetMediaMessageSpendLimitOverride indicates an expected call of SetMediaMessageSpendLimitOverride. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetMediaMessageSpendLimitOverride(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMediaMessageSpendLimitOverride", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetMediaMessageSpendLimitOverride), arg0) +} + +// SetMediaMessageSpendLimitOverrideRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetMediaMessageSpendLimitOverrideRequest(arg0 *pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideInput) (*request.Request, *pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMediaMessageSpendLimitOverrideRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideOutput) + return ret0, ret1 +} + +// SetMediaMessageSpendLimitOverrideRequest indicates an expected call of SetMediaMessageSpendLimitOverrideRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetMediaMessageSpendLimitOverrideRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMediaMessageSpendLimitOverrideRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetMediaMessageSpendLimitOverrideRequest), arg0) +} + +// SetMediaMessageSpendLimitOverrideWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetMediaMessageSpendLimitOverrideWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetMediaMessageSpendLimitOverrideWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetMediaMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetMediaMessageSpendLimitOverrideWithContext indicates an expected call of SetMediaMessageSpendLimitOverrideWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetMediaMessageSpendLimitOverrideWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMediaMessageSpendLimitOverrideWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetMediaMessageSpendLimitOverrideWithContext), varargs...) +} + +// SetTextMessageSpendLimitOverride mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetTextMessageSpendLimitOverride(arg0 *pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideInput) (*pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetTextMessageSpendLimitOverride", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetTextMessageSpendLimitOverride indicates an expected call of SetTextMessageSpendLimitOverride. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetTextMessageSpendLimitOverride(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTextMessageSpendLimitOverride", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetTextMessageSpendLimitOverride), arg0) +} + +// SetTextMessageSpendLimitOverrideRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetTextMessageSpendLimitOverrideRequest(arg0 *pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideInput) (*request.Request, *pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetTextMessageSpendLimitOverrideRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideOutput) + return ret0, ret1 +} + +// SetTextMessageSpendLimitOverrideRequest indicates an expected call of SetTextMessageSpendLimitOverrideRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetTextMessageSpendLimitOverrideRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTextMessageSpendLimitOverrideRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetTextMessageSpendLimitOverrideRequest), arg0) +} + +// SetTextMessageSpendLimitOverrideWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetTextMessageSpendLimitOverrideWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetTextMessageSpendLimitOverrideWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetTextMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetTextMessageSpendLimitOverrideWithContext indicates an expected call of SetTextMessageSpendLimitOverrideWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetTextMessageSpendLimitOverrideWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTextMessageSpendLimitOverrideWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetTextMessageSpendLimitOverrideWithContext), varargs...) +} + +// SetVoiceMessageSpendLimitOverride mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetVoiceMessageSpendLimitOverride(arg0 *pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideInput) (*pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetVoiceMessageSpendLimitOverride", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetVoiceMessageSpendLimitOverride indicates an expected call of SetVoiceMessageSpendLimitOverride. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetVoiceMessageSpendLimitOverride(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVoiceMessageSpendLimitOverride", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetVoiceMessageSpendLimitOverride), arg0) +} + +// SetVoiceMessageSpendLimitOverrideRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetVoiceMessageSpendLimitOverrideRequest(arg0 *pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideInput) (*request.Request, *pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetVoiceMessageSpendLimitOverrideRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideOutput) + return ret0, ret1 +} + +// SetVoiceMessageSpendLimitOverrideRequest indicates an expected call of SetVoiceMessageSpendLimitOverrideRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetVoiceMessageSpendLimitOverrideRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVoiceMessageSpendLimitOverrideRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetVoiceMessageSpendLimitOverrideRequest), arg0) +} + +// SetVoiceMessageSpendLimitOverrideWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SetVoiceMessageSpendLimitOverrideWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetVoiceMessageSpendLimitOverrideWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SetVoiceMessageSpendLimitOverrideOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetVoiceMessageSpendLimitOverrideWithContext indicates an expected call of SetVoiceMessageSpendLimitOverrideWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SetVoiceMessageSpendLimitOverrideWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVoiceMessageSpendLimitOverrideWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SetVoiceMessageSpendLimitOverrideWithContext), varargs...) +} + +// SubmitRegistrationVersion mocks base method. +func (m *MockPinpointSMSVoiceV2API) SubmitRegistrationVersion(arg0 *pinpointsmsvoicev2.SubmitRegistrationVersionInput) (*pinpointsmsvoicev2.SubmitRegistrationVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubmitRegistrationVersion", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SubmitRegistrationVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubmitRegistrationVersion indicates an expected call of SubmitRegistrationVersion. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SubmitRegistrationVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitRegistrationVersion", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SubmitRegistrationVersion), arg0) +} + +// SubmitRegistrationVersionRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) SubmitRegistrationVersionRequest(arg0 *pinpointsmsvoicev2.SubmitRegistrationVersionInput) (*request.Request, *pinpointsmsvoicev2.SubmitRegistrationVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubmitRegistrationVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.SubmitRegistrationVersionOutput) + return ret0, ret1 +} + +// SubmitRegistrationVersionRequest indicates an expected call of SubmitRegistrationVersionRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SubmitRegistrationVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitRegistrationVersionRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SubmitRegistrationVersionRequest), arg0) +} + +// SubmitRegistrationVersionWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) SubmitRegistrationVersionWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.SubmitRegistrationVersionInput, arg2 ...request.Option) (*pinpointsmsvoicev2.SubmitRegistrationVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SubmitRegistrationVersionWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.SubmitRegistrationVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubmitRegistrationVersionWithContext indicates an expected call of SubmitRegistrationVersionWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) SubmitRegistrationVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitRegistrationVersionWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).SubmitRegistrationVersionWithContext), varargs...) +} + +// TagResource mocks base method. +func (m *MockPinpointSMSVoiceV2API) TagResource(arg0 *pinpointsmsvoicev2.TagResourceInput) (*pinpointsmsvoicev2.TagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResource", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResource indicates an expected call of TagResource. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).TagResource), arg0) +} + +// TagResourceRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) TagResourceRequest(arg0 *pinpointsmsvoicev2.TagResourceInput) (*request.Request, *pinpointsmsvoicev2.TagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.TagResourceOutput) + return ret0, ret1 +} + +// TagResourceRequest indicates an expected call of TagResourceRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).TagResourceRequest), arg0) +} + +// TagResourceWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) TagResourceWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.TagResourceInput, arg2 ...request.Option) (*pinpointsmsvoicev2.TagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResourceWithContext indicates an expected call of TagResourceWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).TagResourceWithContext), varargs...) +} + +// UntagResource mocks base method. +func (m *MockPinpointSMSVoiceV2API) UntagResource(arg0 *pinpointsmsvoicev2.UntagResourceInput) (*pinpointsmsvoicev2.UntagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResource", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResource indicates an expected call of UntagResource. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UntagResource), arg0) +} + +// UntagResourceRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) UntagResourceRequest(arg0 *pinpointsmsvoicev2.UntagResourceInput) (*request.Request, *pinpointsmsvoicev2.UntagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.UntagResourceOutput) + return ret0, ret1 +} + +// UntagResourceRequest indicates an expected call of UntagResourceRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UntagResourceRequest), arg0) +} + +// UntagResourceWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) UntagResourceWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.UntagResourceInput, arg2 ...request.Option) (*pinpointsmsvoicev2.UntagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResourceWithContext indicates an expected call of UntagResourceWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UntagResourceWithContext), varargs...) +} + +// UpdateEventDestination mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateEventDestination(arg0 *pinpointsmsvoicev2.UpdateEventDestinationInput) (*pinpointsmsvoicev2.UpdateEventDestinationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateEventDestination", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateEventDestinationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateEventDestination indicates an expected call of UpdateEventDestination. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateEventDestination(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEventDestination", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateEventDestination), arg0) +} + +// UpdateEventDestinationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateEventDestinationRequest(arg0 *pinpointsmsvoicev2.UpdateEventDestinationInput) (*request.Request, *pinpointsmsvoicev2.UpdateEventDestinationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateEventDestinationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.UpdateEventDestinationOutput) + return ret0, ret1 +} + +// UpdateEventDestinationRequest indicates an expected call of UpdateEventDestinationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateEventDestinationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEventDestinationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateEventDestinationRequest), arg0) +} + +// UpdateEventDestinationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateEventDestinationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.UpdateEventDestinationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.UpdateEventDestinationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateEventDestinationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateEventDestinationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateEventDestinationWithContext indicates an expected call of UpdateEventDestinationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateEventDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEventDestinationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateEventDestinationWithContext), varargs...) +} + +// UpdatePhoneNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdatePhoneNumber(arg0 *pinpointsmsvoicev2.UpdatePhoneNumberInput) (*pinpointsmsvoicev2.UpdatePhoneNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePhoneNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdatePhoneNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePhoneNumber indicates an expected call of UpdatePhoneNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdatePhoneNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdatePhoneNumber), arg0) +} + +// UpdatePhoneNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdatePhoneNumberRequest(arg0 *pinpointsmsvoicev2.UpdatePhoneNumberInput) (*request.Request, *pinpointsmsvoicev2.UpdatePhoneNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePhoneNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.UpdatePhoneNumberOutput) + return ret0, ret1 +} + +// UpdatePhoneNumberRequest indicates an expected call of UpdatePhoneNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdatePhoneNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdatePhoneNumberRequest), arg0) +} + +// UpdatePhoneNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdatePhoneNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.UpdatePhoneNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.UpdatePhoneNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePhoneNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdatePhoneNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePhoneNumberWithContext indicates an expected call of UpdatePhoneNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdatePhoneNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdatePhoneNumberWithContext), varargs...) +} + +// UpdatePool mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdatePool(arg0 *pinpointsmsvoicev2.UpdatePoolInput) (*pinpointsmsvoicev2.UpdatePoolOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePool", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdatePoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePool indicates an expected call of UpdatePool. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdatePool(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePool", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdatePool), arg0) +} + +// UpdatePoolRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdatePoolRequest(arg0 *pinpointsmsvoicev2.UpdatePoolInput) (*request.Request, *pinpointsmsvoicev2.UpdatePoolOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePoolRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.UpdatePoolOutput) + return ret0, ret1 +} + +// UpdatePoolRequest indicates an expected call of UpdatePoolRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdatePoolRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePoolRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdatePoolRequest), arg0) +} + +// UpdatePoolWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdatePoolWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.UpdatePoolInput, arg2 ...request.Option) (*pinpointsmsvoicev2.UpdatePoolOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePoolWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdatePoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePoolWithContext indicates an expected call of UpdatePoolWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdatePoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePoolWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdatePoolWithContext), varargs...) +} + +// UpdateProtectConfiguration mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateProtectConfiguration(arg0 *pinpointsmsvoicev2.UpdateProtectConfigurationInput) (*pinpointsmsvoicev2.UpdateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateProtectConfiguration", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProtectConfiguration indicates an expected call of UpdateProtectConfiguration. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateProtectConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectConfiguration", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateProtectConfiguration), arg0) +} + +// UpdateProtectConfigurationCountryRuleSet mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateProtectConfigurationCountryRuleSet(arg0 *pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetInput) (*pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateProtectConfigurationCountryRuleSet", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProtectConfigurationCountryRuleSet indicates an expected call of UpdateProtectConfigurationCountryRuleSet. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateProtectConfigurationCountryRuleSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectConfigurationCountryRuleSet", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateProtectConfigurationCountryRuleSet), arg0) +} + +// UpdateProtectConfigurationCountryRuleSetRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateProtectConfigurationCountryRuleSetRequest(arg0 *pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetInput) (*request.Request, *pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateProtectConfigurationCountryRuleSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetOutput) + return ret0, ret1 +} + +// UpdateProtectConfigurationCountryRuleSetRequest indicates an expected call of UpdateProtectConfigurationCountryRuleSetRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateProtectConfigurationCountryRuleSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectConfigurationCountryRuleSetRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateProtectConfigurationCountryRuleSetRequest), arg0) +} + +// UpdateProtectConfigurationCountryRuleSetWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateProtectConfigurationCountryRuleSetWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetInput, arg2 ...request.Option) (*pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateProtectConfigurationCountryRuleSetWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateProtectConfigurationCountryRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProtectConfigurationCountryRuleSetWithContext indicates an expected call of UpdateProtectConfigurationCountryRuleSetWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateProtectConfigurationCountryRuleSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectConfigurationCountryRuleSetWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateProtectConfigurationCountryRuleSetWithContext), varargs...) +} + +// UpdateProtectConfigurationRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateProtectConfigurationRequest(arg0 *pinpointsmsvoicev2.UpdateProtectConfigurationInput) (*request.Request, *pinpointsmsvoicev2.UpdateProtectConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateProtectConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.UpdateProtectConfigurationOutput) + return ret0, ret1 +} + +// UpdateProtectConfigurationRequest indicates an expected call of UpdateProtectConfigurationRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateProtectConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectConfigurationRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateProtectConfigurationRequest), arg0) +} + +// UpdateProtectConfigurationWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateProtectConfigurationWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.UpdateProtectConfigurationInput, arg2 ...request.Option) (*pinpointsmsvoicev2.UpdateProtectConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateProtectConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateProtectConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProtectConfigurationWithContext indicates an expected call of UpdateProtectConfigurationWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateProtectConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectConfigurationWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateProtectConfigurationWithContext), varargs...) +} + +// UpdateSenderId mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateSenderId(arg0 *pinpointsmsvoicev2.UpdateSenderIdInput) (*pinpointsmsvoicev2.UpdateSenderIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSenderId", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSenderId indicates an expected call of UpdateSenderId. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateSenderId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSenderId", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateSenderId), arg0) +} + +// UpdateSenderIdRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateSenderIdRequest(arg0 *pinpointsmsvoicev2.UpdateSenderIdInput) (*request.Request, *pinpointsmsvoicev2.UpdateSenderIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSenderIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.UpdateSenderIdOutput) + return ret0, ret1 +} + +// UpdateSenderIdRequest indicates an expected call of UpdateSenderIdRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateSenderIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSenderIdRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateSenderIdRequest), arg0) +} + +// UpdateSenderIdWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) UpdateSenderIdWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.UpdateSenderIdInput, arg2 ...request.Option) (*pinpointsmsvoicev2.UpdateSenderIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateSenderIdWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.UpdateSenderIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSenderIdWithContext indicates an expected call of UpdateSenderIdWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) UpdateSenderIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSenderIdWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).UpdateSenderIdWithContext), varargs...) +} + +// VerifyDestinationNumber mocks base method. +func (m *MockPinpointSMSVoiceV2API) VerifyDestinationNumber(arg0 *pinpointsmsvoicev2.VerifyDestinationNumberInput) (*pinpointsmsvoicev2.VerifyDestinationNumberOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VerifyDestinationNumber", arg0) + ret0, _ := ret[0].(*pinpointsmsvoicev2.VerifyDestinationNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyDestinationNumber indicates an expected call of VerifyDestinationNumber. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) VerifyDestinationNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyDestinationNumber", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).VerifyDestinationNumber), arg0) +} + +// VerifyDestinationNumberRequest mocks base method. +func (m *MockPinpointSMSVoiceV2API) VerifyDestinationNumberRequest(arg0 *pinpointsmsvoicev2.VerifyDestinationNumberInput) (*request.Request, *pinpointsmsvoicev2.VerifyDestinationNumberOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VerifyDestinationNumberRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*pinpointsmsvoicev2.VerifyDestinationNumberOutput) + return ret0, ret1 +} + +// VerifyDestinationNumberRequest indicates an expected call of VerifyDestinationNumberRequest. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) VerifyDestinationNumberRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyDestinationNumberRequest", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).VerifyDestinationNumberRequest), arg0) +} + +// VerifyDestinationNumberWithContext mocks base method. +func (m *MockPinpointSMSVoiceV2API) VerifyDestinationNumberWithContext(arg0 aws.Context, arg1 *pinpointsmsvoicev2.VerifyDestinationNumberInput, arg2 ...request.Option) (*pinpointsmsvoicev2.VerifyDestinationNumberOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "VerifyDestinationNumberWithContext", varargs...) + ret0, _ := ret[0].(*pinpointsmsvoicev2.VerifyDestinationNumberOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyDestinationNumberWithContext indicates an expected call of VerifyDestinationNumberWithContext. +func (mr *MockPinpointSMSVoiceV2APIMockRecorder) VerifyDestinationNumberWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyDestinationNumberWithContext", reflect.TypeOf((*MockPinpointSMSVoiceV2API)(nil).VerifyDestinationNumberWithContext), varargs...) +} diff --git a/resources/pinpoint_mock_test.go b/resources/pinpoint_mock_test.go new file mode 100644 index 00000000..65ab5a60 --- /dev/null +++ b/resources/pinpoint_mock_test.go @@ -0,0 +1,4 @@ +//go:generate ../mocks/generate_mocks.sh pinpointsmsvoicev2 pinpointsmsvoicev2iface +package resources + +// Note: empty on purpose, this file exist purely to generate mocks for the IAM service From 02777a4761a899d537d309427e5098f4ef949985 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 16:01:07 -0600 Subject: [PATCH 16/23] test(gamelift): add mocks for tests --- mocks/mock_gameliftiface/mock.go | 6229 ++++++++++++++++++++++++++++++ resources/gamelift_mock_test.go | 4 + 2 files changed, 6233 insertions(+) create mode 100644 mocks/mock_gameliftiface/mock.go create mode 100644 resources/gamelift_mock_test.go diff --git a/mocks/mock_gameliftiface/mock.go b/mocks/mock_gameliftiface/mock.go new file mode 100644 index 00000000..5c4f5a0b --- /dev/null +++ b/mocks/mock_gameliftiface/mock.go @@ -0,0 +1,6229 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.54.20/service/gamelift/gameliftiface/interface.go + +// Package mock_gameliftiface is a generated GoMock package. +package mock_gameliftiface + +import ( + reflect "reflect" + + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + gamelift "github.com/aws/aws-sdk-go/service/gamelift" + gomock "github.com/golang/mock/gomock" +) + +// MockGameLiftAPI is a mock of GameLiftAPI interface. +type MockGameLiftAPI struct { + ctrl *gomock.Controller + recorder *MockGameLiftAPIMockRecorder +} + +// MockGameLiftAPIMockRecorder is the mock recorder for MockGameLiftAPI. +type MockGameLiftAPIMockRecorder struct { + mock *MockGameLiftAPI +} + +// NewMockGameLiftAPI creates a new mock instance. +func NewMockGameLiftAPI(ctrl *gomock.Controller) *MockGameLiftAPI { + mock := &MockGameLiftAPI{ctrl: ctrl} + mock.recorder = &MockGameLiftAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGameLiftAPI) EXPECT() *MockGameLiftAPIMockRecorder { + return m.recorder +} + +// AcceptMatch mocks base method. +func (m *MockGameLiftAPI) AcceptMatch(arg0 *gamelift.AcceptMatchInput) (*gamelift.AcceptMatchOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptMatch", arg0) + ret0, _ := ret[0].(*gamelift.AcceptMatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptMatch indicates an expected call of AcceptMatch. +func (mr *MockGameLiftAPIMockRecorder) AcceptMatch(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptMatch", reflect.TypeOf((*MockGameLiftAPI)(nil).AcceptMatch), arg0) +} + +// AcceptMatchRequest mocks base method. +func (m *MockGameLiftAPI) AcceptMatchRequest(arg0 *gamelift.AcceptMatchInput) (*request.Request, *gamelift.AcceptMatchOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptMatchRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.AcceptMatchOutput) + return ret0, ret1 +} + +// AcceptMatchRequest indicates an expected call of AcceptMatchRequest. +func (mr *MockGameLiftAPIMockRecorder) AcceptMatchRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptMatchRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).AcceptMatchRequest), arg0) +} + +// AcceptMatchWithContext mocks base method. +func (m *MockGameLiftAPI) AcceptMatchWithContext(arg0 aws.Context, arg1 *gamelift.AcceptMatchInput, arg2 ...request.Option) (*gamelift.AcceptMatchOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AcceptMatchWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.AcceptMatchOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptMatchWithContext indicates an expected call of AcceptMatchWithContext. +func (mr *MockGameLiftAPIMockRecorder) AcceptMatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptMatchWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).AcceptMatchWithContext), varargs...) +} + +// ClaimGameServer mocks base method. +func (m *MockGameLiftAPI) ClaimGameServer(arg0 *gamelift.ClaimGameServerInput) (*gamelift.ClaimGameServerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClaimGameServer", arg0) + ret0, _ := ret[0].(*gamelift.ClaimGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ClaimGameServer indicates an expected call of ClaimGameServer. +func (mr *MockGameLiftAPIMockRecorder) ClaimGameServer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClaimGameServer", reflect.TypeOf((*MockGameLiftAPI)(nil).ClaimGameServer), arg0) +} + +// ClaimGameServerRequest mocks base method. +func (m *MockGameLiftAPI) ClaimGameServerRequest(arg0 *gamelift.ClaimGameServerInput) (*request.Request, *gamelift.ClaimGameServerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClaimGameServerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ClaimGameServerOutput) + return ret0, ret1 +} + +// ClaimGameServerRequest indicates an expected call of ClaimGameServerRequest. +func (mr *MockGameLiftAPIMockRecorder) ClaimGameServerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClaimGameServerRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ClaimGameServerRequest), arg0) +} + +// ClaimGameServerWithContext mocks base method. +func (m *MockGameLiftAPI) ClaimGameServerWithContext(arg0 aws.Context, arg1 *gamelift.ClaimGameServerInput, arg2 ...request.Option) (*gamelift.ClaimGameServerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClaimGameServerWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ClaimGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ClaimGameServerWithContext indicates an expected call of ClaimGameServerWithContext. +func (mr *MockGameLiftAPIMockRecorder) ClaimGameServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClaimGameServerWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ClaimGameServerWithContext), varargs...) +} + +// CreateAlias mocks base method. +func (m *MockGameLiftAPI) CreateAlias(arg0 *gamelift.CreateAliasInput) (*gamelift.CreateAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAlias", arg0) + ret0, _ := ret[0].(*gamelift.CreateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAlias indicates an expected call of CreateAlias. +func (mr *MockGameLiftAPIMockRecorder) CreateAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAlias", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateAlias), arg0) +} + +// CreateAliasRequest mocks base method. +func (m *MockGameLiftAPI) CreateAliasRequest(arg0 *gamelift.CreateAliasInput) (*request.Request, *gamelift.CreateAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateAliasOutput) + return ret0, ret1 +} + +// CreateAliasRequest indicates an expected call of CreateAliasRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAliasRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateAliasRequest), arg0) +} + +// CreateAliasWithContext mocks base method. +func (m *MockGameLiftAPI) CreateAliasWithContext(arg0 aws.Context, arg1 *gamelift.CreateAliasInput, arg2 ...request.Option) (*gamelift.CreateAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAliasWithContext indicates an expected call of CreateAliasWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAliasWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateAliasWithContext), varargs...) +} + +// CreateBuild mocks base method. +func (m *MockGameLiftAPI) CreateBuild(arg0 *gamelift.CreateBuildInput) (*gamelift.CreateBuildOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateBuild", arg0) + ret0, _ := ret[0].(*gamelift.CreateBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateBuild indicates an expected call of CreateBuild. +func (mr *MockGameLiftAPIMockRecorder) CreateBuild(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBuild", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateBuild), arg0) +} + +// CreateBuildRequest mocks base method. +func (m *MockGameLiftAPI) CreateBuildRequest(arg0 *gamelift.CreateBuildInput) (*request.Request, *gamelift.CreateBuildOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateBuildRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateBuildOutput) + return ret0, ret1 +} + +// CreateBuildRequest indicates an expected call of CreateBuildRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateBuildRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBuildRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateBuildRequest), arg0) +} + +// CreateBuildWithContext mocks base method. +func (m *MockGameLiftAPI) CreateBuildWithContext(arg0 aws.Context, arg1 *gamelift.CreateBuildInput, arg2 ...request.Option) (*gamelift.CreateBuildOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateBuildWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateBuildWithContext indicates an expected call of CreateBuildWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateBuildWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBuildWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateBuildWithContext), varargs...) +} + +// CreateContainerGroupDefinition mocks base method. +func (m *MockGameLiftAPI) CreateContainerGroupDefinition(arg0 *gamelift.CreateContainerGroupDefinitionInput) (*gamelift.CreateContainerGroupDefinitionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateContainerGroupDefinition", arg0) + ret0, _ := ret[0].(*gamelift.CreateContainerGroupDefinitionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateContainerGroupDefinition indicates an expected call of CreateContainerGroupDefinition. +func (mr *MockGameLiftAPIMockRecorder) CreateContainerGroupDefinition(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerGroupDefinition", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateContainerGroupDefinition), arg0) +} + +// CreateContainerGroupDefinitionRequest mocks base method. +func (m *MockGameLiftAPI) CreateContainerGroupDefinitionRequest(arg0 *gamelift.CreateContainerGroupDefinitionInput) (*request.Request, *gamelift.CreateContainerGroupDefinitionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateContainerGroupDefinitionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateContainerGroupDefinitionOutput) + return ret0, ret1 +} + +// CreateContainerGroupDefinitionRequest indicates an expected call of CreateContainerGroupDefinitionRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateContainerGroupDefinitionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerGroupDefinitionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateContainerGroupDefinitionRequest), arg0) +} + +// CreateContainerGroupDefinitionWithContext mocks base method. +func (m *MockGameLiftAPI) CreateContainerGroupDefinitionWithContext(arg0 aws.Context, arg1 *gamelift.CreateContainerGroupDefinitionInput, arg2 ...request.Option) (*gamelift.CreateContainerGroupDefinitionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateContainerGroupDefinitionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateContainerGroupDefinitionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateContainerGroupDefinitionWithContext indicates an expected call of CreateContainerGroupDefinitionWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateContainerGroupDefinitionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerGroupDefinitionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateContainerGroupDefinitionWithContext), varargs...) +} + +// CreateFleet mocks base method. +func (m *MockGameLiftAPI) CreateFleet(arg0 *gamelift.CreateFleetInput) (*gamelift.CreateFleetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFleet", arg0) + ret0, _ := ret[0].(*gamelift.CreateFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFleet indicates an expected call of CreateFleet. +func (mr *MockGameLiftAPIMockRecorder) CreateFleet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleet", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateFleet), arg0) +} + +// CreateFleetLocations mocks base method. +func (m *MockGameLiftAPI) CreateFleetLocations(arg0 *gamelift.CreateFleetLocationsInput) (*gamelift.CreateFleetLocationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFleetLocations", arg0) + ret0, _ := ret[0].(*gamelift.CreateFleetLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFleetLocations indicates an expected call of CreateFleetLocations. +func (mr *MockGameLiftAPIMockRecorder) CreateFleetLocations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetLocations", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateFleetLocations), arg0) +} + +// CreateFleetLocationsRequest mocks base method. +func (m *MockGameLiftAPI) CreateFleetLocationsRequest(arg0 *gamelift.CreateFleetLocationsInput) (*request.Request, *gamelift.CreateFleetLocationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFleetLocationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateFleetLocationsOutput) + return ret0, ret1 +} + +// CreateFleetLocationsRequest indicates an expected call of CreateFleetLocationsRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateFleetLocationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetLocationsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateFleetLocationsRequest), arg0) +} + +// CreateFleetLocationsWithContext mocks base method. +func (m *MockGameLiftAPI) CreateFleetLocationsWithContext(arg0 aws.Context, arg1 *gamelift.CreateFleetLocationsInput, arg2 ...request.Option) (*gamelift.CreateFleetLocationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFleetLocationsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateFleetLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFleetLocationsWithContext indicates an expected call of CreateFleetLocationsWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateFleetLocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetLocationsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateFleetLocationsWithContext), varargs...) +} + +// CreateFleetRequest mocks base method. +func (m *MockGameLiftAPI) CreateFleetRequest(arg0 *gamelift.CreateFleetInput) (*request.Request, *gamelift.CreateFleetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFleetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateFleetOutput) + return ret0, ret1 +} + +// CreateFleetRequest indicates an expected call of CreateFleetRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateFleetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateFleetRequest), arg0) +} + +// CreateFleetWithContext mocks base method. +func (m *MockGameLiftAPI) CreateFleetWithContext(arg0 aws.Context, arg1 *gamelift.CreateFleetInput, arg2 ...request.Option) (*gamelift.CreateFleetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFleetWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFleetWithContext indicates an expected call of CreateFleetWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateFleetWithContext), varargs...) +} + +// CreateGameServerGroup mocks base method. +func (m *MockGameLiftAPI) CreateGameServerGroup(arg0 *gamelift.CreateGameServerGroupInput) (*gamelift.CreateGameServerGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGameServerGroup", arg0) + ret0, _ := ret[0].(*gamelift.CreateGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGameServerGroup indicates an expected call of CreateGameServerGroup. +func (mr *MockGameLiftAPIMockRecorder) CreateGameServerGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameServerGroup", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameServerGroup), arg0) +} + +// CreateGameServerGroupRequest mocks base method. +func (m *MockGameLiftAPI) CreateGameServerGroupRequest(arg0 *gamelift.CreateGameServerGroupInput) (*request.Request, *gamelift.CreateGameServerGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGameServerGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateGameServerGroupOutput) + return ret0, ret1 +} + +// CreateGameServerGroupRequest indicates an expected call of CreateGameServerGroupRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateGameServerGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameServerGroupRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameServerGroupRequest), arg0) +} + +// CreateGameServerGroupWithContext mocks base method. +func (m *MockGameLiftAPI) CreateGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.CreateGameServerGroupInput, arg2 ...request.Option) (*gamelift.CreateGameServerGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateGameServerGroupWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGameServerGroupWithContext indicates an expected call of CreateGameServerGroupWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateGameServerGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameServerGroupWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameServerGroupWithContext), varargs...) +} + +// CreateGameSession mocks base method. +func (m *MockGameLiftAPI) CreateGameSession(arg0 *gamelift.CreateGameSessionInput) (*gamelift.CreateGameSessionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGameSession", arg0) + ret0, _ := ret[0].(*gamelift.CreateGameSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGameSession indicates an expected call of CreateGameSession. +func (mr *MockGameLiftAPIMockRecorder) CreateGameSession(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameSession", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameSession), arg0) +} + +// CreateGameSessionQueue mocks base method. +func (m *MockGameLiftAPI) CreateGameSessionQueue(arg0 *gamelift.CreateGameSessionQueueInput) (*gamelift.CreateGameSessionQueueOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGameSessionQueue", arg0) + ret0, _ := ret[0].(*gamelift.CreateGameSessionQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGameSessionQueue indicates an expected call of CreateGameSessionQueue. +func (mr *MockGameLiftAPIMockRecorder) CreateGameSessionQueue(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameSessionQueue", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameSessionQueue), arg0) +} + +// CreateGameSessionQueueRequest mocks base method. +func (m *MockGameLiftAPI) CreateGameSessionQueueRequest(arg0 *gamelift.CreateGameSessionQueueInput) (*request.Request, *gamelift.CreateGameSessionQueueOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGameSessionQueueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateGameSessionQueueOutput) + return ret0, ret1 +} + +// CreateGameSessionQueueRequest indicates an expected call of CreateGameSessionQueueRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateGameSessionQueueRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameSessionQueueRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameSessionQueueRequest), arg0) +} + +// CreateGameSessionQueueWithContext mocks base method. +func (m *MockGameLiftAPI) CreateGameSessionQueueWithContext(arg0 aws.Context, arg1 *gamelift.CreateGameSessionQueueInput, arg2 ...request.Option) (*gamelift.CreateGameSessionQueueOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateGameSessionQueueWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateGameSessionQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGameSessionQueueWithContext indicates an expected call of CreateGameSessionQueueWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateGameSessionQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameSessionQueueWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameSessionQueueWithContext), varargs...) +} + +// CreateGameSessionRequest mocks base method. +func (m *MockGameLiftAPI) CreateGameSessionRequest(arg0 *gamelift.CreateGameSessionInput) (*request.Request, *gamelift.CreateGameSessionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGameSessionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateGameSessionOutput) + return ret0, ret1 +} + +// CreateGameSessionRequest indicates an expected call of CreateGameSessionRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateGameSessionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameSessionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameSessionRequest), arg0) +} + +// CreateGameSessionWithContext mocks base method. +func (m *MockGameLiftAPI) CreateGameSessionWithContext(arg0 aws.Context, arg1 *gamelift.CreateGameSessionInput, arg2 ...request.Option) (*gamelift.CreateGameSessionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateGameSessionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateGameSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGameSessionWithContext indicates an expected call of CreateGameSessionWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateGameSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGameSessionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateGameSessionWithContext), varargs...) +} + +// CreateLocation mocks base method. +func (m *MockGameLiftAPI) CreateLocation(arg0 *gamelift.CreateLocationInput) (*gamelift.CreateLocationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLocation", arg0) + ret0, _ := ret[0].(*gamelift.CreateLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLocation indicates an expected call of CreateLocation. +func (mr *MockGameLiftAPIMockRecorder) CreateLocation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocation", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateLocation), arg0) +} + +// CreateLocationRequest mocks base method. +func (m *MockGameLiftAPI) CreateLocationRequest(arg0 *gamelift.CreateLocationInput) (*request.Request, *gamelift.CreateLocationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLocationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateLocationOutput) + return ret0, ret1 +} + +// CreateLocationRequest indicates an expected call of CreateLocationRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateLocationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateLocationRequest), arg0) +} + +// CreateLocationWithContext mocks base method. +func (m *MockGameLiftAPI) CreateLocationWithContext(arg0 aws.Context, arg1 *gamelift.CreateLocationInput, arg2 ...request.Option) (*gamelift.CreateLocationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateLocationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLocationWithContext indicates an expected call of CreateLocationWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateLocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateLocationWithContext), varargs...) +} + +// CreateMatchmakingConfiguration mocks base method. +func (m *MockGameLiftAPI) CreateMatchmakingConfiguration(arg0 *gamelift.CreateMatchmakingConfigurationInput) (*gamelift.CreateMatchmakingConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateMatchmakingConfiguration", arg0) + ret0, _ := ret[0].(*gamelift.CreateMatchmakingConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateMatchmakingConfiguration indicates an expected call of CreateMatchmakingConfiguration. +func (mr *MockGameLiftAPIMockRecorder) CreateMatchmakingConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMatchmakingConfiguration", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateMatchmakingConfiguration), arg0) +} + +// CreateMatchmakingConfigurationRequest mocks base method. +func (m *MockGameLiftAPI) CreateMatchmakingConfigurationRequest(arg0 *gamelift.CreateMatchmakingConfigurationInput) (*request.Request, *gamelift.CreateMatchmakingConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateMatchmakingConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateMatchmakingConfigurationOutput) + return ret0, ret1 +} + +// CreateMatchmakingConfigurationRequest indicates an expected call of CreateMatchmakingConfigurationRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateMatchmakingConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMatchmakingConfigurationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateMatchmakingConfigurationRequest), arg0) +} + +// CreateMatchmakingConfigurationWithContext mocks base method. +func (m *MockGameLiftAPI) CreateMatchmakingConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.CreateMatchmakingConfigurationInput, arg2 ...request.Option) (*gamelift.CreateMatchmakingConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateMatchmakingConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateMatchmakingConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateMatchmakingConfigurationWithContext indicates an expected call of CreateMatchmakingConfigurationWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateMatchmakingConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMatchmakingConfigurationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateMatchmakingConfigurationWithContext), varargs...) +} + +// CreateMatchmakingRuleSet mocks base method. +func (m *MockGameLiftAPI) CreateMatchmakingRuleSet(arg0 *gamelift.CreateMatchmakingRuleSetInput) (*gamelift.CreateMatchmakingRuleSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateMatchmakingRuleSet", arg0) + ret0, _ := ret[0].(*gamelift.CreateMatchmakingRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateMatchmakingRuleSet indicates an expected call of CreateMatchmakingRuleSet. +func (mr *MockGameLiftAPIMockRecorder) CreateMatchmakingRuleSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMatchmakingRuleSet", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateMatchmakingRuleSet), arg0) +} + +// CreateMatchmakingRuleSetRequest mocks base method. +func (m *MockGameLiftAPI) CreateMatchmakingRuleSetRequest(arg0 *gamelift.CreateMatchmakingRuleSetInput) (*request.Request, *gamelift.CreateMatchmakingRuleSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateMatchmakingRuleSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateMatchmakingRuleSetOutput) + return ret0, ret1 +} + +// CreateMatchmakingRuleSetRequest indicates an expected call of CreateMatchmakingRuleSetRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateMatchmakingRuleSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMatchmakingRuleSetRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateMatchmakingRuleSetRequest), arg0) +} + +// CreateMatchmakingRuleSetWithContext mocks base method. +func (m *MockGameLiftAPI) CreateMatchmakingRuleSetWithContext(arg0 aws.Context, arg1 *gamelift.CreateMatchmakingRuleSetInput, arg2 ...request.Option) (*gamelift.CreateMatchmakingRuleSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateMatchmakingRuleSetWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateMatchmakingRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateMatchmakingRuleSetWithContext indicates an expected call of CreateMatchmakingRuleSetWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateMatchmakingRuleSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMatchmakingRuleSetWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateMatchmakingRuleSetWithContext), varargs...) +} + +// CreatePlayerSession mocks base method. +func (m *MockGameLiftAPI) CreatePlayerSession(arg0 *gamelift.CreatePlayerSessionInput) (*gamelift.CreatePlayerSessionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePlayerSession", arg0) + ret0, _ := ret[0].(*gamelift.CreatePlayerSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePlayerSession indicates an expected call of CreatePlayerSession. +func (mr *MockGameLiftAPIMockRecorder) CreatePlayerSession(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlayerSession", reflect.TypeOf((*MockGameLiftAPI)(nil).CreatePlayerSession), arg0) +} + +// CreatePlayerSessionRequest mocks base method. +func (m *MockGameLiftAPI) CreatePlayerSessionRequest(arg0 *gamelift.CreatePlayerSessionInput) (*request.Request, *gamelift.CreatePlayerSessionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePlayerSessionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreatePlayerSessionOutput) + return ret0, ret1 +} + +// CreatePlayerSessionRequest indicates an expected call of CreatePlayerSessionRequest. +func (mr *MockGameLiftAPIMockRecorder) CreatePlayerSessionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlayerSessionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreatePlayerSessionRequest), arg0) +} + +// CreatePlayerSessionWithContext mocks base method. +func (m *MockGameLiftAPI) CreatePlayerSessionWithContext(arg0 aws.Context, arg1 *gamelift.CreatePlayerSessionInput, arg2 ...request.Option) (*gamelift.CreatePlayerSessionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePlayerSessionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreatePlayerSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePlayerSessionWithContext indicates an expected call of CreatePlayerSessionWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreatePlayerSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlayerSessionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreatePlayerSessionWithContext), varargs...) +} + +// CreatePlayerSessions mocks base method. +func (m *MockGameLiftAPI) CreatePlayerSessions(arg0 *gamelift.CreatePlayerSessionsInput) (*gamelift.CreatePlayerSessionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePlayerSessions", arg0) + ret0, _ := ret[0].(*gamelift.CreatePlayerSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePlayerSessions indicates an expected call of CreatePlayerSessions. +func (mr *MockGameLiftAPIMockRecorder) CreatePlayerSessions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlayerSessions", reflect.TypeOf((*MockGameLiftAPI)(nil).CreatePlayerSessions), arg0) +} + +// CreatePlayerSessionsRequest mocks base method. +func (m *MockGameLiftAPI) CreatePlayerSessionsRequest(arg0 *gamelift.CreatePlayerSessionsInput) (*request.Request, *gamelift.CreatePlayerSessionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePlayerSessionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreatePlayerSessionsOutput) + return ret0, ret1 +} + +// CreatePlayerSessionsRequest indicates an expected call of CreatePlayerSessionsRequest. +func (mr *MockGameLiftAPIMockRecorder) CreatePlayerSessionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlayerSessionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreatePlayerSessionsRequest), arg0) +} + +// CreatePlayerSessionsWithContext mocks base method. +func (m *MockGameLiftAPI) CreatePlayerSessionsWithContext(arg0 aws.Context, arg1 *gamelift.CreatePlayerSessionsInput, arg2 ...request.Option) (*gamelift.CreatePlayerSessionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePlayerSessionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreatePlayerSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePlayerSessionsWithContext indicates an expected call of CreatePlayerSessionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreatePlayerSessionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlayerSessionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreatePlayerSessionsWithContext), varargs...) +} + +// CreateScript mocks base method. +func (m *MockGameLiftAPI) CreateScript(arg0 *gamelift.CreateScriptInput) (*gamelift.CreateScriptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateScript", arg0) + ret0, _ := ret[0].(*gamelift.CreateScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateScript indicates an expected call of CreateScript. +func (mr *MockGameLiftAPIMockRecorder) CreateScript(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateScript", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateScript), arg0) +} + +// CreateScriptRequest mocks base method. +func (m *MockGameLiftAPI) CreateScriptRequest(arg0 *gamelift.CreateScriptInput) (*request.Request, *gamelift.CreateScriptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateScriptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateScriptOutput) + return ret0, ret1 +} + +// CreateScriptRequest indicates an expected call of CreateScriptRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateScriptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateScriptRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateScriptRequest), arg0) +} + +// CreateScriptWithContext mocks base method. +func (m *MockGameLiftAPI) CreateScriptWithContext(arg0 aws.Context, arg1 *gamelift.CreateScriptInput, arg2 ...request.Option) (*gamelift.CreateScriptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateScriptWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateScriptWithContext indicates an expected call of CreateScriptWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateScriptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateScriptWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateScriptWithContext), varargs...) +} + +// CreateVpcPeeringAuthorization mocks base method. +func (m *MockGameLiftAPI) CreateVpcPeeringAuthorization(arg0 *gamelift.CreateVpcPeeringAuthorizationInput) (*gamelift.CreateVpcPeeringAuthorizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcPeeringAuthorization", arg0) + ret0, _ := ret[0].(*gamelift.CreateVpcPeeringAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcPeeringAuthorization indicates an expected call of CreateVpcPeeringAuthorization. +func (mr *MockGameLiftAPIMockRecorder) CreateVpcPeeringAuthorization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringAuthorization", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateVpcPeeringAuthorization), arg0) +} + +// CreateVpcPeeringAuthorizationRequest mocks base method. +func (m *MockGameLiftAPI) CreateVpcPeeringAuthorizationRequest(arg0 *gamelift.CreateVpcPeeringAuthorizationInput) (*request.Request, *gamelift.CreateVpcPeeringAuthorizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcPeeringAuthorizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateVpcPeeringAuthorizationOutput) + return ret0, ret1 +} + +// CreateVpcPeeringAuthorizationRequest indicates an expected call of CreateVpcPeeringAuthorizationRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateVpcPeeringAuthorizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringAuthorizationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateVpcPeeringAuthorizationRequest), arg0) +} + +// CreateVpcPeeringAuthorizationWithContext mocks base method. +func (m *MockGameLiftAPI) CreateVpcPeeringAuthorizationWithContext(arg0 aws.Context, arg1 *gamelift.CreateVpcPeeringAuthorizationInput, arg2 ...request.Option) (*gamelift.CreateVpcPeeringAuthorizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpcPeeringAuthorizationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateVpcPeeringAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcPeeringAuthorizationWithContext indicates an expected call of CreateVpcPeeringAuthorizationWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateVpcPeeringAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringAuthorizationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateVpcPeeringAuthorizationWithContext), varargs...) +} + +// CreateVpcPeeringConnection mocks base method. +func (m *MockGameLiftAPI) CreateVpcPeeringConnection(arg0 *gamelift.CreateVpcPeeringConnectionInput) (*gamelift.CreateVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcPeeringConnection", arg0) + ret0, _ := ret[0].(*gamelift.CreateVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcPeeringConnection indicates an expected call of CreateVpcPeeringConnection. +func (mr *MockGameLiftAPIMockRecorder) CreateVpcPeeringConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnection", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateVpcPeeringConnection), arg0) +} + +// CreateVpcPeeringConnectionRequest mocks base method. +func (m *MockGameLiftAPI) CreateVpcPeeringConnectionRequest(arg0 *gamelift.CreateVpcPeeringConnectionInput) (*request.Request, *gamelift.CreateVpcPeeringConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.CreateVpcPeeringConnectionOutput) + return ret0, ret1 +} + +// CreateVpcPeeringConnectionRequest indicates an expected call of CreateVpcPeeringConnectionRequest. +func (mr *MockGameLiftAPIMockRecorder) CreateVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateVpcPeeringConnectionRequest), arg0) +} + +// CreateVpcPeeringConnectionWithContext mocks base method. +func (m *MockGameLiftAPI) CreateVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *gamelift.CreateVpcPeeringConnectionInput, arg2 ...request.Option) (*gamelift.CreateVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.CreateVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcPeeringConnectionWithContext indicates an expected call of CreateVpcPeeringConnectionWithContext. +func (mr *MockGameLiftAPIMockRecorder) CreateVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).CreateVpcPeeringConnectionWithContext), varargs...) +} + +// DeleteAlias mocks base method. +func (m *MockGameLiftAPI) DeleteAlias(arg0 *gamelift.DeleteAliasInput) (*gamelift.DeleteAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAlias", arg0) + ret0, _ := ret[0].(*gamelift.DeleteAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAlias indicates an expected call of DeleteAlias. +func (mr *MockGameLiftAPIMockRecorder) DeleteAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAlias", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteAlias), arg0) +} + +// DeleteAliasRequest mocks base method. +func (m *MockGameLiftAPI) DeleteAliasRequest(arg0 *gamelift.DeleteAliasInput) (*request.Request, *gamelift.DeleteAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteAliasOutput) + return ret0, ret1 +} + +// DeleteAliasRequest indicates an expected call of DeleteAliasRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAliasRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteAliasRequest), arg0) +} + +// DeleteAliasWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteAliasWithContext(arg0 aws.Context, arg1 *gamelift.DeleteAliasInput, arg2 ...request.Option) (*gamelift.DeleteAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAliasWithContext indicates an expected call of DeleteAliasWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAliasWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteAliasWithContext), varargs...) +} + +// DeleteBuild mocks base method. +func (m *MockGameLiftAPI) DeleteBuild(arg0 *gamelift.DeleteBuildInput) (*gamelift.DeleteBuildOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteBuild", arg0) + ret0, _ := ret[0].(*gamelift.DeleteBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBuild indicates an expected call of DeleteBuild. +func (mr *MockGameLiftAPIMockRecorder) DeleteBuild(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBuild", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteBuild), arg0) +} + +// DeleteBuildRequest mocks base method. +func (m *MockGameLiftAPI) DeleteBuildRequest(arg0 *gamelift.DeleteBuildInput) (*request.Request, *gamelift.DeleteBuildOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteBuildRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteBuildOutput) + return ret0, ret1 +} + +// DeleteBuildRequest indicates an expected call of DeleteBuildRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteBuildRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBuildRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteBuildRequest), arg0) +} + +// DeleteBuildWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteBuildWithContext(arg0 aws.Context, arg1 *gamelift.DeleteBuildInput, arg2 ...request.Option) (*gamelift.DeleteBuildOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBuildWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBuildWithContext indicates an expected call of DeleteBuildWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteBuildWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBuildWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteBuildWithContext), varargs...) +} + +// DeleteContainerGroupDefinition mocks base method. +func (m *MockGameLiftAPI) DeleteContainerGroupDefinition(arg0 *gamelift.DeleteContainerGroupDefinitionInput) (*gamelift.DeleteContainerGroupDefinitionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteContainerGroupDefinition", arg0) + ret0, _ := ret[0].(*gamelift.DeleteContainerGroupDefinitionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteContainerGroupDefinition indicates an expected call of DeleteContainerGroupDefinition. +func (mr *MockGameLiftAPIMockRecorder) DeleteContainerGroupDefinition(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerGroupDefinition", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteContainerGroupDefinition), arg0) +} + +// DeleteContainerGroupDefinitionRequest mocks base method. +func (m *MockGameLiftAPI) DeleteContainerGroupDefinitionRequest(arg0 *gamelift.DeleteContainerGroupDefinitionInput) (*request.Request, *gamelift.DeleteContainerGroupDefinitionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteContainerGroupDefinitionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteContainerGroupDefinitionOutput) + return ret0, ret1 +} + +// DeleteContainerGroupDefinitionRequest indicates an expected call of DeleteContainerGroupDefinitionRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteContainerGroupDefinitionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerGroupDefinitionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteContainerGroupDefinitionRequest), arg0) +} + +// DeleteContainerGroupDefinitionWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteContainerGroupDefinitionWithContext(arg0 aws.Context, arg1 *gamelift.DeleteContainerGroupDefinitionInput, arg2 ...request.Option) (*gamelift.DeleteContainerGroupDefinitionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteContainerGroupDefinitionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteContainerGroupDefinitionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteContainerGroupDefinitionWithContext indicates an expected call of DeleteContainerGroupDefinitionWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteContainerGroupDefinitionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerGroupDefinitionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteContainerGroupDefinitionWithContext), varargs...) +} + +// DeleteFleet mocks base method. +func (m *MockGameLiftAPI) DeleteFleet(arg0 *gamelift.DeleteFleetInput) (*gamelift.DeleteFleetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFleet", arg0) + ret0, _ := ret[0].(*gamelift.DeleteFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFleet indicates an expected call of DeleteFleet. +func (mr *MockGameLiftAPIMockRecorder) DeleteFleet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleet", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteFleet), arg0) +} + +// DeleteFleetLocations mocks base method. +func (m *MockGameLiftAPI) DeleteFleetLocations(arg0 *gamelift.DeleteFleetLocationsInput) (*gamelift.DeleteFleetLocationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFleetLocations", arg0) + ret0, _ := ret[0].(*gamelift.DeleteFleetLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFleetLocations indicates an expected call of DeleteFleetLocations. +func (mr *MockGameLiftAPIMockRecorder) DeleteFleetLocations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetLocations", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteFleetLocations), arg0) +} + +// DeleteFleetLocationsRequest mocks base method. +func (m *MockGameLiftAPI) DeleteFleetLocationsRequest(arg0 *gamelift.DeleteFleetLocationsInput) (*request.Request, *gamelift.DeleteFleetLocationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFleetLocationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteFleetLocationsOutput) + return ret0, ret1 +} + +// DeleteFleetLocationsRequest indicates an expected call of DeleteFleetLocationsRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteFleetLocationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetLocationsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteFleetLocationsRequest), arg0) +} + +// DeleteFleetLocationsWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteFleetLocationsWithContext(arg0 aws.Context, arg1 *gamelift.DeleteFleetLocationsInput, arg2 ...request.Option) (*gamelift.DeleteFleetLocationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFleetLocationsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteFleetLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFleetLocationsWithContext indicates an expected call of DeleteFleetLocationsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteFleetLocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetLocationsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteFleetLocationsWithContext), varargs...) +} + +// DeleteFleetRequest mocks base method. +func (m *MockGameLiftAPI) DeleteFleetRequest(arg0 *gamelift.DeleteFleetInput) (*request.Request, *gamelift.DeleteFleetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFleetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteFleetOutput) + return ret0, ret1 +} + +// DeleteFleetRequest indicates an expected call of DeleteFleetRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteFleetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteFleetRequest), arg0) +} + +// DeleteFleetWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteFleetWithContext(arg0 aws.Context, arg1 *gamelift.DeleteFleetInput, arg2 ...request.Option) (*gamelift.DeleteFleetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFleetWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFleetWithContext indicates an expected call of DeleteFleetWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteFleetWithContext), varargs...) +} + +// DeleteGameServerGroup mocks base method. +func (m *MockGameLiftAPI) DeleteGameServerGroup(arg0 *gamelift.DeleteGameServerGroupInput) (*gamelift.DeleteGameServerGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGameServerGroup", arg0) + ret0, _ := ret[0].(*gamelift.DeleteGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGameServerGroup indicates an expected call of DeleteGameServerGroup. +func (mr *MockGameLiftAPIMockRecorder) DeleteGameServerGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGameServerGroup", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteGameServerGroup), arg0) +} + +// DeleteGameServerGroupRequest mocks base method. +func (m *MockGameLiftAPI) DeleteGameServerGroupRequest(arg0 *gamelift.DeleteGameServerGroupInput) (*request.Request, *gamelift.DeleteGameServerGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGameServerGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteGameServerGroupOutput) + return ret0, ret1 +} + +// DeleteGameServerGroupRequest indicates an expected call of DeleteGameServerGroupRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteGameServerGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGameServerGroupRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteGameServerGroupRequest), arg0) +} + +// DeleteGameServerGroupWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.DeleteGameServerGroupInput, arg2 ...request.Option) (*gamelift.DeleteGameServerGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteGameServerGroupWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGameServerGroupWithContext indicates an expected call of DeleteGameServerGroupWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteGameServerGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGameServerGroupWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteGameServerGroupWithContext), varargs...) +} + +// DeleteGameSessionQueue mocks base method. +func (m *MockGameLiftAPI) DeleteGameSessionQueue(arg0 *gamelift.DeleteGameSessionQueueInput) (*gamelift.DeleteGameSessionQueueOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGameSessionQueue", arg0) + ret0, _ := ret[0].(*gamelift.DeleteGameSessionQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGameSessionQueue indicates an expected call of DeleteGameSessionQueue. +func (mr *MockGameLiftAPIMockRecorder) DeleteGameSessionQueue(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGameSessionQueue", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteGameSessionQueue), arg0) +} + +// DeleteGameSessionQueueRequest mocks base method. +func (m *MockGameLiftAPI) DeleteGameSessionQueueRequest(arg0 *gamelift.DeleteGameSessionQueueInput) (*request.Request, *gamelift.DeleteGameSessionQueueOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGameSessionQueueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteGameSessionQueueOutput) + return ret0, ret1 +} + +// DeleteGameSessionQueueRequest indicates an expected call of DeleteGameSessionQueueRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteGameSessionQueueRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGameSessionQueueRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteGameSessionQueueRequest), arg0) +} + +// DeleteGameSessionQueueWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteGameSessionQueueWithContext(arg0 aws.Context, arg1 *gamelift.DeleteGameSessionQueueInput, arg2 ...request.Option) (*gamelift.DeleteGameSessionQueueOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteGameSessionQueueWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteGameSessionQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGameSessionQueueWithContext indicates an expected call of DeleteGameSessionQueueWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteGameSessionQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGameSessionQueueWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteGameSessionQueueWithContext), varargs...) +} + +// DeleteLocation mocks base method. +func (m *MockGameLiftAPI) DeleteLocation(arg0 *gamelift.DeleteLocationInput) (*gamelift.DeleteLocationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLocation", arg0) + ret0, _ := ret[0].(*gamelift.DeleteLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLocation indicates an expected call of DeleteLocation. +func (mr *MockGameLiftAPIMockRecorder) DeleteLocation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocation", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteLocation), arg0) +} + +// DeleteLocationRequest mocks base method. +func (m *MockGameLiftAPI) DeleteLocationRequest(arg0 *gamelift.DeleteLocationInput) (*request.Request, *gamelift.DeleteLocationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLocationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteLocationOutput) + return ret0, ret1 +} + +// DeleteLocationRequest indicates an expected call of DeleteLocationRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteLocationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteLocationRequest), arg0) +} + +// DeleteLocationWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteLocationWithContext(arg0 aws.Context, arg1 *gamelift.DeleteLocationInput, arg2 ...request.Option) (*gamelift.DeleteLocationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLocationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLocationWithContext indicates an expected call of DeleteLocationWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteLocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteLocationWithContext), varargs...) +} + +// DeleteMatchmakingConfiguration mocks base method. +func (m *MockGameLiftAPI) DeleteMatchmakingConfiguration(arg0 *gamelift.DeleteMatchmakingConfigurationInput) (*gamelift.DeleteMatchmakingConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMatchmakingConfiguration", arg0) + ret0, _ := ret[0].(*gamelift.DeleteMatchmakingConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMatchmakingConfiguration indicates an expected call of DeleteMatchmakingConfiguration. +func (mr *MockGameLiftAPIMockRecorder) DeleteMatchmakingConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMatchmakingConfiguration", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteMatchmakingConfiguration), arg0) +} + +// DeleteMatchmakingConfigurationRequest mocks base method. +func (m *MockGameLiftAPI) DeleteMatchmakingConfigurationRequest(arg0 *gamelift.DeleteMatchmakingConfigurationInput) (*request.Request, *gamelift.DeleteMatchmakingConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMatchmakingConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteMatchmakingConfigurationOutput) + return ret0, ret1 +} + +// DeleteMatchmakingConfigurationRequest indicates an expected call of DeleteMatchmakingConfigurationRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteMatchmakingConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMatchmakingConfigurationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteMatchmakingConfigurationRequest), arg0) +} + +// DeleteMatchmakingConfigurationWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteMatchmakingConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.DeleteMatchmakingConfigurationInput, arg2 ...request.Option) (*gamelift.DeleteMatchmakingConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteMatchmakingConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteMatchmakingConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMatchmakingConfigurationWithContext indicates an expected call of DeleteMatchmakingConfigurationWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteMatchmakingConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMatchmakingConfigurationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteMatchmakingConfigurationWithContext), varargs...) +} + +// DeleteMatchmakingRuleSet mocks base method. +func (m *MockGameLiftAPI) DeleteMatchmakingRuleSet(arg0 *gamelift.DeleteMatchmakingRuleSetInput) (*gamelift.DeleteMatchmakingRuleSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMatchmakingRuleSet", arg0) + ret0, _ := ret[0].(*gamelift.DeleteMatchmakingRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMatchmakingRuleSet indicates an expected call of DeleteMatchmakingRuleSet. +func (mr *MockGameLiftAPIMockRecorder) DeleteMatchmakingRuleSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMatchmakingRuleSet", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteMatchmakingRuleSet), arg0) +} + +// DeleteMatchmakingRuleSetRequest mocks base method. +func (m *MockGameLiftAPI) DeleteMatchmakingRuleSetRequest(arg0 *gamelift.DeleteMatchmakingRuleSetInput) (*request.Request, *gamelift.DeleteMatchmakingRuleSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteMatchmakingRuleSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteMatchmakingRuleSetOutput) + return ret0, ret1 +} + +// DeleteMatchmakingRuleSetRequest indicates an expected call of DeleteMatchmakingRuleSetRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteMatchmakingRuleSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMatchmakingRuleSetRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteMatchmakingRuleSetRequest), arg0) +} + +// DeleteMatchmakingRuleSetWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteMatchmakingRuleSetWithContext(arg0 aws.Context, arg1 *gamelift.DeleteMatchmakingRuleSetInput, arg2 ...request.Option) (*gamelift.DeleteMatchmakingRuleSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteMatchmakingRuleSetWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteMatchmakingRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteMatchmakingRuleSetWithContext indicates an expected call of DeleteMatchmakingRuleSetWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteMatchmakingRuleSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMatchmakingRuleSetWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteMatchmakingRuleSetWithContext), varargs...) +} + +// DeleteScalingPolicy mocks base method. +func (m *MockGameLiftAPI) DeleteScalingPolicy(arg0 *gamelift.DeleteScalingPolicyInput) (*gamelift.DeleteScalingPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteScalingPolicy", arg0) + ret0, _ := ret[0].(*gamelift.DeleteScalingPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteScalingPolicy indicates an expected call of DeleteScalingPolicy. +func (mr *MockGameLiftAPIMockRecorder) DeleteScalingPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScalingPolicy", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteScalingPolicy), arg0) +} + +// DeleteScalingPolicyRequest mocks base method. +func (m *MockGameLiftAPI) DeleteScalingPolicyRequest(arg0 *gamelift.DeleteScalingPolicyInput) (*request.Request, *gamelift.DeleteScalingPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteScalingPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteScalingPolicyOutput) + return ret0, ret1 +} + +// DeleteScalingPolicyRequest indicates an expected call of DeleteScalingPolicyRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteScalingPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScalingPolicyRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteScalingPolicyRequest), arg0) +} + +// DeleteScalingPolicyWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteScalingPolicyWithContext(arg0 aws.Context, arg1 *gamelift.DeleteScalingPolicyInput, arg2 ...request.Option) (*gamelift.DeleteScalingPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteScalingPolicyWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteScalingPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteScalingPolicyWithContext indicates an expected call of DeleteScalingPolicyWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteScalingPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScalingPolicyWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteScalingPolicyWithContext), varargs...) +} + +// DeleteScript mocks base method. +func (m *MockGameLiftAPI) DeleteScript(arg0 *gamelift.DeleteScriptInput) (*gamelift.DeleteScriptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteScript", arg0) + ret0, _ := ret[0].(*gamelift.DeleteScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteScript indicates an expected call of DeleteScript. +func (mr *MockGameLiftAPIMockRecorder) DeleteScript(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScript", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteScript), arg0) +} + +// DeleteScriptRequest mocks base method. +func (m *MockGameLiftAPI) DeleteScriptRequest(arg0 *gamelift.DeleteScriptInput) (*request.Request, *gamelift.DeleteScriptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteScriptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteScriptOutput) + return ret0, ret1 +} + +// DeleteScriptRequest indicates an expected call of DeleteScriptRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteScriptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScriptRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteScriptRequest), arg0) +} + +// DeleteScriptWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteScriptWithContext(arg0 aws.Context, arg1 *gamelift.DeleteScriptInput, arg2 ...request.Option) (*gamelift.DeleteScriptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteScriptWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteScriptWithContext indicates an expected call of DeleteScriptWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteScriptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScriptWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteScriptWithContext), varargs...) +} + +// DeleteVpcPeeringAuthorization mocks base method. +func (m *MockGameLiftAPI) DeleteVpcPeeringAuthorization(arg0 *gamelift.DeleteVpcPeeringAuthorizationInput) (*gamelift.DeleteVpcPeeringAuthorizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcPeeringAuthorization", arg0) + ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcPeeringAuthorization indicates an expected call of DeleteVpcPeeringAuthorization. +func (mr *MockGameLiftAPIMockRecorder) DeleteVpcPeeringAuthorization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringAuthorization", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteVpcPeeringAuthorization), arg0) +} + +// DeleteVpcPeeringAuthorizationRequest mocks base method. +func (m *MockGameLiftAPI) DeleteVpcPeeringAuthorizationRequest(arg0 *gamelift.DeleteVpcPeeringAuthorizationInput) (*request.Request, *gamelift.DeleteVpcPeeringAuthorizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcPeeringAuthorizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteVpcPeeringAuthorizationOutput) + return ret0, ret1 +} + +// DeleteVpcPeeringAuthorizationRequest indicates an expected call of DeleteVpcPeeringAuthorizationRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteVpcPeeringAuthorizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringAuthorizationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteVpcPeeringAuthorizationRequest), arg0) +} + +// DeleteVpcPeeringAuthorizationWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteVpcPeeringAuthorizationWithContext(arg0 aws.Context, arg1 *gamelift.DeleteVpcPeeringAuthorizationInput, arg2 ...request.Option) (*gamelift.DeleteVpcPeeringAuthorizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpcPeeringAuthorizationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcPeeringAuthorizationWithContext indicates an expected call of DeleteVpcPeeringAuthorizationWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteVpcPeeringAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringAuthorizationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteVpcPeeringAuthorizationWithContext), varargs...) +} + +// DeleteVpcPeeringConnection mocks base method. +func (m *MockGameLiftAPI) DeleteVpcPeeringConnection(arg0 *gamelift.DeleteVpcPeeringConnectionInput) (*gamelift.DeleteVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcPeeringConnection", arg0) + ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcPeeringConnection indicates an expected call of DeleteVpcPeeringConnection. +func (mr *MockGameLiftAPIMockRecorder) DeleteVpcPeeringConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnection", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteVpcPeeringConnection), arg0) +} + +// DeleteVpcPeeringConnectionRequest mocks base method. +func (m *MockGameLiftAPI) DeleteVpcPeeringConnectionRequest(arg0 *gamelift.DeleteVpcPeeringConnectionInput) (*request.Request, *gamelift.DeleteVpcPeeringConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeleteVpcPeeringConnectionOutput) + return ret0, ret1 +} + +// DeleteVpcPeeringConnectionRequest indicates an expected call of DeleteVpcPeeringConnectionRequest. +func (mr *MockGameLiftAPIMockRecorder) DeleteVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteVpcPeeringConnectionRequest), arg0) +} + +// DeleteVpcPeeringConnectionWithContext mocks base method. +func (m *MockGameLiftAPI) DeleteVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *gamelift.DeleteVpcPeeringConnectionInput, arg2 ...request.Option) (*gamelift.DeleteVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeleteVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcPeeringConnectionWithContext indicates an expected call of DeleteVpcPeeringConnectionWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeleteVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeleteVpcPeeringConnectionWithContext), varargs...) +} + +// DeregisterCompute mocks base method. +func (m *MockGameLiftAPI) DeregisterCompute(arg0 *gamelift.DeregisterComputeInput) (*gamelift.DeregisterComputeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterCompute", arg0) + ret0, _ := ret[0].(*gamelift.DeregisterComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterCompute indicates an expected call of DeregisterCompute. +func (mr *MockGameLiftAPIMockRecorder) DeregisterCompute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterCompute", reflect.TypeOf((*MockGameLiftAPI)(nil).DeregisterCompute), arg0) +} + +// DeregisterComputeRequest mocks base method. +func (m *MockGameLiftAPI) DeregisterComputeRequest(arg0 *gamelift.DeregisterComputeInput) (*request.Request, *gamelift.DeregisterComputeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterComputeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeregisterComputeOutput) + return ret0, ret1 +} + +// DeregisterComputeRequest indicates an expected call of DeregisterComputeRequest. +func (mr *MockGameLiftAPIMockRecorder) DeregisterComputeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterComputeRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeregisterComputeRequest), arg0) +} + +// DeregisterComputeWithContext mocks base method. +func (m *MockGameLiftAPI) DeregisterComputeWithContext(arg0 aws.Context, arg1 *gamelift.DeregisterComputeInput, arg2 ...request.Option) (*gamelift.DeregisterComputeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeregisterComputeWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeregisterComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterComputeWithContext indicates an expected call of DeregisterComputeWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeregisterComputeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterComputeWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeregisterComputeWithContext), varargs...) +} + +// DeregisterGameServer mocks base method. +func (m *MockGameLiftAPI) DeregisterGameServer(arg0 *gamelift.DeregisterGameServerInput) (*gamelift.DeregisterGameServerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterGameServer", arg0) + ret0, _ := ret[0].(*gamelift.DeregisterGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterGameServer indicates an expected call of DeregisterGameServer. +func (mr *MockGameLiftAPIMockRecorder) DeregisterGameServer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterGameServer", reflect.TypeOf((*MockGameLiftAPI)(nil).DeregisterGameServer), arg0) +} + +// DeregisterGameServerRequest mocks base method. +func (m *MockGameLiftAPI) DeregisterGameServerRequest(arg0 *gamelift.DeregisterGameServerInput) (*request.Request, *gamelift.DeregisterGameServerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterGameServerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DeregisterGameServerOutput) + return ret0, ret1 +} + +// DeregisterGameServerRequest indicates an expected call of DeregisterGameServerRequest. +func (mr *MockGameLiftAPIMockRecorder) DeregisterGameServerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterGameServerRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DeregisterGameServerRequest), arg0) +} + +// DeregisterGameServerWithContext mocks base method. +func (m *MockGameLiftAPI) DeregisterGameServerWithContext(arg0 aws.Context, arg1 *gamelift.DeregisterGameServerInput, arg2 ...request.Option) (*gamelift.DeregisterGameServerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeregisterGameServerWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DeregisterGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterGameServerWithContext indicates an expected call of DeregisterGameServerWithContext. +func (mr *MockGameLiftAPIMockRecorder) DeregisterGameServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterGameServerWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DeregisterGameServerWithContext), varargs...) +} + +// DescribeAlias mocks base method. +func (m *MockGameLiftAPI) DescribeAlias(arg0 *gamelift.DescribeAliasInput) (*gamelift.DescribeAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAlias", arg0) + ret0, _ := ret[0].(*gamelift.DescribeAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAlias indicates an expected call of DescribeAlias. +func (mr *MockGameLiftAPIMockRecorder) DescribeAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAlias", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeAlias), arg0) +} + +// DescribeAliasRequest mocks base method. +func (m *MockGameLiftAPI) DescribeAliasRequest(arg0 *gamelift.DescribeAliasInput) (*request.Request, *gamelift.DescribeAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeAliasOutput) + return ret0, ret1 +} + +// DescribeAliasRequest indicates an expected call of DescribeAliasRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAliasRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeAliasRequest), arg0) +} + +// DescribeAliasWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeAliasWithContext(arg0 aws.Context, arg1 *gamelift.DescribeAliasInput, arg2 ...request.Option) (*gamelift.DescribeAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAliasWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAliasWithContext indicates an expected call of DescribeAliasWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAliasWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeAliasWithContext), varargs...) +} + +// DescribeBuild mocks base method. +func (m *MockGameLiftAPI) DescribeBuild(arg0 *gamelift.DescribeBuildInput) (*gamelift.DescribeBuildOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeBuild", arg0) + ret0, _ := ret[0].(*gamelift.DescribeBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBuild indicates an expected call of DescribeBuild. +func (mr *MockGameLiftAPIMockRecorder) DescribeBuild(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBuild", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeBuild), arg0) +} + +// DescribeBuildRequest mocks base method. +func (m *MockGameLiftAPI) DescribeBuildRequest(arg0 *gamelift.DescribeBuildInput) (*request.Request, *gamelift.DescribeBuildOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeBuildRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeBuildOutput) + return ret0, ret1 +} + +// DescribeBuildRequest indicates an expected call of DescribeBuildRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeBuildRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBuildRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeBuildRequest), arg0) +} + +// DescribeBuildWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeBuildWithContext(arg0 aws.Context, arg1 *gamelift.DescribeBuildInput, arg2 ...request.Option) (*gamelift.DescribeBuildOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeBuildWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBuildWithContext indicates an expected call of DescribeBuildWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeBuildWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBuildWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeBuildWithContext), varargs...) +} + +// DescribeCompute mocks base method. +func (m *MockGameLiftAPI) DescribeCompute(arg0 *gamelift.DescribeComputeInput) (*gamelift.DescribeComputeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCompute", arg0) + ret0, _ := ret[0].(*gamelift.DescribeComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCompute indicates an expected call of DescribeCompute. +func (mr *MockGameLiftAPIMockRecorder) DescribeCompute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCompute", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeCompute), arg0) +} + +// DescribeComputeRequest mocks base method. +func (m *MockGameLiftAPI) DescribeComputeRequest(arg0 *gamelift.DescribeComputeInput) (*request.Request, *gamelift.DescribeComputeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeComputeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeComputeOutput) + return ret0, ret1 +} + +// DescribeComputeRequest indicates an expected call of DescribeComputeRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeComputeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComputeRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeComputeRequest), arg0) +} + +// DescribeComputeWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeComputeWithContext(arg0 aws.Context, arg1 *gamelift.DescribeComputeInput, arg2 ...request.Option) (*gamelift.DescribeComputeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeComputeWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeComputeWithContext indicates an expected call of DescribeComputeWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeComputeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComputeWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeComputeWithContext), varargs...) +} + +// DescribeContainerGroupDefinition mocks base method. +func (m *MockGameLiftAPI) DescribeContainerGroupDefinition(arg0 *gamelift.DescribeContainerGroupDefinitionInput) (*gamelift.DescribeContainerGroupDefinitionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeContainerGroupDefinition", arg0) + ret0, _ := ret[0].(*gamelift.DescribeContainerGroupDefinitionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeContainerGroupDefinition indicates an expected call of DescribeContainerGroupDefinition. +func (mr *MockGameLiftAPIMockRecorder) DescribeContainerGroupDefinition(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerGroupDefinition", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeContainerGroupDefinition), arg0) +} + +// DescribeContainerGroupDefinitionRequest mocks base method. +func (m *MockGameLiftAPI) DescribeContainerGroupDefinitionRequest(arg0 *gamelift.DescribeContainerGroupDefinitionInput) (*request.Request, *gamelift.DescribeContainerGroupDefinitionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeContainerGroupDefinitionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeContainerGroupDefinitionOutput) + return ret0, ret1 +} + +// DescribeContainerGroupDefinitionRequest indicates an expected call of DescribeContainerGroupDefinitionRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeContainerGroupDefinitionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerGroupDefinitionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeContainerGroupDefinitionRequest), arg0) +} + +// DescribeContainerGroupDefinitionWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeContainerGroupDefinitionWithContext(arg0 aws.Context, arg1 *gamelift.DescribeContainerGroupDefinitionInput, arg2 ...request.Option) (*gamelift.DescribeContainerGroupDefinitionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeContainerGroupDefinitionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeContainerGroupDefinitionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeContainerGroupDefinitionWithContext indicates an expected call of DescribeContainerGroupDefinitionWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeContainerGroupDefinitionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainerGroupDefinitionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeContainerGroupDefinitionWithContext), varargs...) +} + +// DescribeEC2InstanceLimits mocks base method. +func (m *MockGameLiftAPI) DescribeEC2InstanceLimits(arg0 *gamelift.DescribeEC2InstanceLimitsInput) (*gamelift.DescribeEC2InstanceLimitsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEC2InstanceLimits", arg0) + ret0, _ := ret[0].(*gamelift.DescribeEC2InstanceLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEC2InstanceLimits indicates an expected call of DescribeEC2InstanceLimits. +func (mr *MockGameLiftAPIMockRecorder) DescribeEC2InstanceLimits(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEC2InstanceLimits", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeEC2InstanceLimits), arg0) +} + +// DescribeEC2InstanceLimitsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeEC2InstanceLimitsRequest(arg0 *gamelift.DescribeEC2InstanceLimitsInput) (*request.Request, *gamelift.DescribeEC2InstanceLimitsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEC2InstanceLimitsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeEC2InstanceLimitsOutput) + return ret0, ret1 +} + +// DescribeEC2InstanceLimitsRequest indicates an expected call of DescribeEC2InstanceLimitsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeEC2InstanceLimitsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEC2InstanceLimitsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeEC2InstanceLimitsRequest), arg0) +} + +// DescribeEC2InstanceLimitsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeEC2InstanceLimitsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeEC2InstanceLimitsInput, arg2 ...request.Option) (*gamelift.DescribeEC2InstanceLimitsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEC2InstanceLimitsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeEC2InstanceLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEC2InstanceLimitsWithContext indicates an expected call of DescribeEC2InstanceLimitsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeEC2InstanceLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEC2InstanceLimitsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeEC2InstanceLimitsWithContext), varargs...) +} + +// DescribeFleetAttributes mocks base method. +func (m *MockGameLiftAPI) DescribeFleetAttributes(arg0 *gamelift.DescribeFleetAttributesInput) (*gamelift.DescribeFleetAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetAttributes", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetAttributes indicates an expected call of DescribeFleetAttributes. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetAttributes", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetAttributes), arg0) +} + +// DescribeFleetAttributesPages mocks base method. +func (m *MockGameLiftAPI) DescribeFleetAttributesPages(arg0 *gamelift.DescribeFleetAttributesInput, arg1 func(*gamelift.DescribeFleetAttributesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetAttributesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetAttributesPages indicates an expected call of DescribeFleetAttributesPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetAttributesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetAttributesPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetAttributesPages), arg0, arg1) +} + +// DescribeFleetAttributesPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetAttributesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetAttributesInput, arg2 func(*gamelift.DescribeFleetAttributesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetAttributesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetAttributesPagesWithContext indicates an expected call of DescribeFleetAttributesPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetAttributesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetAttributesPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetAttributesPagesWithContext), varargs...) +} + +// DescribeFleetAttributesRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetAttributesRequest(arg0 *gamelift.DescribeFleetAttributesInput) (*request.Request, *gamelift.DescribeFleetAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetAttributesOutput) + return ret0, ret1 +} + +// DescribeFleetAttributesRequest indicates an expected call of DescribeFleetAttributesRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetAttributesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetAttributesRequest), arg0) +} + +// DescribeFleetAttributesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetAttributesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetAttributesInput, arg2 ...request.Option) (*gamelift.DescribeFleetAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetAttributesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetAttributesWithContext indicates an expected call of DescribeFleetAttributesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetAttributesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetAttributesWithContext), varargs...) +} + +// DescribeFleetCapacity mocks base method. +func (m *MockGameLiftAPI) DescribeFleetCapacity(arg0 *gamelift.DescribeFleetCapacityInput) (*gamelift.DescribeFleetCapacityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetCapacity", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetCapacity indicates an expected call of DescribeFleetCapacity. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetCapacity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetCapacity", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetCapacity), arg0) +} + +// DescribeFleetCapacityPages mocks base method. +func (m *MockGameLiftAPI) DescribeFleetCapacityPages(arg0 *gamelift.DescribeFleetCapacityInput, arg1 func(*gamelift.DescribeFleetCapacityOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetCapacityPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetCapacityPages indicates an expected call of DescribeFleetCapacityPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetCapacityPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetCapacityPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetCapacityPages), arg0, arg1) +} + +// DescribeFleetCapacityPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetCapacityPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetCapacityInput, arg2 func(*gamelift.DescribeFleetCapacityOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetCapacityPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetCapacityPagesWithContext indicates an expected call of DescribeFleetCapacityPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetCapacityPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetCapacityPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetCapacityPagesWithContext), varargs...) +} + +// DescribeFleetCapacityRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetCapacityRequest(arg0 *gamelift.DescribeFleetCapacityInput) (*request.Request, *gamelift.DescribeFleetCapacityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetCapacityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetCapacityOutput) + return ret0, ret1 +} + +// DescribeFleetCapacityRequest indicates an expected call of DescribeFleetCapacityRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetCapacityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetCapacityRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetCapacityRequest), arg0) +} + +// DescribeFleetCapacityWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetCapacityWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetCapacityInput, arg2 ...request.Option) (*gamelift.DescribeFleetCapacityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetCapacityWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetCapacityWithContext indicates an expected call of DescribeFleetCapacityWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetCapacityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetCapacityWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetCapacityWithContext), varargs...) +} + +// DescribeFleetEvents mocks base method. +func (m *MockGameLiftAPI) DescribeFleetEvents(arg0 *gamelift.DescribeFleetEventsInput) (*gamelift.DescribeFleetEventsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetEvents", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetEventsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetEvents indicates an expected call of DescribeFleetEvents. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetEvents(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetEvents", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetEvents), arg0) +} + +// DescribeFleetEventsPages mocks base method. +func (m *MockGameLiftAPI) DescribeFleetEventsPages(arg0 *gamelift.DescribeFleetEventsInput, arg1 func(*gamelift.DescribeFleetEventsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetEventsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetEventsPages indicates an expected call of DescribeFleetEventsPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetEventsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetEventsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetEventsPages), arg0, arg1) +} + +// DescribeFleetEventsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetEventsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetEventsInput, arg2 func(*gamelift.DescribeFleetEventsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetEventsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetEventsPagesWithContext indicates an expected call of DescribeFleetEventsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetEventsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetEventsPagesWithContext), varargs...) +} + +// DescribeFleetEventsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetEventsRequest(arg0 *gamelift.DescribeFleetEventsInput) (*request.Request, *gamelift.DescribeFleetEventsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetEventsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetEventsOutput) + return ret0, ret1 +} + +// DescribeFleetEventsRequest indicates an expected call of DescribeFleetEventsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetEventsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetEventsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetEventsRequest), arg0) +} + +// DescribeFleetEventsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetEventsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetEventsInput, arg2 ...request.Option) (*gamelift.DescribeFleetEventsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetEventsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetEventsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetEventsWithContext indicates an expected call of DescribeFleetEventsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetEventsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetEventsWithContext), varargs...) +} + +// DescribeFleetLocationAttributes mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationAttributes(arg0 *gamelift.DescribeFleetLocationAttributesInput) (*gamelift.DescribeFleetLocationAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetLocationAttributes", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetLocationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetLocationAttributes indicates an expected call of DescribeFleetLocationAttributes. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationAttributes", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationAttributes), arg0) +} + +// DescribeFleetLocationAttributesPages mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationAttributesPages(arg0 *gamelift.DescribeFleetLocationAttributesInput, arg1 func(*gamelift.DescribeFleetLocationAttributesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetLocationAttributesPages indicates an expected call of DescribeFleetLocationAttributesPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationAttributesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationAttributesPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationAttributesPages), arg0, arg1) +} + +// DescribeFleetLocationAttributesPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationAttributesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationAttributesInput, arg2 func(*gamelift.DescribeFleetLocationAttributesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetLocationAttributesPagesWithContext indicates an expected call of DescribeFleetLocationAttributesPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationAttributesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationAttributesPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationAttributesPagesWithContext), varargs...) +} + +// DescribeFleetLocationAttributesRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationAttributesRequest(arg0 *gamelift.DescribeFleetLocationAttributesInput) (*request.Request, *gamelift.DescribeFleetLocationAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetLocationAttributesOutput) + return ret0, ret1 +} + +// DescribeFleetLocationAttributesRequest indicates an expected call of DescribeFleetLocationAttributesRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationAttributesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationAttributesRequest), arg0) +} + +// DescribeFleetLocationAttributesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationAttributesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationAttributesInput, arg2 ...request.Option) (*gamelift.DescribeFleetLocationAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetLocationAttributesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetLocationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetLocationAttributesWithContext indicates an expected call of DescribeFleetLocationAttributesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationAttributesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationAttributesWithContext), varargs...) +} + +// DescribeFleetLocationCapacity mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationCapacity(arg0 *gamelift.DescribeFleetLocationCapacityInput) (*gamelift.DescribeFleetLocationCapacityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetLocationCapacity", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetLocationCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetLocationCapacity indicates an expected call of DescribeFleetLocationCapacity. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationCapacity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationCapacity", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationCapacity), arg0) +} + +// DescribeFleetLocationCapacityRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationCapacityRequest(arg0 *gamelift.DescribeFleetLocationCapacityInput) (*request.Request, *gamelift.DescribeFleetLocationCapacityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetLocationCapacityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetLocationCapacityOutput) + return ret0, ret1 +} + +// DescribeFleetLocationCapacityRequest indicates an expected call of DescribeFleetLocationCapacityRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationCapacityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationCapacityRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationCapacityRequest), arg0) +} + +// DescribeFleetLocationCapacityWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationCapacityWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationCapacityInput, arg2 ...request.Option) (*gamelift.DescribeFleetLocationCapacityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetLocationCapacityWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetLocationCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetLocationCapacityWithContext indicates an expected call of DescribeFleetLocationCapacityWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationCapacityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationCapacityWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationCapacityWithContext), varargs...) +} + +// DescribeFleetLocationUtilization mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationUtilization(arg0 *gamelift.DescribeFleetLocationUtilizationInput) (*gamelift.DescribeFleetLocationUtilizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetLocationUtilization", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetLocationUtilizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetLocationUtilization indicates an expected call of DescribeFleetLocationUtilization. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationUtilization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationUtilization", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationUtilization), arg0) +} + +// DescribeFleetLocationUtilizationRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationUtilizationRequest(arg0 *gamelift.DescribeFleetLocationUtilizationInput) (*request.Request, *gamelift.DescribeFleetLocationUtilizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetLocationUtilizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetLocationUtilizationOutput) + return ret0, ret1 +} + +// DescribeFleetLocationUtilizationRequest indicates an expected call of DescribeFleetLocationUtilizationRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationUtilizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationUtilizationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationUtilizationRequest), arg0) +} + +// DescribeFleetLocationUtilizationWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetLocationUtilizationWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetLocationUtilizationInput, arg2 ...request.Option) (*gamelift.DescribeFleetLocationUtilizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetLocationUtilizationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetLocationUtilizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetLocationUtilizationWithContext indicates an expected call of DescribeFleetLocationUtilizationWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetLocationUtilizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetLocationUtilizationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetLocationUtilizationWithContext), varargs...) +} + +// DescribeFleetPortSettings mocks base method. +func (m *MockGameLiftAPI) DescribeFleetPortSettings(arg0 *gamelift.DescribeFleetPortSettingsInput) (*gamelift.DescribeFleetPortSettingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetPortSettings", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetPortSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetPortSettings indicates an expected call of DescribeFleetPortSettings. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetPortSettings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetPortSettings", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetPortSettings), arg0) +} + +// DescribeFleetPortSettingsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetPortSettingsRequest(arg0 *gamelift.DescribeFleetPortSettingsInput) (*request.Request, *gamelift.DescribeFleetPortSettingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetPortSettingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetPortSettingsOutput) + return ret0, ret1 +} + +// DescribeFleetPortSettingsRequest indicates an expected call of DescribeFleetPortSettingsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetPortSettingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetPortSettingsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetPortSettingsRequest), arg0) +} + +// DescribeFleetPortSettingsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetPortSettingsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetPortSettingsInput, arg2 ...request.Option) (*gamelift.DescribeFleetPortSettingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetPortSettingsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetPortSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetPortSettingsWithContext indicates an expected call of DescribeFleetPortSettingsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetPortSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetPortSettingsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetPortSettingsWithContext), varargs...) +} + +// DescribeFleetUtilization mocks base method. +func (m *MockGameLiftAPI) DescribeFleetUtilization(arg0 *gamelift.DescribeFleetUtilizationInput) (*gamelift.DescribeFleetUtilizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetUtilization", arg0) + ret0, _ := ret[0].(*gamelift.DescribeFleetUtilizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetUtilization indicates an expected call of DescribeFleetUtilization. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetUtilization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetUtilization", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetUtilization), arg0) +} + +// DescribeFleetUtilizationPages mocks base method. +func (m *MockGameLiftAPI) DescribeFleetUtilizationPages(arg0 *gamelift.DescribeFleetUtilizationInput, arg1 func(*gamelift.DescribeFleetUtilizationOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetUtilizationPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetUtilizationPages indicates an expected call of DescribeFleetUtilizationPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetUtilizationPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetUtilizationPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetUtilizationPages), arg0, arg1) +} + +// DescribeFleetUtilizationPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetUtilizationPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetUtilizationInput, arg2 func(*gamelift.DescribeFleetUtilizationOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetUtilizationPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetUtilizationPagesWithContext indicates an expected call of DescribeFleetUtilizationPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetUtilizationPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetUtilizationPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetUtilizationPagesWithContext), varargs...) +} + +// DescribeFleetUtilizationRequest mocks base method. +func (m *MockGameLiftAPI) DescribeFleetUtilizationRequest(arg0 *gamelift.DescribeFleetUtilizationInput) (*request.Request, *gamelift.DescribeFleetUtilizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetUtilizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeFleetUtilizationOutput) + return ret0, ret1 +} + +// DescribeFleetUtilizationRequest indicates an expected call of DescribeFleetUtilizationRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetUtilizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetUtilizationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetUtilizationRequest), arg0) +} + +// DescribeFleetUtilizationWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeFleetUtilizationWithContext(arg0 aws.Context, arg1 *gamelift.DescribeFleetUtilizationInput, arg2 ...request.Option) (*gamelift.DescribeFleetUtilizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetUtilizationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeFleetUtilizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetUtilizationWithContext indicates an expected call of DescribeFleetUtilizationWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeFleetUtilizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetUtilizationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeFleetUtilizationWithContext), varargs...) +} + +// DescribeGameServer mocks base method. +func (m *MockGameLiftAPI) DescribeGameServer(arg0 *gamelift.DescribeGameServerInput) (*gamelift.DescribeGameServerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameServer", arg0) + ret0, _ := ret[0].(*gamelift.DescribeGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameServer indicates an expected call of DescribeGameServer. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServer", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServer), arg0) +} + +// DescribeGameServerGroup mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerGroup(arg0 *gamelift.DescribeGameServerGroupInput) (*gamelift.DescribeGameServerGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameServerGroup", arg0) + ret0, _ := ret[0].(*gamelift.DescribeGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameServerGroup indicates an expected call of DescribeGameServerGroup. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerGroup", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerGroup), arg0) +} + +// DescribeGameServerGroupRequest mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerGroupRequest(arg0 *gamelift.DescribeGameServerGroupInput) (*request.Request, *gamelift.DescribeGameServerGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameServerGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeGameServerGroupOutput) + return ret0, ret1 +} + +// DescribeGameServerGroupRequest indicates an expected call of DescribeGameServerGroupRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerGroupRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerGroupRequest), arg0) +} + +// DescribeGameServerGroupWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerGroupInput, arg2 ...request.Option) (*gamelift.DescribeGameServerGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameServerGroupWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameServerGroupWithContext indicates an expected call of DescribeGameServerGroupWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerGroupWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerGroupWithContext), varargs...) +} + +// DescribeGameServerInstances mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerInstances(arg0 *gamelift.DescribeGameServerInstancesInput) (*gamelift.DescribeGameServerInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameServerInstances", arg0) + ret0, _ := ret[0].(*gamelift.DescribeGameServerInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameServerInstances indicates an expected call of DescribeGameServerInstances. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerInstances", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerInstances), arg0) +} + +// DescribeGameServerInstancesPages mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerInstancesPages(arg0 *gamelift.DescribeGameServerInstancesInput, arg1 func(*gamelift.DescribeGameServerInstancesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameServerInstancesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameServerInstancesPages indicates an expected call of DescribeGameServerInstancesPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerInstancesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerInstancesPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerInstancesPages), arg0, arg1) +} + +// DescribeGameServerInstancesPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerInstancesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerInstancesInput, arg2 func(*gamelift.DescribeGameServerInstancesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameServerInstancesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameServerInstancesPagesWithContext indicates an expected call of DescribeGameServerInstancesPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerInstancesPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerInstancesPagesWithContext), varargs...) +} + +// DescribeGameServerInstancesRequest mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerInstancesRequest(arg0 *gamelift.DescribeGameServerInstancesInput) (*request.Request, *gamelift.DescribeGameServerInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameServerInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeGameServerInstancesOutput) + return ret0, ret1 +} + +// DescribeGameServerInstancesRequest indicates an expected call of DescribeGameServerInstancesRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerInstancesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerInstancesRequest), arg0) +} + +// DescribeGameServerInstancesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerInstancesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerInstancesInput, arg2 ...request.Option) (*gamelift.DescribeGameServerInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameServerInstancesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeGameServerInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameServerInstancesWithContext indicates an expected call of DescribeGameServerInstancesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerInstancesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerInstancesWithContext), varargs...) +} + +// DescribeGameServerRequest mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerRequest(arg0 *gamelift.DescribeGameServerInput) (*request.Request, *gamelift.DescribeGameServerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameServerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeGameServerOutput) + return ret0, ret1 +} + +// DescribeGameServerRequest indicates an expected call of DescribeGameServerRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerRequest), arg0) +} + +// DescribeGameServerWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameServerWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameServerInput, arg2 ...request.Option) (*gamelift.DescribeGameServerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameServerWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameServerWithContext indicates an expected call of DescribeGameServerWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameServerWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameServerWithContext), varargs...) +} + +// DescribeGameSessionDetails mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionDetails(arg0 *gamelift.DescribeGameSessionDetailsInput) (*gamelift.DescribeGameSessionDetailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionDetails", arg0) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessionDetails indicates an expected call of DescribeGameSessionDetails. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionDetails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionDetails", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionDetails), arg0) +} + +// DescribeGameSessionDetailsPages mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionDetailsPages(arg0 *gamelift.DescribeGameSessionDetailsInput, arg1 func(*gamelift.DescribeGameSessionDetailsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionDetailsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameSessionDetailsPages indicates an expected call of DescribeGameSessionDetailsPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionDetailsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionDetailsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionDetailsPages), arg0, arg1) +} + +// DescribeGameSessionDetailsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionDetailsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionDetailsInput, arg2 func(*gamelift.DescribeGameSessionDetailsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameSessionDetailsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameSessionDetailsPagesWithContext indicates an expected call of DescribeGameSessionDetailsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionDetailsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionDetailsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionDetailsPagesWithContext), varargs...) +} + +// DescribeGameSessionDetailsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionDetailsRequest(arg0 *gamelift.DescribeGameSessionDetailsInput) (*request.Request, *gamelift.DescribeGameSessionDetailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionDetailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeGameSessionDetailsOutput) + return ret0, ret1 +} + +// DescribeGameSessionDetailsRequest indicates an expected call of DescribeGameSessionDetailsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionDetailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionDetailsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionDetailsRequest), arg0) +} + +// DescribeGameSessionDetailsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionDetailsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionDetailsInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionDetailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameSessionDetailsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessionDetailsWithContext indicates an expected call of DescribeGameSessionDetailsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionDetailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionDetailsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionDetailsWithContext), varargs...) +} + +// DescribeGameSessionPlacement mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionPlacement(arg0 *gamelift.DescribeGameSessionPlacementInput) (*gamelift.DescribeGameSessionPlacementOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionPlacement", arg0) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionPlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessionPlacement indicates an expected call of DescribeGameSessionPlacement. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionPlacement(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionPlacement", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionPlacement), arg0) +} + +// DescribeGameSessionPlacementRequest mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionPlacementRequest(arg0 *gamelift.DescribeGameSessionPlacementInput) (*request.Request, *gamelift.DescribeGameSessionPlacementOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionPlacementRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeGameSessionPlacementOutput) + return ret0, ret1 +} + +// DescribeGameSessionPlacementRequest indicates an expected call of DescribeGameSessionPlacementRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionPlacementRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionPlacementRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionPlacementRequest), arg0) +} + +// DescribeGameSessionPlacementWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionPlacementWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionPlacementInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionPlacementOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameSessionPlacementWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionPlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessionPlacementWithContext indicates an expected call of DescribeGameSessionPlacementWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionPlacementWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionPlacementWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionPlacementWithContext), varargs...) +} + +// DescribeGameSessionQueues mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionQueues(arg0 *gamelift.DescribeGameSessionQueuesInput) (*gamelift.DescribeGameSessionQueuesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionQueues", arg0) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionQueuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessionQueues indicates an expected call of DescribeGameSessionQueues. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionQueues(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionQueues", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionQueues), arg0) +} + +// DescribeGameSessionQueuesPages mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionQueuesPages(arg0 *gamelift.DescribeGameSessionQueuesInput, arg1 func(*gamelift.DescribeGameSessionQueuesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionQueuesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameSessionQueuesPages indicates an expected call of DescribeGameSessionQueuesPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionQueuesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionQueuesPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionQueuesPages), arg0, arg1) +} + +// DescribeGameSessionQueuesPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionQueuesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionQueuesInput, arg2 func(*gamelift.DescribeGameSessionQueuesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameSessionQueuesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameSessionQueuesPagesWithContext indicates an expected call of DescribeGameSessionQueuesPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionQueuesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionQueuesPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionQueuesPagesWithContext), varargs...) +} + +// DescribeGameSessionQueuesRequest mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionQueuesRequest(arg0 *gamelift.DescribeGameSessionQueuesInput) (*request.Request, *gamelift.DescribeGameSessionQueuesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionQueuesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeGameSessionQueuesOutput) + return ret0, ret1 +} + +// DescribeGameSessionQueuesRequest indicates an expected call of DescribeGameSessionQueuesRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionQueuesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionQueuesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionQueuesRequest), arg0) +} + +// DescribeGameSessionQueuesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionQueuesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionQueuesInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionQueuesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameSessionQueuesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionQueuesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessionQueuesWithContext indicates an expected call of DescribeGameSessionQueuesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionQueuesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionQueuesWithContext), varargs...) +} + +// DescribeGameSessions mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessions(arg0 *gamelift.DescribeGameSessionsInput) (*gamelift.DescribeGameSessionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessions", arg0) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessions indicates an expected call of DescribeGameSessions. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessions", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessions), arg0) +} + +// DescribeGameSessionsPages mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionsPages(arg0 *gamelift.DescribeGameSessionsInput, arg1 func(*gamelift.DescribeGameSessionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameSessionsPages indicates an expected call of DescribeGameSessionsPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionsPages), arg0, arg1) +} + +// DescribeGameSessionsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionsInput, arg2 func(*gamelift.DescribeGameSessionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameSessionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeGameSessionsPagesWithContext indicates an expected call of DescribeGameSessionsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionsPagesWithContext), varargs...) +} + +// DescribeGameSessionsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionsRequest(arg0 *gamelift.DescribeGameSessionsInput) (*request.Request, *gamelift.DescribeGameSessionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeGameSessionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeGameSessionsOutput) + return ret0, ret1 +} + +// DescribeGameSessionsRequest indicates an expected call of DescribeGameSessionsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionsRequest), arg0) +} + +// DescribeGameSessionsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeGameSessionsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeGameSessionsInput, arg2 ...request.Option) (*gamelift.DescribeGameSessionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeGameSessionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeGameSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeGameSessionsWithContext indicates an expected call of DescribeGameSessionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeGameSessionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGameSessionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeGameSessionsWithContext), varargs...) +} + +// DescribeInstances mocks base method. +func (m *MockGameLiftAPI) DescribeInstances(arg0 *gamelift.DescribeInstancesInput) (*gamelift.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstances", arg0) + ret0, _ := ret[0].(*gamelift.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstances indicates an expected call of DescribeInstances. +func (mr *MockGameLiftAPIMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeInstances), arg0) +} + +// DescribeInstancesPages mocks base method. +func (m *MockGameLiftAPI) DescribeInstancesPages(arg0 *gamelift.DescribeInstancesInput, arg1 func(*gamelift.DescribeInstancesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstancesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstancesPages indicates an expected call of DescribeInstancesPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeInstancesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeInstancesPages), arg0, arg1) +} + +// DescribeInstancesPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeInstancesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeInstancesInput, arg2 func(*gamelift.DescribeInstancesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstancesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstancesPagesWithContext indicates an expected call of DescribeInstancesPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeInstancesPagesWithContext), varargs...) +} + +// DescribeInstancesRequest mocks base method. +func (m *MockGameLiftAPI) DescribeInstancesRequest(arg0 *gamelift.DescribeInstancesInput) (*request.Request, *gamelift.DescribeInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeInstancesOutput) + return ret0, ret1 +} + +// DescribeInstancesRequest indicates an expected call of DescribeInstancesRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeInstancesRequest), arg0) +} + +// DescribeInstancesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeInstancesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeInstancesInput, arg2 ...request.Option) (*gamelift.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstancesWithContext indicates an expected call of DescribeInstancesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeInstancesWithContext), varargs...) +} + +// DescribeMatchmaking mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmaking(arg0 *gamelift.DescribeMatchmakingInput) (*gamelift.DescribeMatchmakingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmaking", arg0) + ret0, _ := ret[0].(*gamelift.DescribeMatchmakingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMatchmaking indicates an expected call of DescribeMatchmaking. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmaking(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmaking", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmaking), arg0) +} + +// DescribeMatchmakingConfigurations mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingConfigurations(arg0 *gamelift.DescribeMatchmakingConfigurationsInput) (*gamelift.DescribeMatchmakingConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurations", arg0) + ret0, _ := ret[0].(*gamelift.DescribeMatchmakingConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMatchmakingConfigurations indicates an expected call of DescribeMatchmakingConfigurations. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingConfigurations", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingConfigurations), arg0) +} + +// DescribeMatchmakingConfigurationsPages mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsPages(arg0 *gamelift.DescribeMatchmakingConfigurationsInput, arg1 func(*gamelift.DescribeMatchmakingConfigurationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeMatchmakingConfigurationsPages indicates an expected call of DescribeMatchmakingConfigurationsPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingConfigurationsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingConfigurationsPages), arg0, arg1) +} + +// DescribeMatchmakingConfigurationsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingConfigurationsInput, arg2 func(*gamelift.DescribeMatchmakingConfigurationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeMatchmakingConfigurationsPagesWithContext indicates an expected call of DescribeMatchmakingConfigurationsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingConfigurationsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingConfigurationsPagesWithContext), varargs...) +} + +// DescribeMatchmakingConfigurationsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsRequest(arg0 *gamelift.DescribeMatchmakingConfigurationsInput) (*request.Request, *gamelift.DescribeMatchmakingConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeMatchmakingConfigurationsOutput) + return ret0, ret1 +} + +// DescribeMatchmakingConfigurationsRequest indicates an expected call of DescribeMatchmakingConfigurationsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingConfigurationsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingConfigurationsRequest), arg0) +} + +// DescribeMatchmakingConfigurationsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingConfigurationsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingConfigurationsInput, arg2 ...request.Option) (*gamelift.DescribeMatchmakingConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMatchmakingConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeMatchmakingConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMatchmakingConfigurationsWithContext indicates an expected call of DescribeMatchmakingConfigurationsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingConfigurationsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingConfigurationsWithContext), varargs...) +} + +// DescribeMatchmakingRequest mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingRequest(arg0 *gamelift.DescribeMatchmakingInput) (*request.Request, *gamelift.DescribeMatchmakingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmakingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeMatchmakingOutput) + return ret0, ret1 +} + +// DescribeMatchmakingRequest indicates an expected call of DescribeMatchmakingRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingRequest), arg0) +} + +// DescribeMatchmakingRuleSets mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingRuleSets(arg0 *gamelift.DescribeMatchmakingRuleSetsInput) (*gamelift.DescribeMatchmakingRuleSetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSets", arg0) + ret0, _ := ret[0].(*gamelift.DescribeMatchmakingRuleSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMatchmakingRuleSets indicates an expected call of DescribeMatchmakingRuleSets. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingRuleSets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingRuleSets", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingRuleSets), arg0) +} + +// DescribeMatchmakingRuleSetsPages mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsPages(arg0 *gamelift.DescribeMatchmakingRuleSetsInput, arg1 func(*gamelift.DescribeMatchmakingRuleSetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeMatchmakingRuleSetsPages indicates an expected call of DescribeMatchmakingRuleSetsPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingRuleSetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingRuleSetsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingRuleSetsPages), arg0, arg1) +} + +// DescribeMatchmakingRuleSetsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingRuleSetsInput, arg2 func(*gamelift.DescribeMatchmakingRuleSetsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeMatchmakingRuleSetsPagesWithContext indicates an expected call of DescribeMatchmakingRuleSetsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingRuleSetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingRuleSetsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingRuleSetsPagesWithContext), varargs...) +} + +// DescribeMatchmakingRuleSetsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsRequest(arg0 *gamelift.DescribeMatchmakingRuleSetsInput) (*request.Request, *gamelift.DescribeMatchmakingRuleSetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeMatchmakingRuleSetsOutput) + return ret0, ret1 +} + +// DescribeMatchmakingRuleSetsRequest indicates an expected call of DescribeMatchmakingRuleSetsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingRuleSetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingRuleSetsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingRuleSetsRequest), arg0) +} + +// DescribeMatchmakingRuleSetsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingRuleSetsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingRuleSetsInput, arg2 ...request.Option) (*gamelift.DescribeMatchmakingRuleSetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMatchmakingRuleSetsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeMatchmakingRuleSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMatchmakingRuleSetsWithContext indicates an expected call of DescribeMatchmakingRuleSetsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingRuleSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingRuleSetsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingRuleSetsWithContext), varargs...) +} + +// DescribeMatchmakingWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeMatchmakingWithContext(arg0 aws.Context, arg1 *gamelift.DescribeMatchmakingInput, arg2 ...request.Option) (*gamelift.DescribeMatchmakingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMatchmakingWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeMatchmakingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMatchmakingWithContext indicates an expected call of DescribeMatchmakingWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeMatchmakingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMatchmakingWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeMatchmakingWithContext), varargs...) +} + +// DescribePlayerSessions mocks base method. +func (m *MockGameLiftAPI) DescribePlayerSessions(arg0 *gamelift.DescribePlayerSessionsInput) (*gamelift.DescribePlayerSessionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePlayerSessions", arg0) + ret0, _ := ret[0].(*gamelift.DescribePlayerSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePlayerSessions indicates an expected call of DescribePlayerSessions. +func (mr *MockGameLiftAPIMockRecorder) DescribePlayerSessions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlayerSessions", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribePlayerSessions), arg0) +} + +// DescribePlayerSessionsPages mocks base method. +func (m *MockGameLiftAPI) DescribePlayerSessionsPages(arg0 *gamelift.DescribePlayerSessionsInput, arg1 func(*gamelift.DescribePlayerSessionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePlayerSessionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePlayerSessionsPages indicates an expected call of DescribePlayerSessionsPages. +func (mr *MockGameLiftAPIMockRecorder) DescribePlayerSessionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlayerSessionsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribePlayerSessionsPages), arg0, arg1) +} + +// DescribePlayerSessionsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribePlayerSessionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribePlayerSessionsInput, arg2 func(*gamelift.DescribePlayerSessionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePlayerSessionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePlayerSessionsPagesWithContext indicates an expected call of DescribePlayerSessionsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribePlayerSessionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlayerSessionsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribePlayerSessionsPagesWithContext), varargs...) +} + +// DescribePlayerSessionsRequest mocks base method. +func (m *MockGameLiftAPI) DescribePlayerSessionsRequest(arg0 *gamelift.DescribePlayerSessionsInput) (*request.Request, *gamelift.DescribePlayerSessionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePlayerSessionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribePlayerSessionsOutput) + return ret0, ret1 +} + +// DescribePlayerSessionsRequest indicates an expected call of DescribePlayerSessionsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribePlayerSessionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlayerSessionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribePlayerSessionsRequest), arg0) +} + +// DescribePlayerSessionsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribePlayerSessionsWithContext(arg0 aws.Context, arg1 *gamelift.DescribePlayerSessionsInput, arg2 ...request.Option) (*gamelift.DescribePlayerSessionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePlayerSessionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribePlayerSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePlayerSessionsWithContext indicates an expected call of DescribePlayerSessionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribePlayerSessionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlayerSessionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribePlayerSessionsWithContext), varargs...) +} + +// DescribeRuntimeConfiguration mocks base method. +func (m *MockGameLiftAPI) DescribeRuntimeConfiguration(arg0 *gamelift.DescribeRuntimeConfigurationInput) (*gamelift.DescribeRuntimeConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRuntimeConfiguration", arg0) + ret0, _ := ret[0].(*gamelift.DescribeRuntimeConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRuntimeConfiguration indicates an expected call of DescribeRuntimeConfiguration. +func (mr *MockGameLiftAPIMockRecorder) DescribeRuntimeConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRuntimeConfiguration", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeRuntimeConfiguration), arg0) +} + +// DescribeRuntimeConfigurationRequest mocks base method. +func (m *MockGameLiftAPI) DescribeRuntimeConfigurationRequest(arg0 *gamelift.DescribeRuntimeConfigurationInput) (*request.Request, *gamelift.DescribeRuntimeConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRuntimeConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeRuntimeConfigurationOutput) + return ret0, ret1 +} + +// DescribeRuntimeConfigurationRequest indicates an expected call of DescribeRuntimeConfigurationRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeRuntimeConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRuntimeConfigurationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeRuntimeConfigurationRequest), arg0) +} + +// DescribeRuntimeConfigurationWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeRuntimeConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.DescribeRuntimeConfigurationInput, arg2 ...request.Option) (*gamelift.DescribeRuntimeConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRuntimeConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeRuntimeConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRuntimeConfigurationWithContext indicates an expected call of DescribeRuntimeConfigurationWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeRuntimeConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRuntimeConfigurationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeRuntimeConfigurationWithContext), varargs...) +} + +// DescribeScalingPolicies mocks base method. +func (m *MockGameLiftAPI) DescribeScalingPolicies(arg0 *gamelift.DescribeScalingPoliciesInput) (*gamelift.DescribeScalingPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingPolicies", arg0) + ret0, _ := ret[0].(*gamelift.DescribeScalingPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScalingPolicies indicates an expected call of DescribeScalingPolicies. +func (mr *MockGameLiftAPIMockRecorder) DescribeScalingPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingPolicies", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScalingPolicies), arg0) +} + +// DescribeScalingPoliciesPages mocks base method. +func (m *MockGameLiftAPI) DescribeScalingPoliciesPages(arg0 *gamelift.DescribeScalingPoliciesInput, arg1 func(*gamelift.DescribeScalingPoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingPoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScalingPoliciesPages indicates an expected call of DescribeScalingPoliciesPages. +func (mr *MockGameLiftAPIMockRecorder) DescribeScalingPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingPoliciesPages", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScalingPoliciesPages), arg0, arg1) +} + +// DescribeScalingPoliciesPagesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeScalingPoliciesPagesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeScalingPoliciesInput, arg2 func(*gamelift.DescribeScalingPoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScalingPoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScalingPoliciesPagesWithContext indicates an expected call of DescribeScalingPoliciesPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeScalingPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingPoliciesPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScalingPoliciesPagesWithContext), varargs...) +} + +// DescribeScalingPoliciesRequest mocks base method. +func (m *MockGameLiftAPI) DescribeScalingPoliciesRequest(arg0 *gamelift.DescribeScalingPoliciesInput) (*request.Request, *gamelift.DescribeScalingPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeScalingPoliciesOutput) + return ret0, ret1 +} + +// DescribeScalingPoliciesRequest indicates an expected call of DescribeScalingPoliciesRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeScalingPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingPoliciesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScalingPoliciesRequest), arg0) +} + +// DescribeScalingPoliciesWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeScalingPoliciesWithContext(arg0 aws.Context, arg1 *gamelift.DescribeScalingPoliciesInput, arg2 ...request.Option) (*gamelift.DescribeScalingPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScalingPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeScalingPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScalingPoliciesWithContext indicates an expected call of DescribeScalingPoliciesWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeScalingPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingPoliciesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScalingPoliciesWithContext), varargs...) +} + +// DescribeScript mocks base method. +func (m *MockGameLiftAPI) DescribeScript(arg0 *gamelift.DescribeScriptInput) (*gamelift.DescribeScriptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScript", arg0) + ret0, _ := ret[0].(*gamelift.DescribeScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScript indicates an expected call of DescribeScript. +func (mr *MockGameLiftAPIMockRecorder) DescribeScript(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScript", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScript), arg0) +} + +// DescribeScriptRequest mocks base method. +func (m *MockGameLiftAPI) DescribeScriptRequest(arg0 *gamelift.DescribeScriptInput) (*request.Request, *gamelift.DescribeScriptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScriptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeScriptOutput) + return ret0, ret1 +} + +// DescribeScriptRequest indicates an expected call of DescribeScriptRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeScriptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScriptRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScriptRequest), arg0) +} + +// DescribeScriptWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeScriptWithContext(arg0 aws.Context, arg1 *gamelift.DescribeScriptInput, arg2 ...request.Option) (*gamelift.DescribeScriptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScriptWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScriptWithContext indicates an expected call of DescribeScriptWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeScriptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScriptWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeScriptWithContext), varargs...) +} + +// DescribeVpcPeeringAuthorizations mocks base method. +func (m *MockGameLiftAPI) DescribeVpcPeeringAuthorizations(arg0 *gamelift.DescribeVpcPeeringAuthorizationsInput) (*gamelift.DescribeVpcPeeringAuthorizationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcPeeringAuthorizations", arg0) + ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringAuthorizationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcPeeringAuthorizations indicates an expected call of DescribeVpcPeeringAuthorizations. +func (mr *MockGameLiftAPIMockRecorder) DescribeVpcPeeringAuthorizations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringAuthorizations", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeVpcPeeringAuthorizations), arg0) +} + +// DescribeVpcPeeringAuthorizationsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeVpcPeeringAuthorizationsRequest(arg0 *gamelift.DescribeVpcPeeringAuthorizationsInput) (*request.Request, *gamelift.DescribeVpcPeeringAuthorizationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcPeeringAuthorizationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeVpcPeeringAuthorizationsOutput) + return ret0, ret1 +} + +// DescribeVpcPeeringAuthorizationsRequest indicates an expected call of DescribeVpcPeeringAuthorizationsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeVpcPeeringAuthorizationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringAuthorizationsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeVpcPeeringAuthorizationsRequest), arg0) +} + +// DescribeVpcPeeringAuthorizationsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeVpcPeeringAuthorizationsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeVpcPeeringAuthorizationsInput, arg2 ...request.Option) (*gamelift.DescribeVpcPeeringAuthorizationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcPeeringAuthorizationsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringAuthorizationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcPeeringAuthorizationsWithContext indicates an expected call of DescribeVpcPeeringAuthorizationsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeVpcPeeringAuthorizationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringAuthorizationsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeVpcPeeringAuthorizationsWithContext), varargs...) +} + +// DescribeVpcPeeringConnections mocks base method. +func (m *MockGameLiftAPI) DescribeVpcPeeringConnections(arg0 *gamelift.DescribeVpcPeeringConnectionsInput) (*gamelift.DescribeVpcPeeringConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnections", arg0) + ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcPeeringConnections indicates an expected call of DescribeVpcPeeringConnections. +func (mr *MockGameLiftAPIMockRecorder) DescribeVpcPeeringConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnections", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeVpcPeeringConnections), arg0) +} + +// DescribeVpcPeeringConnectionsRequest mocks base method. +func (m *MockGameLiftAPI) DescribeVpcPeeringConnectionsRequest(arg0 *gamelift.DescribeVpcPeeringConnectionsInput) (*request.Request, *gamelift.DescribeVpcPeeringConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.DescribeVpcPeeringConnectionsOutput) + return ret0, ret1 +} + +// DescribeVpcPeeringConnectionsRequest indicates an expected call of DescribeVpcPeeringConnectionsRequest. +func (mr *MockGameLiftAPIMockRecorder) DescribeVpcPeeringConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeVpcPeeringConnectionsRequest), arg0) +} + +// DescribeVpcPeeringConnectionsWithContext mocks base method. +func (m *MockGameLiftAPI) DescribeVpcPeeringConnectionsWithContext(arg0 aws.Context, arg1 *gamelift.DescribeVpcPeeringConnectionsInput, arg2 ...request.Option) (*gamelift.DescribeVpcPeeringConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.DescribeVpcPeeringConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcPeeringConnectionsWithContext indicates an expected call of DescribeVpcPeeringConnectionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) DescribeVpcPeeringConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).DescribeVpcPeeringConnectionsWithContext), varargs...) +} + +// GetComputeAccess mocks base method. +func (m *MockGameLiftAPI) GetComputeAccess(arg0 *gamelift.GetComputeAccessInput) (*gamelift.GetComputeAccessOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComputeAccess", arg0) + ret0, _ := ret[0].(*gamelift.GetComputeAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComputeAccess indicates an expected call of GetComputeAccess. +func (mr *MockGameLiftAPIMockRecorder) GetComputeAccess(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeAccess", reflect.TypeOf((*MockGameLiftAPI)(nil).GetComputeAccess), arg0) +} + +// GetComputeAccessRequest mocks base method. +func (m *MockGameLiftAPI) GetComputeAccessRequest(arg0 *gamelift.GetComputeAccessInput) (*request.Request, *gamelift.GetComputeAccessOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComputeAccessRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.GetComputeAccessOutput) + return ret0, ret1 +} + +// GetComputeAccessRequest indicates an expected call of GetComputeAccessRequest. +func (mr *MockGameLiftAPIMockRecorder) GetComputeAccessRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeAccessRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).GetComputeAccessRequest), arg0) +} + +// GetComputeAccessWithContext mocks base method. +func (m *MockGameLiftAPI) GetComputeAccessWithContext(arg0 aws.Context, arg1 *gamelift.GetComputeAccessInput, arg2 ...request.Option) (*gamelift.GetComputeAccessOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetComputeAccessWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.GetComputeAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComputeAccessWithContext indicates an expected call of GetComputeAccessWithContext. +func (mr *MockGameLiftAPIMockRecorder) GetComputeAccessWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeAccessWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).GetComputeAccessWithContext), varargs...) +} + +// GetComputeAuthToken mocks base method. +func (m *MockGameLiftAPI) GetComputeAuthToken(arg0 *gamelift.GetComputeAuthTokenInput) (*gamelift.GetComputeAuthTokenOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComputeAuthToken", arg0) + ret0, _ := ret[0].(*gamelift.GetComputeAuthTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComputeAuthToken indicates an expected call of GetComputeAuthToken. +func (mr *MockGameLiftAPIMockRecorder) GetComputeAuthToken(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeAuthToken", reflect.TypeOf((*MockGameLiftAPI)(nil).GetComputeAuthToken), arg0) +} + +// GetComputeAuthTokenRequest mocks base method. +func (m *MockGameLiftAPI) GetComputeAuthTokenRequest(arg0 *gamelift.GetComputeAuthTokenInput) (*request.Request, *gamelift.GetComputeAuthTokenOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComputeAuthTokenRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.GetComputeAuthTokenOutput) + return ret0, ret1 +} + +// GetComputeAuthTokenRequest indicates an expected call of GetComputeAuthTokenRequest. +func (mr *MockGameLiftAPIMockRecorder) GetComputeAuthTokenRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeAuthTokenRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).GetComputeAuthTokenRequest), arg0) +} + +// GetComputeAuthTokenWithContext mocks base method. +func (m *MockGameLiftAPI) GetComputeAuthTokenWithContext(arg0 aws.Context, arg1 *gamelift.GetComputeAuthTokenInput, arg2 ...request.Option) (*gamelift.GetComputeAuthTokenOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetComputeAuthTokenWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.GetComputeAuthTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComputeAuthTokenWithContext indicates an expected call of GetComputeAuthTokenWithContext. +func (mr *MockGameLiftAPIMockRecorder) GetComputeAuthTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputeAuthTokenWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).GetComputeAuthTokenWithContext), varargs...) +} + +// GetGameSessionLogUrl mocks base method. +func (m *MockGameLiftAPI) GetGameSessionLogUrl(arg0 *gamelift.GetGameSessionLogUrlInput) (*gamelift.GetGameSessionLogUrlOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGameSessionLogUrl", arg0) + ret0, _ := ret[0].(*gamelift.GetGameSessionLogUrlOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGameSessionLogUrl indicates an expected call of GetGameSessionLogUrl. +func (mr *MockGameLiftAPIMockRecorder) GetGameSessionLogUrl(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGameSessionLogUrl", reflect.TypeOf((*MockGameLiftAPI)(nil).GetGameSessionLogUrl), arg0) +} + +// GetGameSessionLogUrlRequest mocks base method. +func (m *MockGameLiftAPI) GetGameSessionLogUrlRequest(arg0 *gamelift.GetGameSessionLogUrlInput) (*request.Request, *gamelift.GetGameSessionLogUrlOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGameSessionLogUrlRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.GetGameSessionLogUrlOutput) + return ret0, ret1 +} + +// GetGameSessionLogUrlRequest indicates an expected call of GetGameSessionLogUrlRequest. +func (mr *MockGameLiftAPIMockRecorder) GetGameSessionLogUrlRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGameSessionLogUrlRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).GetGameSessionLogUrlRequest), arg0) +} + +// GetGameSessionLogUrlWithContext mocks base method. +func (m *MockGameLiftAPI) GetGameSessionLogUrlWithContext(arg0 aws.Context, arg1 *gamelift.GetGameSessionLogUrlInput, arg2 ...request.Option) (*gamelift.GetGameSessionLogUrlOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGameSessionLogUrlWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.GetGameSessionLogUrlOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGameSessionLogUrlWithContext indicates an expected call of GetGameSessionLogUrlWithContext. +func (mr *MockGameLiftAPIMockRecorder) GetGameSessionLogUrlWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGameSessionLogUrlWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).GetGameSessionLogUrlWithContext), varargs...) +} + +// GetInstanceAccess mocks base method. +func (m *MockGameLiftAPI) GetInstanceAccess(arg0 *gamelift.GetInstanceAccessInput) (*gamelift.GetInstanceAccessOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstanceAccess", arg0) + ret0, _ := ret[0].(*gamelift.GetInstanceAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstanceAccess indicates an expected call of GetInstanceAccess. +func (mr *MockGameLiftAPIMockRecorder) GetInstanceAccess(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceAccess", reflect.TypeOf((*MockGameLiftAPI)(nil).GetInstanceAccess), arg0) +} + +// GetInstanceAccessRequest mocks base method. +func (m *MockGameLiftAPI) GetInstanceAccessRequest(arg0 *gamelift.GetInstanceAccessInput) (*request.Request, *gamelift.GetInstanceAccessOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstanceAccessRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.GetInstanceAccessOutput) + return ret0, ret1 +} + +// GetInstanceAccessRequest indicates an expected call of GetInstanceAccessRequest. +func (mr *MockGameLiftAPIMockRecorder) GetInstanceAccessRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceAccessRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).GetInstanceAccessRequest), arg0) +} + +// GetInstanceAccessWithContext mocks base method. +func (m *MockGameLiftAPI) GetInstanceAccessWithContext(arg0 aws.Context, arg1 *gamelift.GetInstanceAccessInput, arg2 ...request.Option) (*gamelift.GetInstanceAccessOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetInstanceAccessWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.GetInstanceAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstanceAccessWithContext indicates an expected call of GetInstanceAccessWithContext. +func (mr *MockGameLiftAPIMockRecorder) GetInstanceAccessWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceAccessWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).GetInstanceAccessWithContext), varargs...) +} + +// ListAliases mocks base method. +func (m *MockGameLiftAPI) ListAliases(arg0 *gamelift.ListAliasesInput) (*gamelift.ListAliasesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAliases", arg0) + ret0, _ := ret[0].(*gamelift.ListAliasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAliases indicates an expected call of ListAliases. +func (mr *MockGameLiftAPIMockRecorder) ListAliases(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliases", reflect.TypeOf((*MockGameLiftAPI)(nil).ListAliases), arg0) +} + +// ListAliasesPages mocks base method. +func (m *MockGameLiftAPI) ListAliasesPages(arg0 *gamelift.ListAliasesInput, arg1 func(*gamelift.ListAliasesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAliasesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAliasesPages indicates an expected call of ListAliasesPages. +func (mr *MockGameLiftAPIMockRecorder) ListAliasesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListAliasesPages), arg0, arg1) +} + +// ListAliasesPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListAliasesPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListAliasesInput, arg2 func(*gamelift.ListAliasesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAliasesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAliasesPagesWithContext indicates an expected call of ListAliasesPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListAliasesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListAliasesPagesWithContext), varargs...) +} + +// ListAliasesRequest mocks base method. +func (m *MockGameLiftAPI) ListAliasesRequest(arg0 *gamelift.ListAliasesInput) (*request.Request, *gamelift.ListAliasesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAliasesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListAliasesOutput) + return ret0, ret1 +} + +// ListAliasesRequest indicates an expected call of ListAliasesRequest. +func (mr *MockGameLiftAPIMockRecorder) ListAliasesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListAliasesRequest), arg0) +} + +// ListAliasesWithContext mocks base method. +func (m *MockGameLiftAPI) ListAliasesWithContext(arg0 aws.Context, arg1 *gamelift.ListAliasesInput, arg2 ...request.Option) (*gamelift.ListAliasesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAliasesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListAliasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAliasesWithContext indicates an expected call of ListAliasesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListAliasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListAliasesWithContext), varargs...) +} + +// ListBuilds mocks base method. +func (m *MockGameLiftAPI) ListBuilds(arg0 *gamelift.ListBuildsInput) (*gamelift.ListBuildsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListBuilds", arg0) + ret0, _ := ret[0].(*gamelift.ListBuildsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBuilds indicates an expected call of ListBuilds. +func (mr *MockGameLiftAPIMockRecorder) ListBuilds(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuilds", reflect.TypeOf((*MockGameLiftAPI)(nil).ListBuilds), arg0) +} + +// ListBuildsPages mocks base method. +func (m *MockGameLiftAPI) ListBuildsPages(arg0 *gamelift.ListBuildsInput, arg1 func(*gamelift.ListBuildsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListBuildsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListBuildsPages indicates an expected call of ListBuildsPages. +func (mr *MockGameLiftAPIMockRecorder) ListBuildsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuildsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListBuildsPages), arg0, arg1) +} + +// ListBuildsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListBuildsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListBuildsInput, arg2 func(*gamelift.ListBuildsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListBuildsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListBuildsPagesWithContext indicates an expected call of ListBuildsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListBuildsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuildsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListBuildsPagesWithContext), varargs...) +} + +// ListBuildsRequest mocks base method. +func (m *MockGameLiftAPI) ListBuildsRequest(arg0 *gamelift.ListBuildsInput) (*request.Request, *gamelift.ListBuildsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListBuildsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListBuildsOutput) + return ret0, ret1 +} + +// ListBuildsRequest indicates an expected call of ListBuildsRequest. +func (mr *MockGameLiftAPIMockRecorder) ListBuildsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuildsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListBuildsRequest), arg0) +} + +// ListBuildsWithContext mocks base method. +func (m *MockGameLiftAPI) ListBuildsWithContext(arg0 aws.Context, arg1 *gamelift.ListBuildsInput, arg2 ...request.Option) (*gamelift.ListBuildsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListBuildsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListBuildsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBuildsWithContext indicates an expected call of ListBuildsWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListBuildsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuildsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListBuildsWithContext), varargs...) +} + +// ListCompute mocks base method. +func (m *MockGameLiftAPI) ListCompute(arg0 *gamelift.ListComputeInput) (*gamelift.ListComputeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCompute", arg0) + ret0, _ := ret[0].(*gamelift.ListComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCompute indicates an expected call of ListCompute. +func (mr *MockGameLiftAPIMockRecorder) ListCompute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCompute", reflect.TypeOf((*MockGameLiftAPI)(nil).ListCompute), arg0) +} + +// ListComputePages mocks base method. +func (m *MockGameLiftAPI) ListComputePages(arg0 *gamelift.ListComputeInput, arg1 func(*gamelift.ListComputeOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListComputePages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListComputePages indicates an expected call of ListComputePages. +func (mr *MockGameLiftAPIMockRecorder) ListComputePages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComputePages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListComputePages), arg0, arg1) +} + +// ListComputePagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListComputePagesWithContext(arg0 aws.Context, arg1 *gamelift.ListComputeInput, arg2 func(*gamelift.ListComputeOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListComputePagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListComputePagesWithContext indicates an expected call of ListComputePagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListComputePagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComputePagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListComputePagesWithContext), varargs...) +} + +// ListComputeRequest mocks base method. +func (m *MockGameLiftAPI) ListComputeRequest(arg0 *gamelift.ListComputeInput) (*request.Request, *gamelift.ListComputeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListComputeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListComputeOutput) + return ret0, ret1 +} + +// ListComputeRequest indicates an expected call of ListComputeRequest. +func (mr *MockGameLiftAPIMockRecorder) ListComputeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComputeRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListComputeRequest), arg0) +} + +// ListComputeWithContext mocks base method. +func (m *MockGameLiftAPI) ListComputeWithContext(arg0 aws.Context, arg1 *gamelift.ListComputeInput, arg2 ...request.Option) (*gamelift.ListComputeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListComputeWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListComputeWithContext indicates an expected call of ListComputeWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListComputeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComputeWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListComputeWithContext), varargs...) +} + +// ListContainerGroupDefinitions mocks base method. +func (m *MockGameLiftAPI) ListContainerGroupDefinitions(arg0 *gamelift.ListContainerGroupDefinitionsInput) (*gamelift.ListContainerGroupDefinitionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListContainerGroupDefinitions", arg0) + ret0, _ := ret[0].(*gamelift.ListContainerGroupDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListContainerGroupDefinitions indicates an expected call of ListContainerGroupDefinitions. +func (mr *MockGameLiftAPIMockRecorder) ListContainerGroupDefinitions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerGroupDefinitions", reflect.TypeOf((*MockGameLiftAPI)(nil).ListContainerGroupDefinitions), arg0) +} + +// ListContainerGroupDefinitionsPages mocks base method. +func (m *MockGameLiftAPI) ListContainerGroupDefinitionsPages(arg0 *gamelift.ListContainerGroupDefinitionsInput, arg1 func(*gamelift.ListContainerGroupDefinitionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListContainerGroupDefinitionsPages indicates an expected call of ListContainerGroupDefinitionsPages. +func (mr *MockGameLiftAPIMockRecorder) ListContainerGroupDefinitionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerGroupDefinitionsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListContainerGroupDefinitionsPages), arg0, arg1) +} + +// ListContainerGroupDefinitionsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListContainerGroupDefinitionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListContainerGroupDefinitionsInput, arg2 func(*gamelift.ListContainerGroupDefinitionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListContainerGroupDefinitionsPagesWithContext indicates an expected call of ListContainerGroupDefinitionsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListContainerGroupDefinitionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerGroupDefinitionsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListContainerGroupDefinitionsPagesWithContext), varargs...) +} + +// ListContainerGroupDefinitionsRequest mocks base method. +func (m *MockGameLiftAPI) ListContainerGroupDefinitionsRequest(arg0 *gamelift.ListContainerGroupDefinitionsInput) (*request.Request, *gamelift.ListContainerGroupDefinitionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListContainerGroupDefinitionsOutput) + return ret0, ret1 +} + +// ListContainerGroupDefinitionsRequest indicates an expected call of ListContainerGroupDefinitionsRequest. +func (mr *MockGameLiftAPIMockRecorder) ListContainerGroupDefinitionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerGroupDefinitionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListContainerGroupDefinitionsRequest), arg0) +} + +// ListContainerGroupDefinitionsWithContext mocks base method. +func (m *MockGameLiftAPI) ListContainerGroupDefinitionsWithContext(arg0 aws.Context, arg1 *gamelift.ListContainerGroupDefinitionsInput, arg2 ...request.Option) (*gamelift.ListContainerGroupDefinitionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListContainerGroupDefinitionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListContainerGroupDefinitionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListContainerGroupDefinitionsWithContext indicates an expected call of ListContainerGroupDefinitionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListContainerGroupDefinitionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerGroupDefinitionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListContainerGroupDefinitionsWithContext), varargs...) +} + +// ListFleets mocks base method. +func (m *MockGameLiftAPI) ListFleets(arg0 *gamelift.ListFleetsInput) (*gamelift.ListFleetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFleets", arg0) + ret0, _ := ret[0].(*gamelift.ListFleetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFleets indicates an expected call of ListFleets. +func (mr *MockGameLiftAPIMockRecorder) ListFleets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFleets", reflect.TypeOf((*MockGameLiftAPI)(nil).ListFleets), arg0) +} + +// ListFleetsPages mocks base method. +func (m *MockGameLiftAPI) ListFleetsPages(arg0 *gamelift.ListFleetsInput, arg1 func(*gamelift.ListFleetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFleetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFleetsPages indicates an expected call of ListFleetsPages. +func (mr *MockGameLiftAPIMockRecorder) ListFleetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFleetsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListFleetsPages), arg0, arg1) +} + +// ListFleetsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListFleetsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListFleetsInput, arg2 func(*gamelift.ListFleetsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFleetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFleetsPagesWithContext indicates an expected call of ListFleetsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListFleetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFleetsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListFleetsPagesWithContext), varargs...) +} + +// ListFleetsRequest mocks base method. +func (m *MockGameLiftAPI) ListFleetsRequest(arg0 *gamelift.ListFleetsInput) (*request.Request, *gamelift.ListFleetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFleetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListFleetsOutput) + return ret0, ret1 +} + +// ListFleetsRequest indicates an expected call of ListFleetsRequest. +func (mr *MockGameLiftAPIMockRecorder) ListFleetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFleetsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListFleetsRequest), arg0) +} + +// ListFleetsWithContext mocks base method. +func (m *MockGameLiftAPI) ListFleetsWithContext(arg0 aws.Context, arg1 *gamelift.ListFleetsInput, arg2 ...request.Option) (*gamelift.ListFleetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFleetsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListFleetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFleetsWithContext indicates an expected call of ListFleetsWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListFleetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFleetsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListFleetsWithContext), varargs...) +} + +// ListGameServerGroups mocks base method. +func (m *MockGameLiftAPI) ListGameServerGroups(arg0 *gamelift.ListGameServerGroupsInput) (*gamelift.ListGameServerGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGameServerGroups", arg0) + ret0, _ := ret[0].(*gamelift.ListGameServerGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGameServerGroups indicates an expected call of ListGameServerGroups. +func (mr *MockGameLiftAPIMockRecorder) ListGameServerGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServerGroups", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServerGroups), arg0) +} + +// ListGameServerGroupsPages mocks base method. +func (m *MockGameLiftAPI) ListGameServerGroupsPages(arg0 *gamelift.ListGameServerGroupsInput, arg1 func(*gamelift.ListGameServerGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGameServerGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGameServerGroupsPages indicates an expected call of ListGameServerGroupsPages. +func (mr *MockGameLiftAPIMockRecorder) ListGameServerGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServerGroupsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServerGroupsPages), arg0, arg1) +} + +// ListGameServerGroupsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListGameServerGroupsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServerGroupsInput, arg2 func(*gamelift.ListGameServerGroupsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGameServerGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGameServerGroupsPagesWithContext indicates an expected call of ListGameServerGroupsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListGameServerGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServerGroupsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServerGroupsPagesWithContext), varargs...) +} + +// ListGameServerGroupsRequest mocks base method. +func (m *MockGameLiftAPI) ListGameServerGroupsRequest(arg0 *gamelift.ListGameServerGroupsInput) (*request.Request, *gamelift.ListGameServerGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGameServerGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListGameServerGroupsOutput) + return ret0, ret1 +} + +// ListGameServerGroupsRequest indicates an expected call of ListGameServerGroupsRequest. +func (mr *MockGameLiftAPIMockRecorder) ListGameServerGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServerGroupsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServerGroupsRequest), arg0) +} + +// ListGameServerGroupsWithContext mocks base method. +func (m *MockGameLiftAPI) ListGameServerGroupsWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServerGroupsInput, arg2 ...request.Option) (*gamelift.ListGameServerGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGameServerGroupsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListGameServerGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGameServerGroupsWithContext indicates an expected call of ListGameServerGroupsWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListGameServerGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServerGroupsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServerGroupsWithContext), varargs...) +} + +// ListGameServers mocks base method. +func (m *MockGameLiftAPI) ListGameServers(arg0 *gamelift.ListGameServersInput) (*gamelift.ListGameServersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGameServers", arg0) + ret0, _ := ret[0].(*gamelift.ListGameServersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGameServers indicates an expected call of ListGameServers. +func (mr *MockGameLiftAPIMockRecorder) ListGameServers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServers", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServers), arg0) +} + +// ListGameServersPages mocks base method. +func (m *MockGameLiftAPI) ListGameServersPages(arg0 *gamelift.ListGameServersInput, arg1 func(*gamelift.ListGameServersOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGameServersPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGameServersPages indicates an expected call of ListGameServersPages. +func (mr *MockGameLiftAPIMockRecorder) ListGameServersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServersPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServersPages), arg0, arg1) +} + +// ListGameServersPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListGameServersPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServersInput, arg2 func(*gamelift.ListGameServersOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGameServersPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGameServersPagesWithContext indicates an expected call of ListGameServersPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListGameServersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServersPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServersPagesWithContext), varargs...) +} + +// ListGameServersRequest mocks base method. +func (m *MockGameLiftAPI) ListGameServersRequest(arg0 *gamelift.ListGameServersInput) (*request.Request, *gamelift.ListGameServersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGameServersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListGameServersOutput) + return ret0, ret1 +} + +// ListGameServersRequest indicates an expected call of ListGameServersRequest. +func (mr *MockGameLiftAPIMockRecorder) ListGameServersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServersRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServersRequest), arg0) +} + +// ListGameServersWithContext mocks base method. +func (m *MockGameLiftAPI) ListGameServersWithContext(arg0 aws.Context, arg1 *gamelift.ListGameServersInput, arg2 ...request.Option) (*gamelift.ListGameServersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGameServersWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListGameServersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGameServersWithContext indicates an expected call of ListGameServersWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListGameServersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGameServersWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListGameServersWithContext), varargs...) +} + +// ListLocations mocks base method. +func (m *MockGameLiftAPI) ListLocations(arg0 *gamelift.ListLocationsInput) (*gamelift.ListLocationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListLocations", arg0) + ret0, _ := ret[0].(*gamelift.ListLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListLocations indicates an expected call of ListLocations. +func (mr *MockGameLiftAPIMockRecorder) ListLocations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocations", reflect.TypeOf((*MockGameLiftAPI)(nil).ListLocations), arg0) +} + +// ListLocationsPages mocks base method. +func (m *MockGameLiftAPI) ListLocationsPages(arg0 *gamelift.ListLocationsInput, arg1 func(*gamelift.ListLocationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListLocationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListLocationsPages indicates an expected call of ListLocationsPages. +func (mr *MockGameLiftAPIMockRecorder) ListLocationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocationsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListLocationsPages), arg0, arg1) +} + +// ListLocationsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListLocationsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListLocationsInput, arg2 func(*gamelift.ListLocationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListLocationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListLocationsPagesWithContext indicates an expected call of ListLocationsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListLocationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocationsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListLocationsPagesWithContext), varargs...) +} + +// ListLocationsRequest mocks base method. +func (m *MockGameLiftAPI) ListLocationsRequest(arg0 *gamelift.ListLocationsInput) (*request.Request, *gamelift.ListLocationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListLocationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListLocationsOutput) + return ret0, ret1 +} + +// ListLocationsRequest indicates an expected call of ListLocationsRequest. +func (mr *MockGameLiftAPIMockRecorder) ListLocationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocationsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListLocationsRequest), arg0) +} + +// ListLocationsWithContext mocks base method. +func (m *MockGameLiftAPI) ListLocationsWithContext(arg0 aws.Context, arg1 *gamelift.ListLocationsInput, arg2 ...request.Option) (*gamelift.ListLocationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListLocationsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListLocationsWithContext indicates an expected call of ListLocationsWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListLocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLocationsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListLocationsWithContext), varargs...) +} + +// ListScripts mocks base method. +func (m *MockGameLiftAPI) ListScripts(arg0 *gamelift.ListScriptsInput) (*gamelift.ListScriptsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListScripts", arg0) + ret0, _ := ret[0].(*gamelift.ListScriptsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListScripts indicates an expected call of ListScripts. +func (mr *MockGameLiftAPIMockRecorder) ListScripts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListScripts", reflect.TypeOf((*MockGameLiftAPI)(nil).ListScripts), arg0) +} + +// ListScriptsPages mocks base method. +func (m *MockGameLiftAPI) ListScriptsPages(arg0 *gamelift.ListScriptsInput, arg1 func(*gamelift.ListScriptsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListScriptsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListScriptsPages indicates an expected call of ListScriptsPages. +func (mr *MockGameLiftAPIMockRecorder) ListScriptsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListScriptsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).ListScriptsPages), arg0, arg1) +} + +// ListScriptsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) ListScriptsPagesWithContext(arg0 aws.Context, arg1 *gamelift.ListScriptsInput, arg2 func(*gamelift.ListScriptsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListScriptsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListScriptsPagesWithContext indicates an expected call of ListScriptsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListScriptsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListScriptsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListScriptsPagesWithContext), varargs...) +} + +// ListScriptsRequest mocks base method. +func (m *MockGameLiftAPI) ListScriptsRequest(arg0 *gamelift.ListScriptsInput) (*request.Request, *gamelift.ListScriptsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListScriptsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListScriptsOutput) + return ret0, ret1 +} + +// ListScriptsRequest indicates an expected call of ListScriptsRequest. +func (mr *MockGameLiftAPIMockRecorder) ListScriptsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListScriptsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListScriptsRequest), arg0) +} + +// ListScriptsWithContext mocks base method. +func (m *MockGameLiftAPI) ListScriptsWithContext(arg0 aws.Context, arg1 *gamelift.ListScriptsInput, arg2 ...request.Option) (*gamelift.ListScriptsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListScriptsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListScriptsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListScriptsWithContext indicates an expected call of ListScriptsWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListScriptsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListScriptsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListScriptsWithContext), varargs...) +} + +// ListTagsForResource mocks base method. +func (m *MockGameLiftAPI) ListTagsForResource(arg0 *gamelift.ListTagsForResourceInput) (*gamelift.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*gamelift.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource. +func (mr *MockGameLiftAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockGameLiftAPI)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourceRequest mocks base method. +func (m *MockGameLiftAPI) ListTagsForResourceRequest(arg0 *gamelift.ListTagsForResourceInput) (*request.Request, *gamelift.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest. +func (mr *MockGameLiftAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method. +func (m *MockGameLiftAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *gamelift.ListTagsForResourceInput, arg2 ...request.Option) (*gamelift.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext. +func (mr *MockGameLiftAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ListTagsForResourceWithContext), varargs...) +} + +// PutScalingPolicy mocks base method. +func (m *MockGameLiftAPI) PutScalingPolicy(arg0 *gamelift.PutScalingPolicyInput) (*gamelift.PutScalingPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutScalingPolicy", arg0) + ret0, _ := ret[0].(*gamelift.PutScalingPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutScalingPolicy indicates an expected call of PutScalingPolicy. +func (mr *MockGameLiftAPIMockRecorder) PutScalingPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicy", reflect.TypeOf((*MockGameLiftAPI)(nil).PutScalingPolicy), arg0) +} + +// PutScalingPolicyRequest mocks base method. +func (m *MockGameLiftAPI) PutScalingPolicyRequest(arg0 *gamelift.PutScalingPolicyInput) (*request.Request, *gamelift.PutScalingPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutScalingPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.PutScalingPolicyOutput) + return ret0, ret1 +} + +// PutScalingPolicyRequest indicates an expected call of PutScalingPolicyRequest. +func (mr *MockGameLiftAPIMockRecorder) PutScalingPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicyRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).PutScalingPolicyRequest), arg0) +} + +// PutScalingPolicyWithContext mocks base method. +func (m *MockGameLiftAPI) PutScalingPolicyWithContext(arg0 aws.Context, arg1 *gamelift.PutScalingPolicyInput, arg2 ...request.Option) (*gamelift.PutScalingPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutScalingPolicyWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.PutScalingPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutScalingPolicyWithContext indicates an expected call of PutScalingPolicyWithContext. +func (mr *MockGameLiftAPIMockRecorder) PutScalingPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicyWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).PutScalingPolicyWithContext), varargs...) +} + +// RegisterCompute mocks base method. +func (m *MockGameLiftAPI) RegisterCompute(arg0 *gamelift.RegisterComputeInput) (*gamelift.RegisterComputeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterCompute", arg0) + ret0, _ := ret[0].(*gamelift.RegisterComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterCompute indicates an expected call of RegisterCompute. +func (mr *MockGameLiftAPIMockRecorder) RegisterCompute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCompute", reflect.TypeOf((*MockGameLiftAPI)(nil).RegisterCompute), arg0) +} + +// RegisterComputeRequest mocks base method. +func (m *MockGameLiftAPI) RegisterComputeRequest(arg0 *gamelift.RegisterComputeInput) (*request.Request, *gamelift.RegisterComputeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterComputeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.RegisterComputeOutput) + return ret0, ret1 +} + +// RegisterComputeRequest indicates an expected call of RegisterComputeRequest. +func (mr *MockGameLiftAPIMockRecorder) RegisterComputeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterComputeRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).RegisterComputeRequest), arg0) +} + +// RegisterComputeWithContext mocks base method. +func (m *MockGameLiftAPI) RegisterComputeWithContext(arg0 aws.Context, arg1 *gamelift.RegisterComputeInput, arg2 ...request.Option) (*gamelift.RegisterComputeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterComputeWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.RegisterComputeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterComputeWithContext indicates an expected call of RegisterComputeWithContext. +func (mr *MockGameLiftAPIMockRecorder) RegisterComputeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterComputeWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).RegisterComputeWithContext), varargs...) +} + +// RegisterGameServer mocks base method. +func (m *MockGameLiftAPI) RegisterGameServer(arg0 *gamelift.RegisterGameServerInput) (*gamelift.RegisterGameServerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterGameServer", arg0) + ret0, _ := ret[0].(*gamelift.RegisterGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterGameServer indicates an expected call of RegisterGameServer. +func (mr *MockGameLiftAPIMockRecorder) RegisterGameServer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGameServer", reflect.TypeOf((*MockGameLiftAPI)(nil).RegisterGameServer), arg0) +} + +// RegisterGameServerRequest mocks base method. +func (m *MockGameLiftAPI) RegisterGameServerRequest(arg0 *gamelift.RegisterGameServerInput) (*request.Request, *gamelift.RegisterGameServerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterGameServerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.RegisterGameServerOutput) + return ret0, ret1 +} + +// RegisterGameServerRequest indicates an expected call of RegisterGameServerRequest. +func (mr *MockGameLiftAPIMockRecorder) RegisterGameServerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGameServerRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).RegisterGameServerRequest), arg0) +} + +// RegisterGameServerWithContext mocks base method. +func (m *MockGameLiftAPI) RegisterGameServerWithContext(arg0 aws.Context, arg1 *gamelift.RegisterGameServerInput, arg2 ...request.Option) (*gamelift.RegisterGameServerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterGameServerWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.RegisterGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterGameServerWithContext indicates an expected call of RegisterGameServerWithContext. +func (mr *MockGameLiftAPIMockRecorder) RegisterGameServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGameServerWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).RegisterGameServerWithContext), varargs...) +} + +// RequestUploadCredentials mocks base method. +func (m *MockGameLiftAPI) RequestUploadCredentials(arg0 *gamelift.RequestUploadCredentialsInput) (*gamelift.RequestUploadCredentialsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestUploadCredentials", arg0) + ret0, _ := ret[0].(*gamelift.RequestUploadCredentialsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestUploadCredentials indicates an expected call of RequestUploadCredentials. +func (mr *MockGameLiftAPIMockRecorder) RequestUploadCredentials(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestUploadCredentials", reflect.TypeOf((*MockGameLiftAPI)(nil).RequestUploadCredentials), arg0) +} + +// RequestUploadCredentialsRequest mocks base method. +func (m *MockGameLiftAPI) RequestUploadCredentialsRequest(arg0 *gamelift.RequestUploadCredentialsInput) (*request.Request, *gamelift.RequestUploadCredentialsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestUploadCredentialsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.RequestUploadCredentialsOutput) + return ret0, ret1 +} + +// RequestUploadCredentialsRequest indicates an expected call of RequestUploadCredentialsRequest. +func (mr *MockGameLiftAPIMockRecorder) RequestUploadCredentialsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestUploadCredentialsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).RequestUploadCredentialsRequest), arg0) +} + +// RequestUploadCredentialsWithContext mocks base method. +func (m *MockGameLiftAPI) RequestUploadCredentialsWithContext(arg0 aws.Context, arg1 *gamelift.RequestUploadCredentialsInput, arg2 ...request.Option) (*gamelift.RequestUploadCredentialsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestUploadCredentialsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.RequestUploadCredentialsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestUploadCredentialsWithContext indicates an expected call of RequestUploadCredentialsWithContext. +func (mr *MockGameLiftAPIMockRecorder) RequestUploadCredentialsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestUploadCredentialsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).RequestUploadCredentialsWithContext), varargs...) +} + +// ResolveAlias mocks base method. +func (m *MockGameLiftAPI) ResolveAlias(arg0 *gamelift.ResolveAliasInput) (*gamelift.ResolveAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResolveAlias", arg0) + ret0, _ := ret[0].(*gamelift.ResolveAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResolveAlias indicates an expected call of ResolveAlias. +func (mr *MockGameLiftAPIMockRecorder) ResolveAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAlias", reflect.TypeOf((*MockGameLiftAPI)(nil).ResolveAlias), arg0) +} + +// ResolveAliasRequest mocks base method. +func (m *MockGameLiftAPI) ResolveAliasRequest(arg0 *gamelift.ResolveAliasInput) (*request.Request, *gamelift.ResolveAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResolveAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ResolveAliasOutput) + return ret0, ret1 +} + +// ResolveAliasRequest indicates an expected call of ResolveAliasRequest. +func (mr *MockGameLiftAPIMockRecorder) ResolveAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAliasRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ResolveAliasRequest), arg0) +} + +// ResolveAliasWithContext mocks base method. +func (m *MockGameLiftAPI) ResolveAliasWithContext(arg0 aws.Context, arg1 *gamelift.ResolveAliasInput, arg2 ...request.Option) (*gamelift.ResolveAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResolveAliasWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ResolveAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResolveAliasWithContext indicates an expected call of ResolveAliasWithContext. +func (mr *MockGameLiftAPIMockRecorder) ResolveAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveAliasWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ResolveAliasWithContext), varargs...) +} + +// ResumeGameServerGroup mocks base method. +func (m *MockGameLiftAPI) ResumeGameServerGroup(arg0 *gamelift.ResumeGameServerGroupInput) (*gamelift.ResumeGameServerGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResumeGameServerGroup", arg0) + ret0, _ := ret[0].(*gamelift.ResumeGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResumeGameServerGroup indicates an expected call of ResumeGameServerGroup. +func (mr *MockGameLiftAPIMockRecorder) ResumeGameServerGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeGameServerGroup", reflect.TypeOf((*MockGameLiftAPI)(nil).ResumeGameServerGroup), arg0) +} + +// ResumeGameServerGroupRequest mocks base method. +func (m *MockGameLiftAPI) ResumeGameServerGroupRequest(arg0 *gamelift.ResumeGameServerGroupInput) (*request.Request, *gamelift.ResumeGameServerGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResumeGameServerGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ResumeGameServerGroupOutput) + return ret0, ret1 +} + +// ResumeGameServerGroupRequest indicates an expected call of ResumeGameServerGroupRequest. +func (mr *MockGameLiftAPIMockRecorder) ResumeGameServerGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeGameServerGroupRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ResumeGameServerGroupRequest), arg0) +} + +// ResumeGameServerGroupWithContext mocks base method. +func (m *MockGameLiftAPI) ResumeGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.ResumeGameServerGroupInput, arg2 ...request.Option) (*gamelift.ResumeGameServerGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResumeGameServerGroupWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ResumeGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResumeGameServerGroupWithContext indicates an expected call of ResumeGameServerGroupWithContext. +func (mr *MockGameLiftAPIMockRecorder) ResumeGameServerGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeGameServerGroupWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ResumeGameServerGroupWithContext), varargs...) +} + +// SearchGameSessions mocks base method. +func (m *MockGameLiftAPI) SearchGameSessions(arg0 *gamelift.SearchGameSessionsInput) (*gamelift.SearchGameSessionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchGameSessions", arg0) + ret0, _ := ret[0].(*gamelift.SearchGameSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchGameSessions indicates an expected call of SearchGameSessions. +func (mr *MockGameLiftAPIMockRecorder) SearchGameSessions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGameSessions", reflect.TypeOf((*MockGameLiftAPI)(nil).SearchGameSessions), arg0) +} + +// SearchGameSessionsPages mocks base method. +func (m *MockGameLiftAPI) SearchGameSessionsPages(arg0 *gamelift.SearchGameSessionsInput, arg1 func(*gamelift.SearchGameSessionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchGameSessionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SearchGameSessionsPages indicates an expected call of SearchGameSessionsPages. +func (mr *MockGameLiftAPIMockRecorder) SearchGameSessionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGameSessionsPages", reflect.TypeOf((*MockGameLiftAPI)(nil).SearchGameSessionsPages), arg0, arg1) +} + +// SearchGameSessionsPagesWithContext mocks base method. +func (m *MockGameLiftAPI) SearchGameSessionsPagesWithContext(arg0 aws.Context, arg1 *gamelift.SearchGameSessionsInput, arg2 func(*gamelift.SearchGameSessionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchGameSessionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SearchGameSessionsPagesWithContext indicates an expected call of SearchGameSessionsPagesWithContext. +func (mr *MockGameLiftAPIMockRecorder) SearchGameSessionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGameSessionsPagesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).SearchGameSessionsPagesWithContext), varargs...) +} + +// SearchGameSessionsRequest mocks base method. +func (m *MockGameLiftAPI) SearchGameSessionsRequest(arg0 *gamelift.SearchGameSessionsInput) (*request.Request, *gamelift.SearchGameSessionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchGameSessionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.SearchGameSessionsOutput) + return ret0, ret1 +} + +// SearchGameSessionsRequest indicates an expected call of SearchGameSessionsRequest. +func (mr *MockGameLiftAPIMockRecorder) SearchGameSessionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGameSessionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).SearchGameSessionsRequest), arg0) +} + +// SearchGameSessionsWithContext mocks base method. +func (m *MockGameLiftAPI) SearchGameSessionsWithContext(arg0 aws.Context, arg1 *gamelift.SearchGameSessionsInput, arg2 ...request.Option) (*gamelift.SearchGameSessionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchGameSessionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.SearchGameSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchGameSessionsWithContext indicates an expected call of SearchGameSessionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) SearchGameSessionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGameSessionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).SearchGameSessionsWithContext), varargs...) +} + +// StartFleetActions mocks base method. +func (m *MockGameLiftAPI) StartFleetActions(arg0 *gamelift.StartFleetActionsInput) (*gamelift.StartFleetActionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartFleetActions", arg0) + ret0, _ := ret[0].(*gamelift.StartFleetActionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartFleetActions indicates an expected call of StartFleetActions. +func (mr *MockGameLiftAPIMockRecorder) StartFleetActions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartFleetActions", reflect.TypeOf((*MockGameLiftAPI)(nil).StartFleetActions), arg0) +} + +// StartFleetActionsRequest mocks base method. +func (m *MockGameLiftAPI) StartFleetActionsRequest(arg0 *gamelift.StartFleetActionsInput) (*request.Request, *gamelift.StartFleetActionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartFleetActionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.StartFleetActionsOutput) + return ret0, ret1 +} + +// StartFleetActionsRequest indicates an expected call of StartFleetActionsRequest. +func (mr *MockGameLiftAPIMockRecorder) StartFleetActionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartFleetActionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).StartFleetActionsRequest), arg0) +} + +// StartFleetActionsWithContext mocks base method. +func (m *MockGameLiftAPI) StartFleetActionsWithContext(arg0 aws.Context, arg1 *gamelift.StartFleetActionsInput, arg2 ...request.Option) (*gamelift.StartFleetActionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartFleetActionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.StartFleetActionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartFleetActionsWithContext indicates an expected call of StartFleetActionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) StartFleetActionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartFleetActionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).StartFleetActionsWithContext), varargs...) +} + +// StartGameSessionPlacement mocks base method. +func (m *MockGameLiftAPI) StartGameSessionPlacement(arg0 *gamelift.StartGameSessionPlacementInput) (*gamelift.StartGameSessionPlacementOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartGameSessionPlacement", arg0) + ret0, _ := ret[0].(*gamelift.StartGameSessionPlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartGameSessionPlacement indicates an expected call of StartGameSessionPlacement. +func (mr *MockGameLiftAPIMockRecorder) StartGameSessionPlacement(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartGameSessionPlacement", reflect.TypeOf((*MockGameLiftAPI)(nil).StartGameSessionPlacement), arg0) +} + +// StartGameSessionPlacementRequest mocks base method. +func (m *MockGameLiftAPI) StartGameSessionPlacementRequest(arg0 *gamelift.StartGameSessionPlacementInput) (*request.Request, *gamelift.StartGameSessionPlacementOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartGameSessionPlacementRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.StartGameSessionPlacementOutput) + return ret0, ret1 +} + +// StartGameSessionPlacementRequest indicates an expected call of StartGameSessionPlacementRequest. +func (mr *MockGameLiftAPIMockRecorder) StartGameSessionPlacementRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartGameSessionPlacementRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).StartGameSessionPlacementRequest), arg0) +} + +// StartGameSessionPlacementWithContext mocks base method. +func (m *MockGameLiftAPI) StartGameSessionPlacementWithContext(arg0 aws.Context, arg1 *gamelift.StartGameSessionPlacementInput, arg2 ...request.Option) (*gamelift.StartGameSessionPlacementOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartGameSessionPlacementWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.StartGameSessionPlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartGameSessionPlacementWithContext indicates an expected call of StartGameSessionPlacementWithContext. +func (mr *MockGameLiftAPIMockRecorder) StartGameSessionPlacementWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartGameSessionPlacementWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).StartGameSessionPlacementWithContext), varargs...) +} + +// StartMatchBackfill mocks base method. +func (m *MockGameLiftAPI) StartMatchBackfill(arg0 *gamelift.StartMatchBackfillInput) (*gamelift.StartMatchBackfillOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartMatchBackfill", arg0) + ret0, _ := ret[0].(*gamelift.StartMatchBackfillOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartMatchBackfill indicates an expected call of StartMatchBackfill. +func (mr *MockGameLiftAPIMockRecorder) StartMatchBackfill(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMatchBackfill", reflect.TypeOf((*MockGameLiftAPI)(nil).StartMatchBackfill), arg0) +} + +// StartMatchBackfillRequest mocks base method. +func (m *MockGameLiftAPI) StartMatchBackfillRequest(arg0 *gamelift.StartMatchBackfillInput) (*request.Request, *gamelift.StartMatchBackfillOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartMatchBackfillRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.StartMatchBackfillOutput) + return ret0, ret1 +} + +// StartMatchBackfillRequest indicates an expected call of StartMatchBackfillRequest. +func (mr *MockGameLiftAPIMockRecorder) StartMatchBackfillRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMatchBackfillRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).StartMatchBackfillRequest), arg0) +} + +// StartMatchBackfillWithContext mocks base method. +func (m *MockGameLiftAPI) StartMatchBackfillWithContext(arg0 aws.Context, arg1 *gamelift.StartMatchBackfillInput, arg2 ...request.Option) (*gamelift.StartMatchBackfillOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartMatchBackfillWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.StartMatchBackfillOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartMatchBackfillWithContext indicates an expected call of StartMatchBackfillWithContext. +func (mr *MockGameLiftAPIMockRecorder) StartMatchBackfillWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMatchBackfillWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).StartMatchBackfillWithContext), varargs...) +} + +// StartMatchmaking mocks base method. +func (m *MockGameLiftAPI) StartMatchmaking(arg0 *gamelift.StartMatchmakingInput) (*gamelift.StartMatchmakingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartMatchmaking", arg0) + ret0, _ := ret[0].(*gamelift.StartMatchmakingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartMatchmaking indicates an expected call of StartMatchmaking. +func (mr *MockGameLiftAPIMockRecorder) StartMatchmaking(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMatchmaking", reflect.TypeOf((*MockGameLiftAPI)(nil).StartMatchmaking), arg0) +} + +// StartMatchmakingRequest mocks base method. +func (m *MockGameLiftAPI) StartMatchmakingRequest(arg0 *gamelift.StartMatchmakingInput) (*request.Request, *gamelift.StartMatchmakingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartMatchmakingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.StartMatchmakingOutput) + return ret0, ret1 +} + +// StartMatchmakingRequest indicates an expected call of StartMatchmakingRequest. +func (mr *MockGameLiftAPIMockRecorder) StartMatchmakingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMatchmakingRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).StartMatchmakingRequest), arg0) +} + +// StartMatchmakingWithContext mocks base method. +func (m *MockGameLiftAPI) StartMatchmakingWithContext(arg0 aws.Context, arg1 *gamelift.StartMatchmakingInput, arg2 ...request.Option) (*gamelift.StartMatchmakingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartMatchmakingWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.StartMatchmakingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartMatchmakingWithContext indicates an expected call of StartMatchmakingWithContext. +func (mr *MockGameLiftAPIMockRecorder) StartMatchmakingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMatchmakingWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).StartMatchmakingWithContext), varargs...) +} + +// StopFleetActions mocks base method. +func (m *MockGameLiftAPI) StopFleetActions(arg0 *gamelift.StopFleetActionsInput) (*gamelift.StopFleetActionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopFleetActions", arg0) + ret0, _ := ret[0].(*gamelift.StopFleetActionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopFleetActions indicates an expected call of StopFleetActions. +func (mr *MockGameLiftAPIMockRecorder) StopFleetActions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopFleetActions", reflect.TypeOf((*MockGameLiftAPI)(nil).StopFleetActions), arg0) +} + +// StopFleetActionsRequest mocks base method. +func (m *MockGameLiftAPI) StopFleetActionsRequest(arg0 *gamelift.StopFleetActionsInput) (*request.Request, *gamelift.StopFleetActionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopFleetActionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.StopFleetActionsOutput) + return ret0, ret1 +} + +// StopFleetActionsRequest indicates an expected call of StopFleetActionsRequest. +func (mr *MockGameLiftAPIMockRecorder) StopFleetActionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopFleetActionsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).StopFleetActionsRequest), arg0) +} + +// StopFleetActionsWithContext mocks base method. +func (m *MockGameLiftAPI) StopFleetActionsWithContext(arg0 aws.Context, arg1 *gamelift.StopFleetActionsInput, arg2 ...request.Option) (*gamelift.StopFleetActionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopFleetActionsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.StopFleetActionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopFleetActionsWithContext indicates an expected call of StopFleetActionsWithContext. +func (mr *MockGameLiftAPIMockRecorder) StopFleetActionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopFleetActionsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).StopFleetActionsWithContext), varargs...) +} + +// StopGameSessionPlacement mocks base method. +func (m *MockGameLiftAPI) StopGameSessionPlacement(arg0 *gamelift.StopGameSessionPlacementInput) (*gamelift.StopGameSessionPlacementOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopGameSessionPlacement", arg0) + ret0, _ := ret[0].(*gamelift.StopGameSessionPlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopGameSessionPlacement indicates an expected call of StopGameSessionPlacement. +func (mr *MockGameLiftAPIMockRecorder) StopGameSessionPlacement(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopGameSessionPlacement", reflect.TypeOf((*MockGameLiftAPI)(nil).StopGameSessionPlacement), arg0) +} + +// StopGameSessionPlacementRequest mocks base method. +func (m *MockGameLiftAPI) StopGameSessionPlacementRequest(arg0 *gamelift.StopGameSessionPlacementInput) (*request.Request, *gamelift.StopGameSessionPlacementOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopGameSessionPlacementRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.StopGameSessionPlacementOutput) + return ret0, ret1 +} + +// StopGameSessionPlacementRequest indicates an expected call of StopGameSessionPlacementRequest. +func (mr *MockGameLiftAPIMockRecorder) StopGameSessionPlacementRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopGameSessionPlacementRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).StopGameSessionPlacementRequest), arg0) +} + +// StopGameSessionPlacementWithContext mocks base method. +func (m *MockGameLiftAPI) StopGameSessionPlacementWithContext(arg0 aws.Context, arg1 *gamelift.StopGameSessionPlacementInput, arg2 ...request.Option) (*gamelift.StopGameSessionPlacementOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopGameSessionPlacementWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.StopGameSessionPlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopGameSessionPlacementWithContext indicates an expected call of StopGameSessionPlacementWithContext. +func (mr *MockGameLiftAPIMockRecorder) StopGameSessionPlacementWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopGameSessionPlacementWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).StopGameSessionPlacementWithContext), varargs...) +} + +// StopMatchmaking mocks base method. +func (m *MockGameLiftAPI) StopMatchmaking(arg0 *gamelift.StopMatchmakingInput) (*gamelift.StopMatchmakingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopMatchmaking", arg0) + ret0, _ := ret[0].(*gamelift.StopMatchmakingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopMatchmaking indicates an expected call of StopMatchmaking. +func (mr *MockGameLiftAPIMockRecorder) StopMatchmaking(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopMatchmaking", reflect.TypeOf((*MockGameLiftAPI)(nil).StopMatchmaking), arg0) +} + +// StopMatchmakingRequest mocks base method. +func (m *MockGameLiftAPI) StopMatchmakingRequest(arg0 *gamelift.StopMatchmakingInput) (*request.Request, *gamelift.StopMatchmakingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopMatchmakingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.StopMatchmakingOutput) + return ret0, ret1 +} + +// StopMatchmakingRequest indicates an expected call of StopMatchmakingRequest. +func (mr *MockGameLiftAPIMockRecorder) StopMatchmakingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopMatchmakingRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).StopMatchmakingRequest), arg0) +} + +// StopMatchmakingWithContext mocks base method. +func (m *MockGameLiftAPI) StopMatchmakingWithContext(arg0 aws.Context, arg1 *gamelift.StopMatchmakingInput, arg2 ...request.Option) (*gamelift.StopMatchmakingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopMatchmakingWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.StopMatchmakingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopMatchmakingWithContext indicates an expected call of StopMatchmakingWithContext. +func (mr *MockGameLiftAPIMockRecorder) StopMatchmakingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopMatchmakingWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).StopMatchmakingWithContext), varargs...) +} + +// SuspendGameServerGroup mocks base method. +func (m *MockGameLiftAPI) SuspendGameServerGroup(arg0 *gamelift.SuspendGameServerGroupInput) (*gamelift.SuspendGameServerGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SuspendGameServerGroup", arg0) + ret0, _ := ret[0].(*gamelift.SuspendGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SuspendGameServerGroup indicates an expected call of SuspendGameServerGroup. +func (mr *MockGameLiftAPIMockRecorder) SuspendGameServerGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendGameServerGroup", reflect.TypeOf((*MockGameLiftAPI)(nil).SuspendGameServerGroup), arg0) +} + +// SuspendGameServerGroupRequest mocks base method. +func (m *MockGameLiftAPI) SuspendGameServerGroupRequest(arg0 *gamelift.SuspendGameServerGroupInput) (*request.Request, *gamelift.SuspendGameServerGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SuspendGameServerGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.SuspendGameServerGroupOutput) + return ret0, ret1 +} + +// SuspendGameServerGroupRequest indicates an expected call of SuspendGameServerGroupRequest. +func (mr *MockGameLiftAPIMockRecorder) SuspendGameServerGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendGameServerGroupRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).SuspendGameServerGroupRequest), arg0) +} + +// SuspendGameServerGroupWithContext mocks base method. +func (m *MockGameLiftAPI) SuspendGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.SuspendGameServerGroupInput, arg2 ...request.Option) (*gamelift.SuspendGameServerGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SuspendGameServerGroupWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.SuspendGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SuspendGameServerGroupWithContext indicates an expected call of SuspendGameServerGroupWithContext. +func (mr *MockGameLiftAPIMockRecorder) SuspendGameServerGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendGameServerGroupWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).SuspendGameServerGroupWithContext), varargs...) +} + +// TagResource mocks base method. +func (m *MockGameLiftAPI) TagResource(arg0 *gamelift.TagResourceInput) (*gamelift.TagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResource", arg0) + ret0, _ := ret[0].(*gamelift.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResource indicates an expected call of TagResource. +func (mr *MockGameLiftAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockGameLiftAPI)(nil).TagResource), arg0) +} + +// TagResourceRequest mocks base method. +func (m *MockGameLiftAPI) TagResourceRequest(arg0 *gamelift.TagResourceInput) (*request.Request, *gamelift.TagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.TagResourceOutput) + return ret0, ret1 +} + +// TagResourceRequest indicates an expected call of TagResourceRequest. +func (mr *MockGameLiftAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).TagResourceRequest), arg0) +} + +// TagResourceWithContext mocks base method. +func (m *MockGameLiftAPI) TagResourceWithContext(arg0 aws.Context, arg1 *gamelift.TagResourceInput, arg2 ...request.Option) (*gamelift.TagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResourceWithContext indicates an expected call of TagResourceWithContext. +func (mr *MockGameLiftAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).TagResourceWithContext), varargs...) +} + +// UntagResource mocks base method. +func (m *MockGameLiftAPI) UntagResource(arg0 *gamelift.UntagResourceInput) (*gamelift.UntagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResource", arg0) + ret0, _ := ret[0].(*gamelift.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResource indicates an expected call of UntagResource. +func (mr *MockGameLiftAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockGameLiftAPI)(nil).UntagResource), arg0) +} + +// UntagResourceRequest mocks base method. +func (m *MockGameLiftAPI) UntagResourceRequest(arg0 *gamelift.UntagResourceInput) (*request.Request, *gamelift.UntagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UntagResourceOutput) + return ret0, ret1 +} + +// UntagResourceRequest indicates an expected call of UntagResourceRequest. +func (mr *MockGameLiftAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UntagResourceRequest), arg0) +} + +// UntagResourceWithContext mocks base method. +func (m *MockGameLiftAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *gamelift.UntagResourceInput, arg2 ...request.Option) (*gamelift.UntagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResourceWithContext indicates an expected call of UntagResourceWithContext. +func (mr *MockGameLiftAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UntagResourceWithContext), varargs...) +} + +// UpdateAlias mocks base method. +func (m *MockGameLiftAPI) UpdateAlias(arg0 *gamelift.UpdateAliasInput) (*gamelift.UpdateAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAlias", arg0) + ret0, _ := ret[0].(*gamelift.UpdateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAlias indicates an expected call of UpdateAlias. +func (mr *MockGameLiftAPIMockRecorder) UpdateAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAlias", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateAlias), arg0) +} + +// UpdateAliasRequest mocks base method. +func (m *MockGameLiftAPI) UpdateAliasRequest(arg0 *gamelift.UpdateAliasInput) (*request.Request, *gamelift.UpdateAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateAliasOutput) + return ret0, ret1 +} + +// UpdateAliasRequest indicates an expected call of UpdateAliasRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAliasRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateAliasRequest), arg0) +} + +// UpdateAliasWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateAliasWithContext(arg0 aws.Context, arg1 *gamelift.UpdateAliasInput, arg2 ...request.Option) (*gamelift.UpdateAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateAliasWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAliasWithContext indicates an expected call of UpdateAliasWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAliasWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateAliasWithContext), varargs...) +} + +// UpdateBuild mocks base method. +func (m *MockGameLiftAPI) UpdateBuild(arg0 *gamelift.UpdateBuildInput) (*gamelift.UpdateBuildOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBuild", arg0) + ret0, _ := ret[0].(*gamelift.UpdateBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateBuild indicates an expected call of UpdateBuild. +func (mr *MockGameLiftAPIMockRecorder) UpdateBuild(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuild", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateBuild), arg0) +} + +// UpdateBuildRequest mocks base method. +func (m *MockGameLiftAPI) UpdateBuildRequest(arg0 *gamelift.UpdateBuildInput) (*request.Request, *gamelift.UpdateBuildOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateBuildRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateBuildOutput) + return ret0, ret1 +} + +// UpdateBuildRequest indicates an expected call of UpdateBuildRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateBuildRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateBuildRequest), arg0) +} + +// UpdateBuildWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateBuildWithContext(arg0 aws.Context, arg1 *gamelift.UpdateBuildInput, arg2 ...request.Option) (*gamelift.UpdateBuildOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateBuildWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateBuildOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateBuildWithContext indicates an expected call of UpdateBuildWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateBuildWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateBuildWithContext), varargs...) +} + +// UpdateFleetAttributes mocks base method. +func (m *MockGameLiftAPI) UpdateFleetAttributes(arg0 *gamelift.UpdateFleetAttributesInput) (*gamelift.UpdateFleetAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFleetAttributes", arg0) + ret0, _ := ret[0].(*gamelift.UpdateFleetAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFleetAttributes indicates an expected call of UpdateFleetAttributes. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetAttributes", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetAttributes), arg0) +} + +// UpdateFleetAttributesRequest mocks base method. +func (m *MockGameLiftAPI) UpdateFleetAttributesRequest(arg0 *gamelift.UpdateFleetAttributesInput) (*request.Request, *gamelift.UpdateFleetAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFleetAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateFleetAttributesOutput) + return ret0, ret1 +} + +// UpdateFleetAttributesRequest indicates an expected call of UpdateFleetAttributesRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetAttributesRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetAttributesRequest), arg0) +} + +// UpdateFleetAttributesWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateFleetAttributesWithContext(arg0 aws.Context, arg1 *gamelift.UpdateFleetAttributesInput, arg2 ...request.Option) (*gamelift.UpdateFleetAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateFleetAttributesWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateFleetAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFleetAttributesWithContext indicates an expected call of UpdateFleetAttributesWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetAttributesWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetAttributesWithContext), varargs...) +} + +// UpdateFleetCapacity mocks base method. +func (m *MockGameLiftAPI) UpdateFleetCapacity(arg0 *gamelift.UpdateFleetCapacityInput) (*gamelift.UpdateFleetCapacityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFleetCapacity", arg0) + ret0, _ := ret[0].(*gamelift.UpdateFleetCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFleetCapacity indicates an expected call of UpdateFleetCapacity. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetCapacity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetCapacity", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetCapacity), arg0) +} + +// UpdateFleetCapacityRequest mocks base method. +func (m *MockGameLiftAPI) UpdateFleetCapacityRequest(arg0 *gamelift.UpdateFleetCapacityInput) (*request.Request, *gamelift.UpdateFleetCapacityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFleetCapacityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateFleetCapacityOutput) + return ret0, ret1 +} + +// UpdateFleetCapacityRequest indicates an expected call of UpdateFleetCapacityRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetCapacityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetCapacityRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetCapacityRequest), arg0) +} + +// UpdateFleetCapacityWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateFleetCapacityWithContext(arg0 aws.Context, arg1 *gamelift.UpdateFleetCapacityInput, arg2 ...request.Option) (*gamelift.UpdateFleetCapacityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateFleetCapacityWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateFleetCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFleetCapacityWithContext indicates an expected call of UpdateFleetCapacityWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetCapacityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetCapacityWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetCapacityWithContext), varargs...) +} + +// UpdateFleetPortSettings mocks base method. +func (m *MockGameLiftAPI) UpdateFleetPortSettings(arg0 *gamelift.UpdateFleetPortSettingsInput) (*gamelift.UpdateFleetPortSettingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFleetPortSettings", arg0) + ret0, _ := ret[0].(*gamelift.UpdateFleetPortSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFleetPortSettings indicates an expected call of UpdateFleetPortSettings. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetPortSettings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetPortSettings", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetPortSettings), arg0) +} + +// UpdateFleetPortSettingsRequest mocks base method. +func (m *MockGameLiftAPI) UpdateFleetPortSettingsRequest(arg0 *gamelift.UpdateFleetPortSettingsInput) (*request.Request, *gamelift.UpdateFleetPortSettingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFleetPortSettingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateFleetPortSettingsOutput) + return ret0, ret1 +} + +// UpdateFleetPortSettingsRequest indicates an expected call of UpdateFleetPortSettingsRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetPortSettingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetPortSettingsRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetPortSettingsRequest), arg0) +} + +// UpdateFleetPortSettingsWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateFleetPortSettingsWithContext(arg0 aws.Context, arg1 *gamelift.UpdateFleetPortSettingsInput, arg2 ...request.Option) (*gamelift.UpdateFleetPortSettingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateFleetPortSettingsWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateFleetPortSettingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFleetPortSettingsWithContext indicates an expected call of UpdateFleetPortSettingsWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateFleetPortSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFleetPortSettingsWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateFleetPortSettingsWithContext), varargs...) +} + +// UpdateGameServer mocks base method. +func (m *MockGameLiftAPI) UpdateGameServer(arg0 *gamelift.UpdateGameServerInput) (*gamelift.UpdateGameServerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameServer", arg0) + ret0, _ := ret[0].(*gamelift.UpdateGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameServer indicates an expected call of UpdateGameServer. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameServer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameServer", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameServer), arg0) +} + +// UpdateGameServerGroup mocks base method. +func (m *MockGameLiftAPI) UpdateGameServerGroup(arg0 *gamelift.UpdateGameServerGroupInput) (*gamelift.UpdateGameServerGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameServerGroup", arg0) + ret0, _ := ret[0].(*gamelift.UpdateGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameServerGroup indicates an expected call of UpdateGameServerGroup. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameServerGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameServerGroup", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameServerGroup), arg0) +} + +// UpdateGameServerGroupRequest mocks base method. +func (m *MockGameLiftAPI) UpdateGameServerGroupRequest(arg0 *gamelift.UpdateGameServerGroupInput) (*request.Request, *gamelift.UpdateGameServerGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameServerGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateGameServerGroupOutput) + return ret0, ret1 +} + +// UpdateGameServerGroupRequest indicates an expected call of UpdateGameServerGroupRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameServerGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameServerGroupRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameServerGroupRequest), arg0) +} + +// UpdateGameServerGroupWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateGameServerGroupWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameServerGroupInput, arg2 ...request.Option) (*gamelift.UpdateGameServerGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateGameServerGroupWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateGameServerGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameServerGroupWithContext indicates an expected call of UpdateGameServerGroupWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameServerGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameServerGroupWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameServerGroupWithContext), varargs...) +} + +// UpdateGameServerRequest mocks base method. +func (m *MockGameLiftAPI) UpdateGameServerRequest(arg0 *gamelift.UpdateGameServerInput) (*request.Request, *gamelift.UpdateGameServerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameServerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateGameServerOutput) + return ret0, ret1 +} + +// UpdateGameServerRequest indicates an expected call of UpdateGameServerRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameServerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameServerRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameServerRequest), arg0) +} + +// UpdateGameServerWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateGameServerWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameServerInput, arg2 ...request.Option) (*gamelift.UpdateGameServerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateGameServerWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateGameServerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameServerWithContext indicates an expected call of UpdateGameServerWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameServerWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameServerWithContext), varargs...) +} + +// UpdateGameSession mocks base method. +func (m *MockGameLiftAPI) UpdateGameSession(arg0 *gamelift.UpdateGameSessionInput) (*gamelift.UpdateGameSessionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameSession", arg0) + ret0, _ := ret[0].(*gamelift.UpdateGameSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameSession indicates an expected call of UpdateGameSession. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameSession(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameSession", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameSession), arg0) +} + +// UpdateGameSessionQueue mocks base method. +func (m *MockGameLiftAPI) UpdateGameSessionQueue(arg0 *gamelift.UpdateGameSessionQueueInput) (*gamelift.UpdateGameSessionQueueOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameSessionQueue", arg0) + ret0, _ := ret[0].(*gamelift.UpdateGameSessionQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameSessionQueue indicates an expected call of UpdateGameSessionQueue. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameSessionQueue(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameSessionQueue", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameSessionQueue), arg0) +} + +// UpdateGameSessionQueueRequest mocks base method. +func (m *MockGameLiftAPI) UpdateGameSessionQueueRequest(arg0 *gamelift.UpdateGameSessionQueueInput) (*request.Request, *gamelift.UpdateGameSessionQueueOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameSessionQueueRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateGameSessionQueueOutput) + return ret0, ret1 +} + +// UpdateGameSessionQueueRequest indicates an expected call of UpdateGameSessionQueueRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameSessionQueueRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameSessionQueueRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameSessionQueueRequest), arg0) +} + +// UpdateGameSessionQueueWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateGameSessionQueueWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameSessionQueueInput, arg2 ...request.Option) (*gamelift.UpdateGameSessionQueueOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateGameSessionQueueWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateGameSessionQueueOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameSessionQueueWithContext indicates an expected call of UpdateGameSessionQueueWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameSessionQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameSessionQueueWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameSessionQueueWithContext), varargs...) +} + +// UpdateGameSessionRequest mocks base method. +func (m *MockGameLiftAPI) UpdateGameSessionRequest(arg0 *gamelift.UpdateGameSessionInput) (*request.Request, *gamelift.UpdateGameSessionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGameSessionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateGameSessionOutput) + return ret0, ret1 +} + +// UpdateGameSessionRequest indicates an expected call of UpdateGameSessionRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameSessionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameSessionRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameSessionRequest), arg0) +} + +// UpdateGameSessionWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateGameSessionWithContext(arg0 aws.Context, arg1 *gamelift.UpdateGameSessionInput, arg2 ...request.Option) (*gamelift.UpdateGameSessionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateGameSessionWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateGameSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGameSessionWithContext indicates an expected call of UpdateGameSessionWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateGameSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGameSessionWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateGameSessionWithContext), varargs...) +} + +// UpdateMatchmakingConfiguration mocks base method. +func (m *MockGameLiftAPI) UpdateMatchmakingConfiguration(arg0 *gamelift.UpdateMatchmakingConfigurationInput) (*gamelift.UpdateMatchmakingConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateMatchmakingConfiguration", arg0) + ret0, _ := ret[0].(*gamelift.UpdateMatchmakingConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateMatchmakingConfiguration indicates an expected call of UpdateMatchmakingConfiguration. +func (mr *MockGameLiftAPIMockRecorder) UpdateMatchmakingConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMatchmakingConfiguration", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateMatchmakingConfiguration), arg0) +} + +// UpdateMatchmakingConfigurationRequest mocks base method. +func (m *MockGameLiftAPI) UpdateMatchmakingConfigurationRequest(arg0 *gamelift.UpdateMatchmakingConfigurationInput) (*request.Request, *gamelift.UpdateMatchmakingConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateMatchmakingConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateMatchmakingConfigurationOutput) + return ret0, ret1 +} + +// UpdateMatchmakingConfigurationRequest indicates an expected call of UpdateMatchmakingConfigurationRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateMatchmakingConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMatchmakingConfigurationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateMatchmakingConfigurationRequest), arg0) +} + +// UpdateMatchmakingConfigurationWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateMatchmakingConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.UpdateMatchmakingConfigurationInput, arg2 ...request.Option) (*gamelift.UpdateMatchmakingConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateMatchmakingConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateMatchmakingConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateMatchmakingConfigurationWithContext indicates an expected call of UpdateMatchmakingConfigurationWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateMatchmakingConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMatchmakingConfigurationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateMatchmakingConfigurationWithContext), varargs...) +} + +// UpdateRuntimeConfiguration mocks base method. +func (m *MockGameLiftAPI) UpdateRuntimeConfiguration(arg0 *gamelift.UpdateRuntimeConfigurationInput) (*gamelift.UpdateRuntimeConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRuntimeConfiguration", arg0) + ret0, _ := ret[0].(*gamelift.UpdateRuntimeConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateRuntimeConfiguration indicates an expected call of UpdateRuntimeConfiguration. +func (mr *MockGameLiftAPIMockRecorder) UpdateRuntimeConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRuntimeConfiguration", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateRuntimeConfiguration), arg0) +} + +// UpdateRuntimeConfigurationRequest mocks base method. +func (m *MockGameLiftAPI) UpdateRuntimeConfigurationRequest(arg0 *gamelift.UpdateRuntimeConfigurationInput) (*request.Request, *gamelift.UpdateRuntimeConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRuntimeConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateRuntimeConfigurationOutput) + return ret0, ret1 +} + +// UpdateRuntimeConfigurationRequest indicates an expected call of UpdateRuntimeConfigurationRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateRuntimeConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRuntimeConfigurationRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateRuntimeConfigurationRequest), arg0) +} + +// UpdateRuntimeConfigurationWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateRuntimeConfigurationWithContext(arg0 aws.Context, arg1 *gamelift.UpdateRuntimeConfigurationInput, arg2 ...request.Option) (*gamelift.UpdateRuntimeConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateRuntimeConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateRuntimeConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateRuntimeConfigurationWithContext indicates an expected call of UpdateRuntimeConfigurationWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateRuntimeConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRuntimeConfigurationWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateRuntimeConfigurationWithContext), varargs...) +} + +// UpdateScript mocks base method. +func (m *MockGameLiftAPI) UpdateScript(arg0 *gamelift.UpdateScriptInput) (*gamelift.UpdateScriptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateScript", arg0) + ret0, _ := ret[0].(*gamelift.UpdateScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateScript indicates an expected call of UpdateScript. +func (mr *MockGameLiftAPIMockRecorder) UpdateScript(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScript", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateScript), arg0) +} + +// UpdateScriptRequest mocks base method. +func (m *MockGameLiftAPI) UpdateScriptRequest(arg0 *gamelift.UpdateScriptInput) (*request.Request, *gamelift.UpdateScriptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateScriptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.UpdateScriptOutput) + return ret0, ret1 +} + +// UpdateScriptRequest indicates an expected call of UpdateScriptRequest. +func (mr *MockGameLiftAPIMockRecorder) UpdateScriptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScriptRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateScriptRequest), arg0) +} + +// UpdateScriptWithContext mocks base method. +func (m *MockGameLiftAPI) UpdateScriptWithContext(arg0 aws.Context, arg1 *gamelift.UpdateScriptInput, arg2 ...request.Option) (*gamelift.UpdateScriptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateScriptWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.UpdateScriptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateScriptWithContext indicates an expected call of UpdateScriptWithContext. +func (mr *MockGameLiftAPIMockRecorder) UpdateScriptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScriptWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).UpdateScriptWithContext), varargs...) +} + +// ValidateMatchmakingRuleSet mocks base method. +func (m *MockGameLiftAPI) ValidateMatchmakingRuleSet(arg0 *gamelift.ValidateMatchmakingRuleSetInput) (*gamelift.ValidateMatchmakingRuleSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidateMatchmakingRuleSet", arg0) + ret0, _ := ret[0].(*gamelift.ValidateMatchmakingRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ValidateMatchmakingRuleSet indicates an expected call of ValidateMatchmakingRuleSet. +func (mr *MockGameLiftAPIMockRecorder) ValidateMatchmakingRuleSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateMatchmakingRuleSet", reflect.TypeOf((*MockGameLiftAPI)(nil).ValidateMatchmakingRuleSet), arg0) +} + +// ValidateMatchmakingRuleSetRequest mocks base method. +func (m *MockGameLiftAPI) ValidateMatchmakingRuleSetRequest(arg0 *gamelift.ValidateMatchmakingRuleSetInput) (*request.Request, *gamelift.ValidateMatchmakingRuleSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidateMatchmakingRuleSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*gamelift.ValidateMatchmakingRuleSetOutput) + return ret0, ret1 +} + +// ValidateMatchmakingRuleSetRequest indicates an expected call of ValidateMatchmakingRuleSetRequest. +func (mr *MockGameLiftAPIMockRecorder) ValidateMatchmakingRuleSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateMatchmakingRuleSetRequest", reflect.TypeOf((*MockGameLiftAPI)(nil).ValidateMatchmakingRuleSetRequest), arg0) +} + +// ValidateMatchmakingRuleSetWithContext mocks base method. +func (m *MockGameLiftAPI) ValidateMatchmakingRuleSetWithContext(arg0 aws.Context, arg1 *gamelift.ValidateMatchmakingRuleSetInput, arg2 ...request.Option) (*gamelift.ValidateMatchmakingRuleSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ValidateMatchmakingRuleSetWithContext", varargs...) + ret0, _ := ret[0].(*gamelift.ValidateMatchmakingRuleSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ValidateMatchmakingRuleSetWithContext indicates an expected call of ValidateMatchmakingRuleSetWithContext. +func (mr *MockGameLiftAPIMockRecorder) ValidateMatchmakingRuleSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateMatchmakingRuleSetWithContext", reflect.TypeOf((*MockGameLiftAPI)(nil).ValidateMatchmakingRuleSetWithContext), varargs...) +} diff --git a/resources/gamelift_mock_test.go b/resources/gamelift_mock_test.go new file mode 100644 index 00000000..175f1758 --- /dev/null +++ b/resources/gamelift_mock_test.go @@ -0,0 +1,4 @@ +//go:generate ../mocks/generate_mocks.sh gamelift gameliftiface +package resources + +// Note: empty on purpose, this file exist purely to generate mocks for the IAM service From 58498aaba1e14cbe8a4a96bb501225e14b3ea79a Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 16:04:54 -0600 Subject: [PATCH 17/23] feat(gamelift-build): add properties --- resources/gamelift-build.go | 52 +++++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) diff --git a/resources/gamelift-build.go b/resources/gamelift-build.go index 1953a364..96087e72 100644 --- a/resources/gamelift-build.go +++ b/resources/gamelift-build.go @@ -2,11 +2,13 @@ package resources import ( "context" + "time" "github.com/aws/aws-sdk-go/service/gamelift" "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) @@ -25,28 +27,46 @@ type GameLiftBuildLister struct{} func (l *GameLiftBuildLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := gamelift.New(opts.Session) - resp, err := svc.ListBuilds(&gamelift.ListBuildsInput{}) - if err != nil { - return nil, err - } - - builds := make([]resource.Resource, 0) - for _, build := range resp.Builds { - builds = append(builds, &GameLiftBuild{ - svc: svc, - BuildID: build.BuildId, - }) + params := &gamelift.ListBuildsInput{} + + for { + resp, err := svc.ListBuilds(params) + if err != nil { + return nil, err + } + + for _, build := range resp.Builds { + resources = append(resources, &GameLiftBuild{ + svc: svc, + BuildID: build.BuildId, + Name: build.Name, + Status: build.Status, + Version: build.Version, + CreationDate: build.CreationTime, + }) + } + + if resp.NextToken == nil { + break + } + + params.NextToken = resp.NextToken } - return builds, nil + return resources, nil } type GameLiftBuild struct { - svc *gamelift.GameLift - BuildID *string + svc *gamelift.GameLift + BuildID *string + Name *string + Status *string + Version *string + CreationDate *time.Time } func (r *GameLiftBuild) Remove(_ context.Context) error { @@ -62,6 +82,10 @@ func (r *GameLiftBuild) Remove(_ context.Context) error { return nil } +func (r *GameLiftBuild) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) +} + func (r *GameLiftBuild) String() string { return *r.BuildID } From 716b15b4177f98a2c9c33bb951a77678b501a1ca Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 16:07:29 -0600 Subject: [PATCH 18/23] feat(gamelift-fleet): add properties and pagination support --- resources/gamelift-fleet.go | 44 ++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 15 deletions(-) diff --git a/resources/gamelift-fleet.go b/resources/gamelift-fleet.go index 1e161e7d..14609bc2 100644 --- a/resources/gamelift-fleet.go +++ b/resources/gamelift-fleet.go @@ -3,11 +3,11 @@ package resources import ( "context" - "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/gamelift" "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) @@ -26,34 +26,44 @@ type GameLiftFleetLister struct{} func (l *GameLiftFleetLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := gamelift.New(opts.Session) - resp, err := svc.ListFleets(&gamelift.ListFleetsInput{}) - if err != nil { - return nil, err - } + params := &gamelift.ListFleetsInput{} - fleets := make([]resource.Resource, 0) - for _, fleetId := range resp.FleetIds { - fleet := &GameLiftFleet{ - svc: svc, - FleetId: *fleetId, // Dereference the fleetId pointer + for { + resp, err := svc.ListFleets(params) + if err != nil { + return nil, err } - fleets = append(fleets, fleet) + + for _, fleetId := range resp.FleetIds { + fleet := &GameLiftFleet{ + svc: svc, + FleetID: fleetId, + } + resources = append(resources, fleet) + } + + if resp.NextToken == nil { + break + } + + params.NextToken = resp.NextToken } - return fleets, nil + return resources, nil } type GameLiftFleet struct { svc *gamelift.GameLift - FleetId string + FleetID *string } func (r *GameLiftFleet) Remove(_ context.Context) error { params := &gamelift.DeleteFleetInput{ - FleetId: aws.String(r.FleetId), + FleetId: r.FleetID, } _, err := r.svc.DeleteFleet(params) @@ -65,5 +75,9 @@ func (r *GameLiftFleet) Remove(_ context.Context) error { } func (r *GameLiftFleet) String() string { - return r.FleetId + return *r.FleetID +} + +func (r *GameLiftFleet) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) } From 69336ced5f81327fcd17fdb13c119837046a2048 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 16:09:20 -0600 Subject: [PATCH 19/23] feat(gamelift-queue): add properties and pagination --- resources/gamelift-queue.go | 37 ++++++++++++++++++++++++++----------- 1 file changed, 26 insertions(+), 11 deletions(-) diff --git a/resources/gamelift-queue.go b/resources/gamelift-queue.go index 4e2a81c1..810cbb12 100644 --- a/resources/gamelift-queue.go +++ b/resources/gamelift-queue.go @@ -7,6 +7,7 @@ import ( "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) @@ -25,24 +26,34 @@ type GameLiftQueueLister struct{} func (l *GameLiftQueueLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := gamelift.New(opts.Session) - resp, err := svc.DescribeGameSessionQueues(&gamelift.DescribeGameSessionQueuesInput{}) - if err != nil { - return nil, err - } + params := &gamelift.DescribeGameSessionQueuesInput{} - queues := make([]resource.Resource, 0) - for _, queue := range resp.GameSessionQueues { - q := &GameLiftQueue{ - svc: svc, - Name: queue.Name, + for { + resp, err := svc.DescribeGameSessionQueues(params) + if err != nil { + return nil, err } - queues = append(queues, q) + + for _, queue := range resp.GameSessionQueues { + q := &GameLiftQueue{ + svc: svc, + Name: queue.Name, + } + resources = append(resources, q) + } + + if resp.NextToken == nil { + break + } + + params.NextToken = resp.NextToken } - return queues, nil + return resources, nil } type GameLiftQueue struct { @@ -63,6 +74,10 @@ func (r *GameLiftQueue) Remove(_ context.Context) error { return nil } +func (r *GameLiftQueue) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) +} + func (r *GameLiftQueue) String() string { return *r.Name } From 93e772075e98c7121a0d193fb2a2cac8eee7a5f7 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 16:11:10 -0600 Subject: [PATCH 20/23] feat(gamelift-mm-rule): add properties and pagination --- resources/gamelift-mm-rule.go | 37 ++++++++++++++++++++++++----------- 1 file changed, 26 insertions(+), 11 deletions(-) diff --git a/resources/gamelift-mm-rule.go b/resources/gamelift-mm-rule.go index 42946cf8..63abdb2d 100644 --- a/resources/gamelift-mm-rule.go +++ b/resources/gamelift-mm-rule.go @@ -7,6 +7,7 @@ import ( "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) @@ -25,24 +26,34 @@ type GameLiftMatchmakingRuleSetLister struct{} func (l *GameLiftMatchmakingRuleSetLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := gamelift.New(opts.Session) - resp, err := svc.DescribeMatchmakingRuleSets(&gamelift.DescribeMatchmakingRuleSetsInput{}) - if err != nil { - return nil, err - } + params := &gamelift.DescribeMatchmakingRuleSetsInput{} - rules := make([]resource.Resource, 0) - for _, ruleSet := range resp.RuleSets { - q := &GameLiftMatchmakingRuleSet{ - svc: svc, - Name: ruleSet.RuleSetName, + for { + resp, err := svc.DescribeMatchmakingRuleSets(params) + if err != nil { + return nil, err } - rules = append(rules, q) + + for _, ruleSet := range resp.RuleSets { + q := &GameLiftMatchmakingRuleSet{ + svc: svc, + Name: ruleSet.RuleSetName, + } + resources = append(resources, q) + } + + if resp.NextToken == nil { + break + } + + params.NextToken = resp.NextToken } - return rules, nil + return resources, nil } type GameLiftMatchmakingRuleSet struct { @@ -63,6 +74,10 @@ func (r *GameLiftMatchmakingRuleSet) Remove(_ context.Context) error { return nil } +func (r *GameLiftMatchmakingRuleSet) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) +} + func (r *GameLiftMatchmakingRuleSet) String() string { return *r.Name } From 14db660ce4df8765d3e34d8d18af7ec8517d00a5 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Thu, 26 Sep 2024 16:12:34 -0600 Subject: [PATCH 21/23] feat(gamelift-mm-config): add properties and pagination --- resources/gamelift-mm-config.go | 44 +++++++++++++++++++++++---------- 1 file changed, 31 insertions(+), 13 deletions(-) diff --git a/resources/gamelift-mm-config.go b/resources/gamelift-mm-config.go index 8d792dbb..ff41001b 100644 --- a/resources/gamelift-mm-config.go +++ b/resources/gamelift-mm-config.go @@ -2,11 +2,13 @@ package resources import ( "context" + "time" "github.com/aws/aws-sdk-go/service/gamelift" "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" "github.com/ekristen/aws-nuke/v3/pkg/nuke" ) @@ -25,29 +27,41 @@ type GameLiftMatchmakingConfigurationLister struct{} func (l *GameLiftMatchmakingConfigurationLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := gamelift.New(opts.Session) - resp, err := svc.DescribeMatchmakingConfigurations(&gamelift.DescribeMatchmakingConfigurationsInput{}) - if err != nil { - return nil, err - } + params := &gamelift.DescribeMatchmakingConfigurationsInput{} - configs := make([]resource.Resource, 0) - for _, config := range resp.Configurations { - q := &GameLiftMatchmakingConfiguration{ - svc: svc, - Name: config.Name, + for { + resp, err := svc.DescribeMatchmakingConfigurations(params) + if err != nil { + return nil, err } - configs = append(configs, q) + + for _, config := range resp.Configurations { + q := &GameLiftMatchmakingConfiguration{ + svc: svc, + Name: config.Name, + CreationTime: config.CreationTime, + } + resources = append(resources, q) + } + + if resp.NextToken == nil { + break + } + + params.NextToken = resp.NextToken } - return configs, nil + return resources, nil } type GameLiftMatchmakingConfiguration struct { - svc *gamelift.GameLift - Name *string + svc *gamelift.GameLift + Name *string + CreationTime *time.Time } func (r *GameLiftMatchmakingConfiguration) Remove(_ context.Context) error { @@ -63,6 +77,10 @@ func (r *GameLiftMatchmakingConfiguration) Remove(_ context.Context) error { return nil } +func (r *GameLiftMatchmakingConfiguration) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) +} + func (r *GameLiftMatchmakingConfiguration) String() string { return *r.Name } From 0ab4b39dd36ad1694e6375b6084f531edb472f4e Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Fri, 27 Sep 2024 11:03:09 -0600 Subject: [PATCH 22/23] chore(gamelift-fleet): fix lint error --- resources/gamelift-fleet.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/resources/gamelift-fleet.go b/resources/gamelift-fleet.go index 14609bc2..31899fc4 100644 --- a/resources/gamelift-fleet.go +++ b/resources/gamelift-fleet.go @@ -38,10 +38,10 @@ func (l *GameLiftFleetLister) List(_ context.Context, o interface{}) ([]resource return nil, err } - for _, fleetId := range resp.FleetIds { + for _, fleetID := range resp.FleetIds { fleet := &GameLiftFleet{ svc: svc, - FleetID: fleetId, + FleetID: fleetID, } resources = append(resources, fleet) } From ad4d880681084506693502f5a0d04e81efe72493 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Fri, 27 Sep 2024 11:03:23 -0600 Subject: [PATCH 23/23] chore(pinpoint-phone-number): fix lint error --- resources/pinpoint-phone-number.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/resources/pinpoint-phone-number.go b/resources/pinpoint-phone-number.go index e17a83a9..cde9174f 100644 --- a/resources/pinpoint-phone-number.go +++ b/resources/pinpoint-phone-number.go @@ -79,7 +79,7 @@ func (r *PinpointPhoneNumber) Properties() types.Properties { } func (r *PinpointPhoneNumber) Remove(_ context.Context) error { - if r.settings.GetBool("DisableDeletionProtection") { + if r.settings.GetBool("DisableDeletionProtection") && ptr.ToBool(r.deletionProtectionEnabled) { _, err := r.svc.UpdatePhoneNumber(&pinpointsmsvoicev2.UpdatePhoneNumberInput{ PhoneNumberId: r.ID, DeletionProtectionEnabled: ptr.Bool(false), @@ -99,8 +99,8 @@ func (r *PinpointPhoneNumber) Remove(_ context.Context) error { return nil } -func (r *PinpointPhoneNumber) Settings(settings *settings.Setting) { - r.settings = settings +func (r *PinpointPhoneNumber) Settings(setting *settings.Setting) { + r.settings = setting } func (r *PinpointPhoneNumber) String() string {