| // 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 |
| } |