github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/caas/kubernetes/provider/mocks/k8sclient_mock.go (about)

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: k8s.io/client-go/kubernetes (interfaces: Interface)
     3  
     4  // Package mocks is a generated GoMock package.
     5  package mocks
     6  
     7  import (
     8  	reflect "reflect"
     9  
    10  	gomock "github.com/golang/mock/gomock"
    11  	discovery "k8s.io/client-go/discovery"
    12  	v1alpha1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1"
    13  	v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1"
    14  	v1 "k8s.io/client-go/kubernetes/typed/apps/v1"
    15  	v1beta10 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
    16  	v1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
    17  	v10 "k8s.io/client-go/kubernetes/typed/authentication/v1"
    18  	v1beta11 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
    19  	v11 "k8s.io/client-go/kubernetes/typed/authorization/v1"
    20  	v1beta12 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
    21  	v12 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
    22  	v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1"
    23  	v13 "k8s.io/client-go/kubernetes/typed/batch/v1"
    24  	v1beta13 "k8s.io/client-go/kubernetes/typed/batch/v1beta1"
    25  	v2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1"
    26  	v1beta14 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
    27  	v1beta15 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1"
    28  	v14 "k8s.io/client-go/kubernetes/typed/core/v1"
    29  	v1beta16 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
    30  	v1beta17 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
    31  	v15 "k8s.io/client-go/kubernetes/typed/networking/v1"
    32  	v1beta18 "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
    33  	v16 "k8s.io/client-go/kubernetes/typed/rbac/v1"
    34  	v1alpha10 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
    35  	v1beta19 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
    36  	v1alpha11 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1"
    37  	v1beta110 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
    38  	v1alpha12 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1"
    39  	v17 "k8s.io/client-go/kubernetes/typed/storage/v1"
    40  	v1alpha13 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1"
    41  	v1beta111 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
    42  )
    43  
    44  // MockInterface is a mock of Interface interface
    45  type MockInterface struct {
    46  	ctrl     *gomock.Controller
    47  	recorder *MockInterfaceMockRecorder
    48  }
    49  
    50  // MockInterfaceMockRecorder is the mock recorder for MockInterface
    51  type MockInterfaceMockRecorder struct {
    52  	mock *MockInterface
    53  }
    54  
    55  // NewMockInterface creates a new mock instance
    56  func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
    57  	mock := &MockInterface{ctrl: ctrl}
    58  	mock.recorder = &MockInterfaceMockRecorder{mock}
    59  	return mock
    60  }
    61  
    62  // EXPECT returns an object that allows the caller to indicate expected use
    63  func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
    64  	return m.recorder
    65  }
    66  
    67  // Admissionregistration mocks base method
    68  func (m *MockInterface) Admissionregistration() v1beta1.AdmissionregistrationV1beta1Interface {
    69  	ret := m.ctrl.Call(m, "Admissionregistration")
    70  	ret0, _ := ret[0].(v1beta1.AdmissionregistrationV1beta1Interface)
    71  	return ret0
    72  }
    73  
    74  // Admissionregistration indicates an expected call of Admissionregistration
    75  func (mr *MockInterfaceMockRecorder) Admissionregistration() *gomock.Call {
    76  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Admissionregistration", reflect.TypeOf((*MockInterface)(nil).Admissionregistration))
    77  }
    78  
    79  // AdmissionregistrationV1alpha1 mocks base method
    80  func (m *MockInterface) AdmissionregistrationV1alpha1() v1alpha1.AdmissionregistrationV1alpha1Interface {
    81  	ret := m.ctrl.Call(m, "AdmissionregistrationV1alpha1")
    82  	ret0, _ := ret[0].(v1alpha1.AdmissionregistrationV1alpha1Interface)
    83  	return ret0
    84  }
    85  
    86  // AdmissionregistrationV1alpha1 indicates an expected call of AdmissionregistrationV1alpha1
    87  func (mr *MockInterfaceMockRecorder) AdmissionregistrationV1alpha1() *gomock.Call {
    88  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdmissionregistrationV1alpha1", reflect.TypeOf((*MockInterface)(nil).AdmissionregistrationV1alpha1))
    89  }
    90  
    91  // AdmissionregistrationV1beta1 mocks base method
    92  func (m *MockInterface) AdmissionregistrationV1beta1() v1beta1.AdmissionregistrationV1beta1Interface {
    93  	ret := m.ctrl.Call(m, "AdmissionregistrationV1beta1")
    94  	ret0, _ := ret[0].(v1beta1.AdmissionregistrationV1beta1Interface)
    95  	return ret0
    96  }
    97  
    98  // AdmissionregistrationV1beta1 indicates an expected call of AdmissionregistrationV1beta1
    99  func (mr *MockInterfaceMockRecorder) AdmissionregistrationV1beta1() *gomock.Call {
   100  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdmissionregistrationV1beta1", reflect.TypeOf((*MockInterface)(nil).AdmissionregistrationV1beta1))
   101  }
   102  
   103  // Apps mocks base method
   104  func (m *MockInterface) Apps() v1.AppsV1Interface {
   105  	ret := m.ctrl.Call(m, "Apps")
   106  	ret0, _ := ret[0].(v1.AppsV1Interface)
   107  	return ret0
   108  }
   109  
   110  // Apps indicates an expected call of Apps
   111  func (mr *MockInterfaceMockRecorder) Apps() *gomock.Call {
   112  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Apps", reflect.TypeOf((*MockInterface)(nil).Apps))
   113  }
   114  
   115  // AppsV1 mocks base method
   116  func (m *MockInterface) AppsV1() v1.AppsV1Interface {
   117  	ret := m.ctrl.Call(m, "AppsV1")
   118  	ret0, _ := ret[0].(v1.AppsV1Interface)
   119  	return ret0
   120  }
   121  
   122  // AppsV1 indicates an expected call of AppsV1
   123  func (mr *MockInterfaceMockRecorder) AppsV1() *gomock.Call {
   124  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsV1", reflect.TypeOf((*MockInterface)(nil).AppsV1))
   125  }
   126  
   127  // AppsV1beta1 mocks base method
   128  func (m *MockInterface) AppsV1beta1() v1beta10.AppsV1beta1Interface {
   129  	ret := m.ctrl.Call(m, "AppsV1beta1")
   130  	ret0, _ := ret[0].(v1beta10.AppsV1beta1Interface)
   131  	return ret0
   132  }
   133  
   134  // AppsV1beta1 indicates an expected call of AppsV1beta1
   135  func (mr *MockInterfaceMockRecorder) AppsV1beta1() *gomock.Call {
   136  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsV1beta1", reflect.TypeOf((*MockInterface)(nil).AppsV1beta1))
   137  }
   138  
   139  // AppsV1beta2 mocks base method
   140  func (m *MockInterface) AppsV1beta2() v1beta2.AppsV1beta2Interface {
   141  	ret := m.ctrl.Call(m, "AppsV1beta2")
   142  	ret0, _ := ret[0].(v1beta2.AppsV1beta2Interface)
   143  	return ret0
   144  }
   145  
   146  // AppsV1beta2 indicates an expected call of AppsV1beta2
   147  func (mr *MockInterfaceMockRecorder) AppsV1beta2() *gomock.Call {
   148  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsV1beta2", reflect.TypeOf((*MockInterface)(nil).AppsV1beta2))
   149  }
   150  
   151  // Authentication mocks base method
   152  func (m *MockInterface) Authentication() v10.AuthenticationV1Interface {
   153  	ret := m.ctrl.Call(m, "Authentication")
   154  	ret0, _ := ret[0].(v10.AuthenticationV1Interface)
   155  	return ret0
   156  }
   157  
   158  // Authentication indicates an expected call of Authentication
   159  func (mr *MockInterfaceMockRecorder) Authentication() *gomock.Call {
   160  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Authentication", reflect.TypeOf((*MockInterface)(nil).Authentication))
   161  }
   162  
   163  // AuthenticationV1 mocks base method
   164  func (m *MockInterface) AuthenticationV1() v10.AuthenticationV1Interface {
   165  	ret := m.ctrl.Call(m, "AuthenticationV1")
   166  	ret0, _ := ret[0].(v10.AuthenticationV1Interface)
   167  	return ret0
   168  }
   169  
   170  // AuthenticationV1 indicates an expected call of AuthenticationV1
   171  func (mr *MockInterfaceMockRecorder) AuthenticationV1() *gomock.Call {
   172  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthenticationV1", reflect.TypeOf((*MockInterface)(nil).AuthenticationV1))
   173  }
   174  
   175  // AuthenticationV1beta1 mocks base method
   176  func (m *MockInterface) AuthenticationV1beta1() v1beta11.AuthenticationV1beta1Interface {
   177  	ret := m.ctrl.Call(m, "AuthenticationV1beta1")
   178  	ret0, _ := ret[0].(v1beta11.AuthenticationV1beta1Interface)
   179  	return ret0
   180  }
   181  
   182  // AuthenticationV1beta1 indicates an expected call of AuthenticationV1beta1
   183  func (mr *MockInterfaceMockRecorder) AuthenticationV1beta1() *gomock.Call {
   184  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthenticationV1beta1", reflect.TypeOf((*MockInterface)(nil).AuthenticationV1beta1))
   185  }
   186  
   187  // Authorization mocks base method
   188  func (m *MockInterface) Authorization() v11.AuthorizationV1Interface {
   189  	ret := m.ctrl.Call(m, "Authorization")
   190  	ret0, _ := ret[0].(v11.AuthorizationV1Interface)
   191  	return ret0
   192  }
   193  
   194  // Authorization indicates an expected call of Authorization
   195  func (mr *MockInterfaceMockRecorder) Authorization() *gomock.Call {
   196  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Authorization", reflect.TypeOf((*MockInterface)(nil).Authorization))
   197  }
   198  
   199  // AuthorizationV1 mocks base method
   200  func (m *MockInterface) AuthorizationV1() v11.AuthorizationV1Interface {
   201  	ret := m.ctrl.Call(m, "AuthorizationV1")
   202  	ret0, _ := ret[0].(v11.AuthorizationV1Interface)
   203  	return ret0
   204  }
   205  
   206  // AuthorizationV1 indicates an expected call of AuthorizationV1
   207  func (mr *MockInterfaceMockRecorder) AuthorizationV1() *gomock.Call {
   208  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizationV1", reflect.TypeOf((*MockInterface)(nil).AuthorizationV1))
   209  }
   210  
   211  // AuthorizationV1beta1 mocks base method
   212  func (m *MockInterface) AuthorizationV1beta1() v1beta12.AuthorizationV1beta1Interface {
   213  	ret := m.ctrl.Call(m, "AuthorizationV1beta1")
   214  	ret0, _ := ret[0].(v1beta12.AuthorizationV1beta1Interface)
   215  	return ret0
   216  }
   217  
   218  // AuthorizationV1beta1 indicates an expected call of AuthorizationV1beta1
   219  func (mr *MockInterfaceMockRecorder) AuthorizationV1beta1() *gomock.Call {
   220  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizationV1beta1", reflect.TypeOf((*MockInterface)(nil).AuthorizationV1beta1))
   221  }
   222  
   223  // Autoscaling mocks base method
   224  func (m *MockInterface) Autoscaling() v12.AutoscalingV1Interface {
   225  	ret := m.ctrl.Call(m, "Autoscaling")
   226  	ret0, _ := ret[0].(v12.AutoscalingV1Interface)
   227  	return ret0
   228  }
   229  
   230  // Autoscaling indicates an expected call of Autoscaling
   231  func (mr *MockInterfaceMockRecorder) Autoscaling() *gomock.Call {
   232  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Autoscaling", reflect.TypeOf((*MockInterface)(nil).Autoscaling))
   233  }
   234  
   235  // AutoscalingV1 mocks base method
   236  func (m *MockInterface) AutoscalingV1() v12.AutoscalingV1Interface {
   237  	ret := m.ctrl.Call(m, "AutoscalingV1")
   238  	ret0, _ := ret[0].(v12.AutoscalingV1Interface)
   239  	return ret0
   240  }
   241  
   242  // AutoscalingV1 indicates an expected call of AutoscalingV1
   243  func (mr *MockInterfaceMockRecorder) AutoscalingV1() *gomock.Call {
   244  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalingV1", reflect.TypeOf((*MockInterface)(nil).AutoscalingV1))
   245  }
   246  
   247  // AutoscalingV2beta1 mocks base method
   248  func (m *MockInterface) AutoscalingV2beta1() v2beta1.AutoscalingV2beta1Interface {
   249  	ret := m.ctrl.Call(m, "AutoscalingV2beta1")
   250  	ret0, _ := ret[0].(v2beta1.AutoscalingV2beta1Interface)
   251  	return ret0
   252  }
   253  
   254  // AutoscalingV2beta1 indicates an expected call of AutoscalingV2beta1
   255  func (mr *MockInterfaceMockRecorder) AutoscalingV2beta1() *gomock.Call {
   256  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalingV2beta1", reflect.TypeOf((*MockInterface)(nil).AutoscalingV2beta1))
   257  }
   258  
   259  // Batch mocks base method
   260  func (m *MockInterface) Batch() v13.BatchV1Interface {
   261  	ret := m.ctrl.Call(m, "Batch")
   262  	ret0, _ := ret[0].(v13.BatchV1Interface)
   263  	return ret0
   264  }
   265  
   266  // Batch indicates an expected call of Batch
   267  func (mr *MockInterfaceMockRecorder) Batch() *gomock.Call {
   268  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Batch", reflect.TypeOf((*MockInterface)(nil).Batch))
   269  }
   270  
   271  // BatchV1 mocks base method
   272  func (m *MockInterface) BatchV1() v13.BatchV1Interface {
   273  	ret := m.ctrl.Call(m, "BatchV1")
   274  	ret0, _ := ret[0].(v13.BatchV1Interface)
   275  	return ret0
   276  }
   277  
   278  // BatchV1 indicates an expected call of BatchV1
   279  func (mr *MockInterfaceMockRecorder) BatchV1() *gomock.Call {
   280  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchV1", reflect.TypeOf((*MockInterface)(nil).BatchV1))
   281  }
   282  
   283  // BatchV1beta1 mocks base method
   284  func (m *MockInterface) BatchV1beta1() v1beta13.BatchV1beta1Interface {
   285  	ret := m.ctrl.Call(m, "BatchV1beta1")
   286  	ret0, _ := ret[0].(v1beta13.BatchV1beta1Interface)
   287  	return ret0
   288  }
   289  
   290  // BatchV1beta1 indicates an expected call of BatchV1beta1
   291  func (mr *MockInterfaceMockRecorder) BatchV1beta1() *gomock.Call {
   292  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchV1beta1", reflect.TypeOf((*MockInterface)(nil).BatchV1beta1))
   293  }
   294  
   295  // BatchV2alpha1 mocks base method
   296  func (m *MockInterface) BatchV2alpha1() v2alpha1.BatchV2alpha1Interface {
   297  	ret := m.ctrl.Call(m, "BatchV2alpha1")
   298  	ret0, _ := ret[0].(v2alpha1.BatchV2alpha1Interface)
   299  	return ret0
   300  }
   301  
   302  // BatchV2alpha1 indicates an expected call of BatchV2alpha1
   303  func (mr *MockInterfaceMockRecorder) BatchV2alpha1() *gomock.Call {
   304  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchV2alpha1", reflect.TypeOf((*MockInterface)(nil).BatchV2alpha1))
   305  }
   306  
   307  // Certificates mocks base method
   308  func (m *MockInterface) Certificates() v1beta14.CertificatesV1beta1Interface {
   309  	ret := m.ctrl.Call(m, "Certificates")
   310  	ret0, _ := ret[0].(v1beta14.CertificatesV1beta1Interface)
   311  	return ret0
   312  }
   313  
   314  // Certificates indicates an expected call of Certificates
   315  func (mr *MockInterfaceMockRecorder) Certificates() *gomock.Call {
   316  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Certificates", reflect.TypeOf((*MockInterface)(nil).Certificates))
   317  }
   318  
   319  // CertificatesV1beta1 mocks base method
   320  func (m *MockInterface) CertificatesV1beta1() v1beta14.CertificatesV1beta1Interface {
   321  	ret := m.ctrl.Call(m, "CertificatesV1beta1")
   322  	ret0, _ := ret[0].(v1beta14.CertificatesV1beta1Interface)
   323  	return ret0
   324  }
   325  
   326  // CertificatesV1beta1 indicates an expected call of CertificatesV1beta1
   327  func (mr *MockInterfaceMockRecorder) CertificatesV1beta1() *gomock.Call {
   328  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CertificatesV1beta1", reflect.TypeOf((*MockInterface)(nil).CertificatesV1beta1))
   329  }
   330  
   331  // Coordination mocks base method
   332  func (m *MockInterface) Coordination() v1beta15.CoordinationV1beta1Interface {
   333  	ret := m.ctrl.Call(m, "Coordination")
   334  	ret0, _ := ret[0].(v1beta15.CoordinationV1beta1Interface)
   335  	return ret0
   336  }
   337  
   338  // Coordination indicates an expected call of Coordination
   339  func (mr *MockInterfaceMockRecorder) Coordination() *gomock.Call {
   340  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Coordination", reflect.TypeOf((*MockInterface)(nil).Coordination))
   341  }
   342  
   343  // CoordinationV1beta1 mocks base method
   344  func (m *MockInterface) CoordinationV1beta1() v1beta15.CoordinationV1beta1Interface {
   345  	ret := m.ctrl.Call(m, "CoordinationV1beta1")
   346  	ret0, _ := ret[0].(v1beta15.CoordinationV1beta1Interface)
   347  	return ret0
   348  }
   349  
   350  // CoordinationV1beta1 indicates an expected call of CoordinationV1beta1
   351  func (mr *MockInterfaceMockRecorder) CoordinationV1beta1() *gomock.Call {
   352  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CoordinationV1beta1", reflect.TypeOf((*MockInterface)(nil).CoordinationV1beta1))
   353  }
   354  
   355  // Core mocks base method
   356  func (m *MockInterface) Core() v14.CoreV1Interface {
   357  	ret := m.ctrl.Call(m, "Core")
   358  	ret0, _ := ret[0].(v14.CoreV1Interface)
   359  	return ret0
   360  }
   361  
   362  // Core indicates an expected call of Core
   363  func (mr *MockInterfaceMockRecorder) Core() *gomock.Call {
   364  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Core", reflect.TypeOf((*MockInterface)(nil).Core))
   365  }
   366  
   367  // CoreV1 mocks base method
   368  func (m *MockInterface) CoreV1() v14.CoreV1Interface {
   369  	ret := m.ctrl.Call(m, "CoreV1")
   370  	ret0, _ := ret[0].(v14.CoreV1Interface)
   371  	return ret0
   372  }
   373  
   374  // CoreV1 indicates an expected call of CoreV1
   375  func (mr *MockInterfaceMockRecorder) CoreV1() *gomock.Call {
   376  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CoreV1", reflect.TypeOf((*MockInterface)(nil).CoreV1))
   377  }
   378  
   379  // Discovery mocks base method
   380  func (m *MockInterface) Discovery() discovery.DiscoveryInterface {
   381  	ret := m.ctrl.Call(m, "Discovery")
   382  	ret0, _ := ret[0].(discovery.DiscoveryInterface)
   383  	return ret0
   384  }
   385  
   386  // Discovery indicates an expected call of Discovery
   387  func (mr *MockInterfaceMockRecorder) Discovery() *gomock.Call {
   388  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discovery", reflect.TypeOf((*MockInterface)(nil).Discovery))
   389  }
   390  
   391  // Events mocks base method
   392  func (m *MockInterface) Events() v1beta16.EventsV1beta1Interface {
   393  	ret := m.ctrl.Call(m, "Events")
   394  	ret0, _ := ret[0].(v1beta16.EventsV1beta1Interface)
   395  	return ret0
   396  }
   397  
   398  // Events indicates an expected call of Events
   399  func (mr *MockInterfaceMockRecorder) Events() *gomock.Call {
   400  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Events", reflect.TypeOf((*MockInterface)(nil).Events))
   401  }
   402  
   403  // EventsV1beta1 mocks base method
   404  func (m *MockInterface) EventsV1beta1() v1beta16.EventsV1beta1Interface {
   405  	ret := m.ctrl.Call(m, "EventsV1beta1")
   406  	ret0, _ := ret[0].(v1beta16.EventsV1beta1Interface)
   407  	return ret0
   408  }
   409  
   410  // EventsV1beta1 indicates an expected call of EventsV1beta1
   411  func (mr *MockInterfaceMockRecorder) EventsV1beta1() *gomock.Call {
   412  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsV1beta1", reflect.TypeOf((*MockInterface)(nil).EventsV1beta1))
   413  }
   414  
   415  // Extensions mocks base method
   416  func (m *MockInterface) Extensions() v1beta17.ExtensionsV1beta1Interface {
   417  	ret := m.ctrl.Call(m, "Extensions")
   418  	ret0, _ := ret[0].(v1beta17.ExtensionsV1beta1Interface)
   419  	return ret0
   420  }
   421  
   422  // Extensions indicates an expected call of Extensions
   423  func (mr *MockInterfaceMockRecorder) Extensions() *gomock.Call {
   424  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Extensions", reflect.TypeOf((*MockInterface)(nil).Extensions))
   425  }
   426  
   427  // ExtensionsV1beta1 mocks base method
   428  func (m *MockInterface) ExtensionsV1beta1() v1beta17.ExtensionsV1beta1Interface {
   429  	ret := m.ctrl.Call(m, "ExtensionsV1beta1")
   430  	ret0, _ := ret[0].(v1beta17.ExtensionsV1beta1Interface)
   431  	return ret0
   432  }
   433  
   434  // ExtensionsV1beta1 indicates an expected call of ExtensionsV1beta1
   435  func (mr *MockInterfaceMockRecorder) ExtensionsV1beta1() *gomock.Call {
   436  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtensionsV1beta1", reflect.TypeOf((*MockInterface)(nil).ExtensionsV1beta1))
   437  }
   438  
   439  // Networking mocks base method
   440  func (m *MockInterface) Networking() v15.NetworkingV1Interface {
   441  	ret := m.ctrl.Call(m, "Networking")
   442  	ret0, _ := ret[0].(v15.NetworkingV1Interface)
   443  	return ret0
   444  }
   445  
   446  // Networking indicates an expected call of Networking
   447  func (mr *MockInterfaceMockRecorder) Networking() *gomock.Call {
   448  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Networking", reflect.TypeOf((*MockInterface)(nil).Networking))
   449  }
   450  
   451  // NetworkingV1 mocks base method
   452  func (m *MockInterface) NetworkingV1() v15.NetworkingV1Interface {
   453  	ret := m.ctrl.Call(m, "NetworkingV1")
   454  	ret0, _ := ret[0].(v15.NetworkingV1Interface)
   455  	return ret0
   456  }
   457  
   458  // NetworkingV1 indicates an expected call of NetworkingV1
   459  func (mr *MockInterfaceMockRecorder) NetworkingV1() *gomock.Call {
   460  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkingV1", reflect.TypeOf((*MockInterface)(nil).NetworkingV1))
   461  }
   462  
   463  // Policy mocks base method
   464  func (m *MockInterface) Policy() v1beta18.PolicyV1beta1Interface {
   465  	ret := m.ctrl.Call(m, "Policy")
   466  	ret0, _ := ret[0].(v1beta18.PolicyV1beta1Interface)
   467  	return ret0
   468  }
   469  
   470  // Policy indicates an expected call of Policy
   471  func (mr *MockInterfaceMockRecorder) Policy() *gomock.Call {
   472  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Policy", reflect.TypeOf((*MockInterface)(nil).Policy))
   473  }
   474  
   475  // PolicyV1beta1 mocks base method
   476  func (m *MockInterface) PolicyV1beta1() v1beta18.PolicyV1beta1Interface {
   477  	ret := m.ctrl.Call(m, "PolicyV1beta1")
   478  	ret0, _ := ret[0].(v1beta18.PolicyV1beta1Interface)
   479  	return ret0
   480  }
   481  
   482  // PolicyV1beta1 indicates an expected call of PolicyV1beta1
   483  func (mr *MockInterfaceMockRecorder) PolicyV1beta1() *gomock.Call {
   484  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PolicyV1beta1", reflect.TypeOf((*MockInterface)(nil).PolicyV1beta1))
   485  }
   486  
   487  // Rbac mocks base method
   488  func (m *MockInterface) Rbac() v16.RbacV1Interface {
   489  	ret := m.ctrl.Call(m, "Rbac")
   490  	ret0, _ := ret[0].(v16.RbacV1Interface)
   491  	return ret0
   492  }
   493  
   494  // Rbac indicates an expected call of Rbac
   495  func (mr *MockInterfaceMockRecorder) Rbac() *gomock.Call {
   496  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rbac", reflect.TypeOf((*MockInterface)(nil).Rbac))
   497  }
   498  
   499  // RbacV1 mocks base method
   500  func (m *MockInterface) RbacV1() v16.RbacV1Interface {
   501  	ret := m.ctrl.Call(m, "RbacV1")
   502  	ret0, _ := ret[0].(v16.RbacV1Interface)
   503  	return ret0
   504  }
   505  
   506  // RbacV1 indicates an expected call of RbacV1
   507  func (mr *MockInterfaceMockRecorder) RbacV1() *gomock.Call {
   508  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RbacV1", reflect.TypeOf((*MockInterface)(nil).RbacV1))
   509  }
   510  
   511  // RbacV1alpha1 mocks base method
   512  func (m *MockInterface) RbacV1alpha1() v1alpha10.RbacV1alpha1Interface {
   513  	ret := m.ctrl.Call(m, "RbacV1alpha1")
   514  	ret0, _ := ret[0].(v1alpha10.RbacV1alpha1Interface)
   515  	return ret0
   516  }
   517  
   518  // RbacV1alpha1 indicates an expected call of RbacV1alpha1
   519  func (mr *MockInterfaceMockRecorder) RbacV1alpha1() *gomock.Call {
   520  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RbacV1alpha1", reflect.TypeOf((*MockInterface)(nil).RbacV1alpha1))
   521  }
   522  
   523  // RbacV1beta1 mocks base method
   524  func (m *MockInterface) RbacV1beta1() v1beta19.RbacV1beta1Interface {
   525  	ret := m.ctrl.Call(m, "RbacV1beta1")
   526  	ret0, _ := ret[0].(v1beta19.RbacV1beta1Interface)
   527  	return ret0
   528  }
   529  
   530  // RbacV1beta1 indicates an expected call of RbacV1beta1
   531  func (mr *MockInterfaceMockRecorder) RbacV1beta1() *gomock.Call {
   532  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RbacV1beta1", reflect.TypeOf((*MockInterface)(nil).RbacV1beta1))
   533  }
   534  
   535  // Scheduling mocks base method
   536  func (m *MockInterface) Scheduling() v1beta110.SchedulingV1beta1Interface {
   537  	ret := m.ctrl.Call(m, "Scheduling")
   538  	ret0, _ := ret[0].(v1beta110.SchedulingV1beta1Interface)
   539  	return ret0
   540  }
   541  
   542  // Scheduling indicates an expected call of Scheduling
   543  func (mr *MockInterfaceMockRecorder) Scheduling() *gomock.Call {
   544  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scheduling", reflect.TypeOf((*MockInterface)(nil).Scheduling))
   545  }
   546  
   547  // SchedulingV1alpha1 mocks base method
   548  func (m *MockInterface) SchedulingV1alpha1() v1alpha11.SchedulingV1alpha1Interface {
   549  	ret := m.ctrl.Call(m, "SchedulingV1alpha1")
   550  	ret0, _ := ret[0].(v1alpha11.SchedulingV1alpha1Interface)
   551  	return ret0
   552  }
   553  
   554  // SchedulingV1alpha1 indicates an expected call of SchedulingV1alpha1
   555  func (mr *MockInterfaceMockRecorder) SchedulingV1alpha1() *gomock.Call {
   556  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulingV1alpha1", reflect.TypeOf((*MockInterface)(nil).SchedulingV1alpha1))
   557  }
   558  
   559  // SchedulingV1beta1 mocks base method
   560  func (m *MockInterface) SchedulingV1beta1() v1beta110.SchedulingV1beta1Interface {
   561  	ret := m.ctrl.Call(m, "SchedulingV1beta1")
   562  	ret0, _ := ret[0].(v1beta110.SchedulingV1beta1Interface)
   563  	return ret0
   564  }
   565  
   566  // SchedulingV1beta1 indicates an expected call of SchedulingV1beta1
   567  func (mr *MockInterfaceMockRecorder) SchedulingV1beta1() *gomock.Call {
   568  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulingV1beta1", reflect.TypeOf((*MockInterface)(nil).SchedulingV1beta1))
   569  }
   570  
   571  // Settings mocks base method
   572  func (m *MockInterface) Settings() v1alpha12.SettingsV1alpha1Interface {
   573  	ret := m.ctrl.Call(m, "Settings")
   574  	ret0, _ := ret[0].(v1alpha12.SettingsV1alpha1Interface)
   575  	return ret0
   576  }
   577  
   578  // Settings indicates an expected call of Settings
   579  func (mr *MockInterfaceMockRecorder) Settings() *gomock.Call {
   580  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Settings", reflect.TypeOf((*MockInterface)(nil).Settings))
   581  }
   582  
   583  // SettingsV1alpha1 mocks base method
   584  func (m *MockInterface) SettingsV1alpha1() v1alpha12.SettingsV1alpha1Interface {
   585  	ret := m.ctrl.Call(m, "SettingsV1alpha1")
   586  	ret0, _ := ret[0].(v1alpha12.SettingsV1alpha1Interface)
   587  	return ret0
   588  }
   589  
   590  // SettingsV1alpha1 indicates an expected call of SettingsV1alpha1
   591  func (mr *MockInterfaceMockRecorder) SettingsV1alpha1() *gomock.Call {
   592  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsV1alpha1", reflect.TypeOf((*MockInterface)(nil).SettingsV1alpha1))
   593  }
   594  
   595  // Storage mocks base method
   596  func (m *MockInterface) Storage() v17.StorageV1Interface {
   597  	ret := m.ctrl.Call(m, "Storage")
   598  	ret0, _ := ret[0].(v17.StorageV1Interface)
   599  	return ret0
   600  }
   601  
   602  // Storage indicates an expected call of Storage
   603  func (mr *MockInterfaceMockRecorder) Storage() *gomock.Call {
   604  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Storage", reflect.TypeOf((*MockInterface)(nil).Storage))
   605  }
   606  
   607  // StorageV1 mocks base method
   608  func (m *MockInterface) StorageV1() v17.StorageV1Interface {
   609  	ret := m.ctrl.Call(m, "StorageV1")
   610  	ret0, _ := ret[0].(v17.StorageV1Interface)
   611  	return ret0
   612  }
   613  
   614  // StorageV1 indicates an expected call of StorageV1
   615  func (mr *MockInterfaceMockRecorder) StorageV1() *gomock.Call {
   616  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageV1", reflect.TypeOf((*MockInterface)(nil).StorageV1))
   617  }
   618  
   619  // StorageV1alpha1 mocks base method
   620  func (m *MockInterface) StorageV1alpha1() v1alpha13.StorageV1alpha1Interface {
   621  	ret := m.ctrl.Call(m, "StorageV1alpha1")
   622  	ret0, _ := ret[0].(v1alpha13.StorageV1alpha1Interface)
   623  	return ret0
   624  }
   625  
   626  // StorageV1alpha1 indicates an expected call of StorageV1alpha1
   627  func (mr *MockInterfaceMockRecorder) StorageV1alpha1() *gomock.Call {
   628  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageV1alpha1", reflect.TypeOf((*MockInterface)(nil).StorageV1alpha1))
   629  }
   630  
   631  // StorageV1beta1 mocks base method
   632  func (m *MockInterface) StorageV1beta1() v1beta111.StorageV1beta1Interface {
   633  	ret := m.ctrl.Call(m, "StorageV1beta1")
   634  	ret0, _ := ret[0].(v1beta111.StorageV1beta1Interface)
   635  	return ret0
   636  }
   637  
   638  // StorageV1beta1 indicates an expected call of StorageV1beta1
   639  func (mr *MockInterfaceMockRecorder) StorageV1beta1() *gomock.Call {
   640  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageV1beta1", reflect.TypeOf((*MockInterface)(nil).StorageV1beta1))
   641  }