// Code generated by go-swagger; DO NOT EDIT.

// All Code Copyright(c) 2018-2021 by Taxnexus, Inc.
// All rights reserved worldwide.
// Proprietary product; unlicensed use is not allowed

package plants

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)

// New creates a new plants API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for plants API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	DeletePlant(params *DeletePlantParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeletePlantOK, error)

	GetPlantGrowthPhases(params *GetPlantGrowthPhasesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantGrowthPhasesOK, error)

	GetPlantWasteMethods(params *GetPlantWasteMethodsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantWasteMethodsOK, error)

	GetPlantWasteReasons(params *GetPlantWasteReasonsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantWasteReasonsOK, error)

	GetPlants(params *GetPlantsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantsOK, error)

	PostPlants(params *PostPlantsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostPlantsOK, error)

	PutPlants(params *PutPlantsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutPlantsOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  DeletePlant plants for this user license

  Delete a plant for this User-License

*/
func (a *Client) DeletePlant(params *DeletePlantParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeletePlantOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeletePlantParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deletePlant",
		Method:             "DELETE",
		PathPattern:        "/plants",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeletePlantReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeletePlantOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deletePlant: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetPlantGrowthPhases plants growth phases for this user license

  Get available Plant Growth Phases for this User-License
*/
func (a *Client) GetPlantGrowthPhases(params *GetPlantGrowthPhasesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantGrowthPhasesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPlantGrowthPhasesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getPlantGrowthPhases",
		Method:             "GET",
		PathPattern:        "/plants/growthphases",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPlantGrowthPhasesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPlantGrowthPhasesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getPlantGrowthPhases: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetPlantWasteMethods plants waste methods for this user license

  Get available Plant Waste Methods for this User-License
*/
func (a *Client) GetPlantWasteMethods(params *GetPlantWasteMethodsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantWasteMethodsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPlantWasteMethodsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getPlantWasteMethods",
		Method:             "GET",
		PathPattern:        "/plants/wastemethods",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPlantWasteMethodsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPlantWasteMethodsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getPlantWasteMethods: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetPlantWasteReasons plants waste methods for this user license

  Get available Plant Waste Reasons for this User-License
*/
func (a *Client) GetPlantWasteReasons(params *GetPlantWasteReasonsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantWasteReasonsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPlantWasteReasonsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getPlantWasteReasons",
		Method:             "GET",
		PathPattern:        "/plants/wastereasons",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPlantWasteReasonsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPlantWasteReasonsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getPlantWasteReasons: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetPlants plants for this user license

  Get Plants for this User-License

*/
func (a *Client) GetPlants(params *GetPlantsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPlantsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPlantsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getPlants",
		Method:             "GET",
		PathPattern:        "/plants",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPlantsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPlantsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getPlants: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostPlants creates new plants

  Create new Plants
*/
func (a *Client) PostPlants(params *PostPlantsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostPlantsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostPlantsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postPlants",
		Method:             "POST",
		PathPattern:        "/plants",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostPlantsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostPlantsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postPlants: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PutPlants updates existing plants

  Update existing Plants
*/
func (a *Client) PutPlants(params *PutPlantsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutPlantsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutPlantsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "putPlants",
		Method:             "PUT",
		PathPattern:        "/plants",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PutPlantsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutPlantsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for putPlants: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}