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

// Copyright 2018 The go-netbox Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package ipam

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

import (
	"github.com/go-openapi/runtime"

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

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

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

/*
IPAMChoicesList ipam choices list API
*/
func (a *Client) IPAMChoicesList(params *IPAMChoicesListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMChoicesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMChoicesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam__choices_list",
		Method:             "GET",
		PathPattern:        "/ipam/_choices/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMChoicesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMChoicesListOK), nil

}

/*
IPAMChoicesRead ipam choices read API
*/
func (a *Client) IPAMChoicesRead(params *IPAMChoicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMChoicesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMChoicesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam__choices_read",
		Method:             "GET",
		PathPattern:        "/ipam/_choices/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMChoicesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMChoicesReadOK), nil

}

/*
IPAMAggregatesCreate ipam aggregates create API
*/
func (a *Client) IPAMAggregatesCreate(params *IPAMAggregatesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMAggregatesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMAggregatesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_aggregates_create",
		Method:             "POST",
		PathPattern:        "/ipam/aggregates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMAggregatesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMAggregatesCreateCreated), nil

}

/*
IPAMAggregatesDelete ipam aggregates delete API
*/
func (a *Client) IPAMAggregatesDelete(params *IPAMAggregatesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMAggregatesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMAggregatesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_aggregates_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/aggregates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMAggregatesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMAggregatesDeleteNoContent), nil

}

/*
IPAMAggregatesList ipam aggregates list API
*/
func (a *Client) IPAMAggregatesList(params *IPAMAggregatesListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMAggregatesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMAggregatesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_aggregates_list",
		Method:             "GET",
		PathPattern:        "/ipam/aggregates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMAggregatesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMAggregatesListOK), nil

}

/*
IPAMAggregatesPartialUpdate ipam aggregates partial update API
*/
func (a *Client) IPAMAggregatesPartialUpdate(params *IPAMAggregatesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMAggregatesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMAggregatesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_aggregates_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/aggregates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMAggregatesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMAggregatesPartialUpdateOK), nil

}

/*
IPAMAggregatesRead ipam aggregates read API
*/
func (a *Client) IPAMAggregatesRead(params *IPAMAggregatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMAggregatesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMAggregatesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_aggregates_read",
		Method:             "GET",
		PathPattern:        "/ipam/aggregates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMAggregatesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMAggregatesReadOK), nil

}

/*
IPAMAggregatesUpdate ipam aggregates update API
*/
func (a *Client) IPAMAggregatesUpdate(params *IPAMAggregatesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMAggregatesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMAggregatesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_aggregates_update",
		Method:             "PUT",
		PathPattern:        "/ipam/aggregates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMAggregatesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMAggregatesUpdateOK), nil

}

/*
IPAMIPAddressesCreate ipam ip addresses create API
*/
func (a *Client) IPAMIPAddressesCreate(params *IPAMIPAddressesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMIPAddressesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMIPAddressesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_ip-addresses_create",
		Method:             "POST",
		PathPattern:        "/ipam/ip-addresses/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMIPAddressesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMIPAddressesCreateCreated), nil

}

/*
IPAMIPAddressesDelete ipam ip addresses delete API
*/
func (a *Client) IPAMIPAddressesDelete(params *IPAMIPAddressesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMIPAddressesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMIPAddressesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_ip-addresses_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/ip-addresses/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMIPAddressesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMIPAddressesDeleteNoContent), nil

}

/*
IPAMIPAddressesList ipam ip addresses list API
*/
func (a *Client) IPAMIPAddressesList(params *IPAMIPAddressesListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMIPAddressesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMIPAddressesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_ip-addresses_list",
		Method:             "GET",
		PathPattern:        "/ipam/ip-addresses/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMIPAddressesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMIPAddressesListOK), nil

}

/*
IPAMIPAddressesPartialUpdate ipam ip addresses partial update API
*/
func (a *Client) IPAMIPAddressesPartialUpdate(params *IPAMIPAddressesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMIPAddressesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMIPAddressesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_ip-addresses_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/ip-addresses/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMIPAddressesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMIPAddressesPartialUpdateOK), nil

}

/*
IPAMIPAddressesRead ipam ip addresses read API
*/
func (a *Client) IPAMIPAddressesRead(params *IPAMIPAddressesReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMIPAddressesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMIPAddressesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_ip-addresses_read",
		Method:             "GET",
		PathPattern:        "/ipam/ip-addresses/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMIPAddressesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMIPAddressesReadOK), nil

}

/*
IPAMIPAddressesUpdate ipam ip addresses update API
*/
func (a *Client) IPAMIPAddressesUpdate(params *IPAMIPAddressesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMIPAddressesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMIPAddressesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_ip-addresses_update",
		Method:             "PUT",
		PathPattern:        "/ipam/ip-addresses/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMIPAddressesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMIPAddressesUpdateOK), nil

}

/*
IPAMPrefixesAvailableIpsCreate A convenience method for returning available IP addresses within a prefix. By default, the number of IPs
returned will be equivalent to PAGINATE_COUNT. An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed,
however results will not be paginated.
*/
func (a *Client) IPAMPrefixesAvailableIpsCreate(params *IPAMPrefixesAvailableIpsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesAvailableIpsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesAvailableIpsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_available-ips_create",
		Method:             "POST",
		PathPattern:        "/ipam/prefixes/{id}/available-ips/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesAvailableIpsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesAvailableIpsCreateCreated), nil

}

/*
IPAMPrefixesAvailableIpsRead A convenience method for returning available IP addresses within a prefix. By default, the number of IPs
returned will be equivalent to PAGINATE_COUNT. An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed,
however results will not be paginated.
*/
func (a *Client) IPAMPrefixesAvailableIpsRead(params *IPAMPrefixesAvailableIpsReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesAvailableIpsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesAvailableIpsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_available-ips_read",
		Method:             "GET",
		PathPattern:        "/ipam/prefixes/{id}/available-ips/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesAvailableIpsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesAvailableIpsReadOK), nil

}

/*
IPAMPrefixesAvailablePrefixesCreate A convenience method for returning available child prefixes within a parent.
*/
func (a *Client) IPAMPrefixesAvailablePrefixesCreate(params *IPAMPrefixesAvailablePrefixesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesAvailablePrefixesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesAvailablePrefixesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_available-prefixes_create",
		Method:             "POST",
		PathPattern:        "/ipam/prefixes/{id}/available-prefixes/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesAvailablePrefixesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesAvailablePrefixesCreateCreated), nil

}

/*
IPAMPrefixesAvailablePrefixesRead A convenience method for returning available child prefixes within a parent.
*/
func (a *Client) IPAMPrefixesAvailablePrefixesRead(params *IPAMPrefixesAvailablePrefixesReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesAvailablePrefixesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesAvailablePrefixesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_available-prefixes_read",
		Method:             "GET",
		PathPattern:        "/ipam/prefixes/{id}/available-prefixes/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesAvailablePrefixesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesAvailablePrefixesReadOK), nil

}

/*
IPAMPrefixesCreate ipam prefixes create API
*/
func (a *Client) IPAMPrefixesCreate(params *IPAMPrefixesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_create",
		Method:             "POST",
		PathPattern:        "/ipam/prefixes/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesCreateCreated), nil

}

/*
IPAMPrefixesDelete ipam prefixes delete API
*/
func (a *Client) IPAMPrefixesDelete(params *IPAMPrefixesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/prefixes/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesDeleteNoContent), nil

}

/*
IPAMPrefixesList ipam prefixes list API
*/
func (a *Client) IPAMPrefixesList(params *IPAMPrefixesListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_list",
		Method:             "GET",
		PathPattern:        "/ipam/prefixes/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesListOK), nil

}

/*
IPAMPrefixesPartialUpdate ipam prefixes partial update API
*/
func (a *Client) IPAMPrefixesPartialUpdate(params *IPAMPrefixesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/prefixes/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesPartialUpdateOK), nil

}

/*
IPAMPrefixesRead ipam prefixes read API
*/
func (a *Client) IPAMPrefixesRead(params *IPAMPrefixesReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_read",
		Method:             "GET",
		PathPattern:        "/ipam/prefixes/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesReadOK), nil

}

/*
IPAMPrefixesUpdate ipam prefixes update API
*/
func (a *Client) IPAMPrefixesUpdate(params *IPAMPrefixesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMPrefixesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMPrefixesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_prefixes_update",
		Method:             "PUT",
		PathPattern:        "/ipam/prefixes/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMPrefixesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMPrefixesUpdateOK), nil

}

/*
IPAMRirsCreate ipam rirs create API
*/
func (a *Client) IPAMRirsCreate(params *IPAMRirsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRirsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRirsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_rirs_create",
		Method:             "POST",
		PathPattern:        "/ipam/rirs/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRirsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRirsCreateCreated), nil

}

/*
IPAMRirsDelete ipam rirs delete API
*/
func (a *Client) IPAMRirsDelete(params *IPAMRirsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRirsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRirsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_rirs_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/rirs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRirsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRirsDeleteNoContent), nil

}

/*
IPAMRirsList ipam rirs list API
*/
func (a *Client) IPAMRirsList(params *IPAMRirsListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRirsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRirsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_rirs_list",
		Method:             "GET",
		PathPattern:        "/ipam/rirs/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRirsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRirsListOK), nil

}

/*
IPAMRirsPartialUpdate ipam rirs partial update API
*/
func (a *Client) IPAMRirsPartialUpdate(params *IPAMRirsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRirsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRirsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_rirs_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/rirs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRirsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRirsPartialUpdateOK), nil

}

/*
IPAMRirsRead ipam rirs read API
*/
func (a *Client) IPAMRirsRead(params *IPAMRirsReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRirsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRirsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_rirs_read",
		Method:             "GET",
		PathPattern:        "/ipam/rirs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRirsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRirsReadOK), nil

}

/*
IPAMRirsUpdate ipam rirs update API
*/
func (a *Client) IPAMRirsUpdate(params *IPAMRirsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRirsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRirsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_rirs_update",
		Method:             "PUT",
		PathPattern:        "/ipam/rirs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRirsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRirsUpdateOK), nil

}

/*
IPAMRolesCreate ipam roles create API
*/
func (a *Client) IPAMRolesCreate(params *IPAMRolesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRolesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRolesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_roles_create",
		Method:             "POST",
		PathPattern:        "/ipam/roles/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRolesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRolesCreateCreated), nil

}

/*
IPAMRolesDelete ipam roles delete API
*/
func (a *Client) IPAMRolesDelete(params *IPAMRolesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRolesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRolesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_roles_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRolesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRolesDeleteNoContent), nil

}

/*
IPAMRolesList ipam roles list API
*/
func (a *Client) IPAMRolesList(params *IPAMRolesListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRolesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRolesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_roles_list",
		Method:             "GET",
		PathPattern:        "/ipam/roles/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRolesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRolesListOK), nil

}

/*
IPAMRolesPartialUpdate ipam roles partial update API
*/
func (a *Client) IPAMRolesPartialUpdate(params *IPAMRolesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRolesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRolesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_roles_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRolesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRolesPartialUpdateOK), nil

}

/*
IPAMRolesRead ipam roles read API
*/
func (a *Client) IPAMRolesRead(params *IPAMRolesReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRolesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRolesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_roles_read",
		Method:             "GET",
		PathPattern:        "/ipam/roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRolesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRolesReadOK), nil

}

/*
IPAMRolesUpdate ipam roles update API
*/
func (a *Client) IPAMRolesUpdate(params *IPAMRolesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMRolesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMRolesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_roles_update",
		Method:             "PUT",
		PathPattern:        "/ipam/roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMRolesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMRolesUpdateOK), nil

}

/*
IPAMServicesCreate ipam services create API
*/
func (a *Client) IPAMServicesCreate(params *IPAMServicesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMServicesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMServicesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_services_create",
		Method:             "POST",
		PathPattern:        "/ipam/services/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMServicesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMServicesCreateCreated), nil

}

/*
IPAMServicesDelete ipam services delete API
*/
func (a *Client) IPAMServicesDelete(params *IPAMServicesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMServicesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMServicesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_services_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/services/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMServicesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMServicesDeleteNoContent), nil

}

/*
IPAMServicesList ipam services list API
*/
func (a *Client) IPAMServicesList(params *IPAMServicesListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMServicesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMServicesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_services_list",
		Method:             "GET",
		PathPattern:        "/ipam/services/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMServicesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMServicesListOK), nil

}

/*
IPAMServicesPartialUpdate ipam services partial update API
*/
func (a *Client) IPAMServicesPartialUpdate(params *IPAMServicesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMServicesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMServicesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_services_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/services/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMServicesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMServicesPartialUpdateOK), nil

}

/*
IPAMServicesRead ipam services read API
*/
func (a *Client) IPAMServicesRead(params *IPAMServicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMServicesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMServicesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_services_read",
		Method:             "GET",
		PathPattern:        "/ipam/services/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMServicesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMServicesReadOK), nil

}

/*
IPAMServicesUpdate ipam services update API
*/
func (a *Client) IPAMServicesUpdate(params *IPAMServicesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMServicesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMServicesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_services_update",
		Method:             "PUT",
		PathPattern:        "/ipam/services/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMServicesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMServicesUpdateOK), nil

}

/*
IPAMVlanGroupsCreate ipam vlan groups create API
*/
func (a *Client) IPAMVlanGroupsCreate(params *IPAMVlanGroupsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlanGroupsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlanGroupsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlan-groups_create",
		Method:             "POST",
		PathPattern:        "/ipam/vlan-groups/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlanGroupsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlanGroupsCreateCreated), nil

}

/*
IPAMVlanGroupsDelete ipam vlan groups delete API
*/
func (a *Client) IPAMVlanGroupsDelete(params *IPAMVlanGroupsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlanGroupsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlanGroupsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlan-groups_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/vlan-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlanGroupsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlanGroupsDeleteNoContent), nil

}

/*
IPAMVlanGroupsList ipam vlan groups list API
*/
func (a *Client) IPAMVlanGroupsList(params *IPAMVlanGroupsListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlanGroupsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlanGroupsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlan-groups_list",
		Method:             "GET",
		PathPattern:        "/ipam/vlan-groups/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlanGroupsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlanGroupsListOK), nil

}

/*
IPAMVlanGroupsPartialUpdate ipam vlan groups partial update API
*/
func (a *Client) IPAMVlanGroupsPartialUpdate(params *IPAMVlanGroupsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlanGroupsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlanGroupsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlan-groups_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/vlan-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlanGroupsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlanGroupsPartialUpdateOK), nil

}

/*
IPAMVlanGroupsRead ipam vlan groups read API
*/
func (a *Client) IPAMVlanGroupsRead(params *IPAMVlanGroupsReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlanGroupsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlanGroupsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlan-groups_read",
		Method:             "GET",
		PathPattern:        "/ipam/vlan-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlanGroupsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlanGroupsReadOK), nil

}

/*
IPAMVlanGroupsUpdate ipam vlan groups update API
*/
func (a *Client) IPAMVlanGroupsUpdate(params *IPAMVlanGroupsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlanGroupsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlanGroupsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlan-groups_update",
		Method:             "PUT",
		PathPattern:        "/ipam/vlan-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlanGroupsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlanGroupsUpdateOK), nil

}

/*
IPAMVlansCreate ipam vlans create API
*/
func (a *Client) IPAMVlansCreate(params *IPAMVlansCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlansCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlansCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlans_create",
		Method:             "POST",
		PathPattern:        "/ipam/vlans/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlansCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlansCreateCreated), nil

}

/*
IPAMVlansDelete ipam vlans delete API
*/
func (a *Client) IPAMVlansDelete(params *IPAMVlansDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlansDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlansDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlans_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/vlans/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlansDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlansDeleteNoContent), nil

}

/*
IPAMVlansList ipam vlans list API
*/
func (a *Client) IPAMVlansList(params *IPAMVlansListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlansListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlansListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlans_list",
		Method:             "GET",
		PathPattern:        "/ipam/vlans/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlansListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlansListOK), nil

}

/*
IPAMVlansPartialUpdate ipam vlans partial update API
*/
func (a *Client) IPAMVlansPartialUpdate(params *IPAMVlansPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlansPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlansPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlans_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/vlans/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlansPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlansPartialUpdateOK), nil

}

/*
IPAMVlansRead ipam vlans read API
*/
func (a *Client) IPAMVlansRead(params *IPAMVlansReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlansReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlansReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlans_read",
		Method:             "GET",
		PathPattern:        "/ipam/vlans/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlansReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlansReadOK), nil

}

/*
IPAMVlansUpdate ipam vlans update API
*/
func (a *Client) IPAMVlansUpdate(params *IPAMVlansUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVlansUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVlansUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vlans_update",
		Method:             "PUT",
		PathPattern:        "/ipam/vlans/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVlansUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVlansUpdateOK), nil

}

/*
IPAMVrfsCreate ipam vrfs create API
*/
func (a *Client) IPAMVrfsCreate(params *IPAMVrfsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVrfsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVrfsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vrfs_create",
		Method:             "POST",
		PathPattern:        "/ipam/vrfs/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVrfsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVrfsCreateCreated), nil

}

/*
IPAMVrfsDelete ipam vrfs delete API
*/
func (a *Client) IPAMVrfsDelete(params *IPAMVrfsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVrfsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVrfsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vrfs_delete",
		Method:             "DELETE",
		PathPattern:        "/ipam/vrfs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVrfsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVrfsDeleteNoContent), nil

}

/*
IPAMVrfsList ipam vrfs list API
*/
func (a *Client) IPAMVrfsList(params *IPAMVrfsListParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVrfsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVrfsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vrfs_list",
		Method:             "GET",
		PathPattern:        "/ipam/vrfs/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVrfsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVrfsListOK), nil

}

/*
IPAMVrfsPartialUpdate ipam vrfs partial update API
*/
func (a *Client) IPAMVrfsPartialUpdate(params *IPAMVrfsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVrfsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVrfsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vrfs_partial_update",
		Method:             "PATCH",
		PathPattern:        "/ipam/vrfs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVrfsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVrfsPartialUpdateOK), nil

}

/*
IPAMVrfsRead ipam vrfs read API
*/
func (a *Client) IPAMVrfsRead(params *IPAMVrfsReadParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVrfsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVrfsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vrfs_read",
		Method:             "GET",
		PathPattern:        "/ipam/vrfs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVrfsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVrfsReadOK), nil

}

/*
IPAMVrfsUpdate ipam vrfs update API
*/
func (a *Client) IPAMVrfsUpdate(params *IPAMVrfsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*IPAMVrfsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewIPAMVrfsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ipam_vrfs_update",
		Method:             "PUT",
		PathPattern:        "/ipam/vrfs/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &IPAMVrfsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*IPAMVrfsUpdateOK), nil

}

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