// RawAPICaller mocks base method
502134
func (m *MockFacadeCaller) RawAPICaller() base.APICaller {
	ret := m.ctrl.Call(m, "RawAPICaller")
	ret0, _ := ret[0].(base.APICaller)
	return ret0
}
104149
func NewMockLambdaAPI(ctrl *gomock.Controller) *MockLambdaAPI {
	mock := &MockLambdaAPI{ctrl: ctrl}
	mock.recorder = &MockLambdaAPIMockRecorder{mock}
	return mock
}
997213
func (m *MockBytes) Finalizer() resource.Finalizer {
	ret := m.ctrl.Call(m, "Finalizer")
	ret0, _ := ret[0].(resource.Finalizer)
	return ret0
}
745463
func (m Match) RawHandler() HandlerType {
	switch v := m.Handler.(type) {
	case netHTTPHandlerWrap:
		return v.Handler
	case handlerFuncWrap:
		return v.fn
	case netHTTPHandlerFuncWrap:
		return v.fn
	default:
		return v
	}
}
568424
func NewUnitFacadeClient(facadeCaller FacadeCaller, httpClient UnitHTTPClient) *UnitFacadeClient {
	return &UnitFacadeClient{
		FacadeCaller: facadeCaller,
		HTTPClient:   httpClient,
	}
}
930871
func UseApiError(status int) bool {
	switch {
	case status > 199 && status < 300:
		return false
	case status == 304:
		return false
	case status == 0:
		return false
	}
	return true
}
120563
func NewMockPacketDecoder(ctrl *gomock.Controller) *MockPacketDecoder {
	mock := &MockPacketDecoder{ctrl: ctrl}
	mock.recorder = &MockPacketDecoderMockRecorder{mock}
	return mock
}
423399
func NewMockAPICalls(ctrl *gomock.Controller) *MockAPICalls {
	mock := &MockAPICalls{ctrl: ctrl}
	mock.recorder = &MockAPICallsMockRecorder{mock}
	return mock
}
710706
func NewMockNetworkAPIClient(ctrl *gomock.Controller) *MockNetworkAPIClient {
	mock := &MockNetworkAPIClient{ctrl: ctrl}
	mock.recorder = &MockNetworkAPIClientMockRecorder{mock}
	return mock
}
13717
func (_m *ServiceResponse) Raw() *protosdiscovery.Response {
	ret := _m.Called()

	var r0 *protosdiscovery.Response
	if rf, ok := ret.Get(0).(func() *protosdiscovery.Response); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*protosdiscovery.Response)
		}
	}

	return r0
}
421399
func (mr *MockPitayaClientMockRecorder) PushToUser(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushToUser", reflect.TypeOf((*MockPitayaClient)(nil).PushToUser), varargs...)
}
1157642
func NewMockAuthorizer(ctrl *gomock.Controller) *MockAuthorizer {
	mock := &MockAuthorizer{ctrl: ctrl}
	mock.recorder = &MockAuthorizerMockRecorder{mock}
	return mock
}
764289
func NewAPI(spec *loads.Document) *API {
	var an *analysis.Spec
	if spec != nil && spec.Spec() != nil {
		an = analysis.New(spec.Spec())
	}
	api := &API{
		spec:           spec,
		analyzer:       an,
		consumers:      make(map[string]runtime.Consumer, 10),
		producers:      make(map[string]runtime.Producer, 10),
		authenticators: make(map[string]runtime.Authenticator),
		operations:     make(map[string]map[string]runtime.OperationHandler),
		ServeError:     errors.ServeError,
		Models:         make(map[string]func() interface{}),
		formats:        strfmt.NewFormats(),
	}
	return api.WithJSONDefaults()
}
195509
func NewMockApiExtensionsClientInterface(ctrl *gomock.Controller) *MockApiExtensionsClientInterface {
	mock := &MockApiExtensionsClientInterface{ctrl: ctrl}
	mock.recorder = &MockApiExtensionsClientInterfaceMockRecorder{mock}
	return mock
}
1163012
func NewMockAuthorizeRequester(ctrl *gomock.Controller) *MockAuthorizeRequester {
	mock := &MockAuthorizeRequester{ctrl: ctrl}
	mock.recorder = &MockAuthorizeRequesterMockRecorder{mock}
	return mock
}
1331483
func (o *GetOptions) raw(f cmdutil.Factory) error {
	restClient, err := f.RESTClient()
	if err != nil {
		return err
	}

	stream, err := restClient.Get().RequestURI(o.Raw).Stream()
	if err != nil {
		return err
	}
	defer stream.Close()

	_, err = io.Copy(o.Out, stream)
	if err != nil && err != io.EOF {
		return err
	}
	return nil
}
105156
func (api *API) Raw(method, endpoint string, data interface{}) (json.RawMessage, error) {
	res, err := api.makeRequest(method, endpoint, data)
	if err != nil {
		return nil, errors.Wrap(err, errMakeRequestError)
	}

	var r RawResponse
	if err := json.Unmarshal(res, &r); err != nil {
		return nil, errors.Wrap(err, errUnmarshalError)
	}
	return r.Result, nil
}