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

package network_service

// 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"
	httptransport "github.com/go-openapi/runtime/client"
	"github.com/go-openapi/strfmt"
)

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

// New creates a new network service API client with basic auth credentials.
// It takes the following parameters:
// - host: http host (github.com).
// - basePath: any base path for the API client ("/v1", "/v3").
// - scheme: http scheme ("http", "https").
// - user: user for basic authentication header.
// - password: password for basic authentication header.
func NewClientWithBasicAuth(host, basePath, scheme, user, password string) ClientService {
	transport := httptransport.New(host, basePath, []string{scheme})
	transport.DefaultAuthentication = httptransport.BasicAuth(user, password)
	return &Client{transport: transport, formats: strfmt.Default}
}

// New creates a new network service API client with a bearer token for authentication.
// It takes the following parameters:
// - host: http host (github.com).
// - basePath: any base path for the API client ("/v1", "/v3").
// - scheme: http scheme ("http", "https").
// - bearerToken: bearer token for Bearer authentication header.
func NewClientWithBearerToken(host, basePath, scheme, bearerToken string) ClientService {
	transport := httptransport.New(host, basePath, []string{scheme})
	transport.DefaultAuthentication = httptransport.BearerToken(bearerToken)
	return &Client{transport: transport, formats: strfmt.Default}
}

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

// ClientOption may be used to customize the behavior of Client methods.
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	AssociateHVNWithAWSRoute53PrivateHostedZone(params *AssociateHVNWithAWSRoute53PrivateHostedZoneParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AssociateHVNWithAWSRoute53PrivateHostedZoneOK, error)

	Create(params *CreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateOK, error)

	CreateDNSForwarding(params *CreateDNSForwardingParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDNSForwardingOK, error)

	CreateDNSForwardingRule(params *CreateDNSForwardingRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDNSForwardingRuleOK, error)

	CreateHVNRoute(params *CreateHVNRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateHVNRouteOK, error)

	CreatePeering(params *CreatePeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePeeringOK, error)

	CreatePrivateLinkService(params *CreatePrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePrivateLinkServiceOK, error)

	CreateTGWAttachment(params *CreateTGWAttachmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateTGWAttachmentOK, error)

	CreateToken(params *CreateTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateTokenOK, error)

	Delete(params *DeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteOK, error)

	DeleteDNSForwardingRule(params *DeleteDNSForwardingRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteDNSForwardingRuleOK, error)

	DeleteHVNRoute(params *DeleteHVNRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteHVNRouteOK, error)

	DeletePeering(params *DeletePeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeletePeeringOK, error)

	DeletePrivateLinkService(params *DeletePrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeletePrivateLinkServiceOK, error)

	DeleteTGWAttachment(params *DeleteTGWAttachmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteTGWAttachmentOK, error)

	Get(params *GetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOK, error)

	GetDNSForwarding(params *GetDNSForwardingParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDNSForwardingOK, error)

	GetDNSForwardingRule(params *GetDNSForwardingRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDNSForwardingRuleOK, error)

	GetHVNRoute(params *GetHVNRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetHVNRouteOK, error)

	GetPeering(params *GetPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPeeringOK, error)

	GetPrivateLinkService(params *GetPrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPrivateLinkServiceOK, error)

	GetTGWAttachment(params *GetTGWAttachmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTGWAttachmentOK, error)

	List(params *ListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListOK, error)

	ListDNSForwardingRules(params *ListDNSForwardingRulesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDNSForwardingRulesOK, error)

	ListDNSForwardings(params *ListDNSForwardingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDNSForwardingsOK, error)

	ListDependencies(params *ListDependenciesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDependenciesOK, error)

	ListHVNRoutes(params *ListHVNRoutesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListHVNRoutesOK, error)

	ListPeerings(params *ListPeeringsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListPeeringsOK, error)

	ListPrivateLinkService(params *ListPrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListPrivateLinkServiceOK, error)

	ListTGWAttachments(params *ListTGWAttachmentsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListTGWAttachmentsOK, error)

	UpdatePrivateLinkService(params *UpdatePrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdatePrivateLinkServiceOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
AssociateHVNWithAWSRoute53PrivateHostedZone associates h v n with a w s route53 private hosted zone will associate the h v n s v p c with a user s private hosted zone in a w s route53 this will enable the resolution of records of the private hosted zone from within the v p c
*/
func (a *Client) AssociateHVNWithAWSRoute53PrivateHostedZone(params *AssociateHVNWithAWSRoute53PrivateHostedZoneParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AssociateHVNWithAWSRoute53PrivateHostedZoneOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAssociateHVNWithAWSRoute53PrivateHostedZoneParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AssociateHVNWithAWSRoute53PrivateHostedZone",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{hvn_id}/aws-route53-private-hosted-zone-associations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &AssociateHVNWithAWSRoute53PrivateHostedZoneReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AssociateHVNWithAWSRoute53PrivateHostedZoneOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*AssociateHVNWithAWSRoute53PrivateHostedZoneDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
Create creates creates a new h v n
*/
func (a *Client) Create(params *CreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Create",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{network.location.organization_id}/projects/{network.location.project_id}/networks",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreateDNSForwarding creates DNS forwarding creates a new network dns forwarding between h v n v p c v net and target customer v p c v net
*/
func (a *Client) CreateDNSForwarding(params *CreateDNSForwardingParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDNSForwardingOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateDNSForwardingParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateDNSForwarding",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{dns_forwarding.hvn.location.organization_id}/projects/{dns_forwarding.hvn.location.project_id}/networks/{dns_forwarding.hvn.id}/dnsforwardings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateDNSForwardingReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateDNSForwardingOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateDNSForwardingDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreateDNSForwardingRule creates DNS forwarding rule creates a new network dns forwarding rule for an existing dns forwarding within a h v n v p c v net
*/
func (a *Client) CreateDNSForwardingRule(params *CreateDNSForwardingRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDNSForwardingRuleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateDNSForwardingRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateDNSForwardingRule",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{dns_forwarding_rule.hvn.location.organization_id}/projects/{dns_forwarding_rule.hvn.location.project_id}/networks/{dns_forwarding_rule.hvn.id}/dnsforwardings/{dns_forwarding_rule.dns_forwarding_id}/rules",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateDNSForwardingRuleReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateDNSForwardingRuleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateDNSForwardingRuleDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreateHVNRoute hs v n routes

CreateHVNRoute creates a new HVN Route
*/
func (a *Client) CreateHVNRoute(params *CreateHVNRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateHVNRouteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateHVNRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateHVNRoute",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/routes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateHVNRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateHVNRouteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateHVNRouteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreatePeering creates peering creates a new network peering between h v n v p c and target v p c
*/
func (a *Client) CreatePeering(params *CreatePeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreatePeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreatePeering",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{peering.hvn.location.organization_id}/projects/{peering.hvn.location.project_id}/networks/{peering.hvn.id}/peerings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreatePeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreatePeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreatePeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreatePrivateLinkService creates private link service creates a new private link service via public api
*/
func (a *Client) CreatePrivateLinkService(params *CreatePrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePrivateLinkServiceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreatePrivateLinkServiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreatePrivateLinkService",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{private_link_service.hvn.location.organization_id}/projects/{private_link_service.hvn.location.project_id}/networks/{private_link_service.hvn.id}/private-link-services",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreatePrivateLinkServiceReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreatePrivateLinkServiceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreatePrivateLinkServiceDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreateTGWAttachment creates t g w attachment creates a new transit gateway attachment for an h v n
*/
func (a *Client) CreateTGWAttachment(params *CreateTGWAttachmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateTGWAttachmentOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateTGWAttachmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateTGWAttachment",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/transit-gateway-attachments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateTGWAttachmentReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateTGWAttachmentOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateTGWAttachmentDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreateToken creates token creates a short lived token with auth to issue a create peering for the given h v n w a r n i n g this is an experimental feature that may change or be removed without notice
*/
func (a *Client) CreateToken(params *CreateTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateTokenOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateTokenParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateToken",
		Method:             "POST",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{id}/tokens",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &CreateTokenReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateTokenOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateTokenDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
Delete deletes deletes a new h v n
*/
func (a *Client) Delete(params *DeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Delete",
		Method:             "DELETE",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeleteDNSForwardingRule deletes DNS forwarding rule deletes specified dns forwarding rule from a dns forwarding and hvn
*/
func (a *Client) DeleteDNSForwardingRule(params *DeleteDNSForwardingRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteDNSForwardingRuleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDNSForwardingRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteDNSForwardingRule",
		Method:             "DELETE",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{hvn_id}/dnsforwardings/{dns_forwarding_id}/rules/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteDNSForwardingRuleReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteDNSForwardingRuleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteDNSForwardingRuleDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeleteHVNRoute deletes h v n route triggers h v n route deletion workflow
*/
func (a *Client) DeleteHVNRoute(params *DeleteHVNRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteHVNRouteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteHVNRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteHVNRoute",
		Method:             "DELETE",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/routes/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteHVNRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteHVNRouteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteHVNRouteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeletePeering deletes peering deletes specified peering and triggers updating network configuration
*/
func (a *Client) DeletePeering(params *DeletePeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeletePeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeletePeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeletePeering",
		Method:             "DELETE",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{hvn_id}/peerings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeletePeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeletePeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeletePeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeletePrivateLinkService deletes private link service deletes specified private link service
*/
func (a *Client) DeletePrivateLinkService(params *DeletePrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeletePrivateLinkServiceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeletePrivateLinkServiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeletePrivateLinkService",
		Method:             "DELETE",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{hvn_id}/private-link-services/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeletePrivateLinkServiceReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeletePrivateLinkServiceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeletePrivateLinkServiceDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeleteTGWAttachment deletes t g w attachment deletes specified transit gateway attachment and triggers updating network configuration
*/
func (a *Client) DeleteTGWAttachment(params *DeleteTGWAttachmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteTGWAttachmentOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteTGWAttachmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteTGWAttachment",
		Method:             "DELETE",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/transit-gateway-attachments/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteTGWAttachmentReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteTGWAttachmentOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteTGWAttachmentDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
Get gets reads a single h v n
*/
func (a *Client) Get(params *GetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Get",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetDNSForwarding gets DNS forwarding returns information about dns forwarding
*/
func (a *Client) GetDNSForwarding(params *GetDNSForwardingParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDNSForwardingOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDNSForwardingParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetDNSForwarding",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/dnsforwardings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetDNSForwardingReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDNSForwardingOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetDNSForwardingDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetDNSForwardingRule gets DNS forwarding rule returns information about a dns forwarding rule
*/
func (a *Client) GetDNSForwardingRule(params *GetDNSForwardingRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDNSForwardingRuleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDNSForwardingRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetDNSForwardingRule",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/dnsforwardings/{dns_forwarding_id}/rules/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetDNSForwardingRuleReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDNSForwardingRuleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetDNSForwardingRuleDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetHVNRoute gets h v n route returns a specific h v n route
*/
func (a *Client) GetHVNRoute(params *GetHVNRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetHVNRouteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetHVNRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetHVNRoute",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/routes/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetHVNRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetHVNRouteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetHVNRouteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetPeering gets peering returns information about peering
*/
func (a *Client) GetPeering(params *GetPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetPeering",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{hvn_id}/peerings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetPeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetPrivateLinkService gets private link returns a private link matching the request
*/
func (a *Client) GetPrivateLinkService(params *GetPrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPrivateLinkServiceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPrivateLinkServiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetPrivateLinkService",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/private-link-services/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPrivateLinkServiceReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPrivateLinkServiceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetPrivateLinkServiceDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetTGWAttachment gets t g w attachment returns existing t g w attachment
*/
func (a *Client) GetTGWAttachment(params *GetTGWAttachmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTGWAttachmentOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTGWAttachmentParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetTGWAttachment",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/transit-gateway-attachments/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTGWAttachmentReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTGWAttachmentOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetTGWAttachmentDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
List lists lists all h v ns
*/
func (a *Client) List(params *ListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "List",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListDNSForwardingRules lists DNS forwarding rules returns a list of dns forwarding rules matching the request
*/
func (a *Client) ListDNSForwardingRules(params *ListDNSForwardingRulesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDNSForwardingRulesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListDNSForwardingRulesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListDNSForwardingRules",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/dnsforwardings/{dns_forwarding_id}/rules",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListDNSForwardingRulesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListDNSForwardingRulesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListDNSForwardingRulesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListDNSForwardings lists DNS forwardings returns a list of dns forwardings for a given h v n matching the request
*/
func (a *Client) ListDNSForwardings(params *ListDNSForwardingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDNSForwardingsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListDNSForwardingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListDNSForwardings",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/dnsforwardings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListDNSForwardingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListDNSForwardingsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListDNSForwardingsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListDependencies lists dependencies lists the dependent services on the given h v n
*/
func (a *Client) ListDependencies(params *ListDependenciesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDependenciesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListDependenciesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListDependencies",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{id}/dependencies",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListDependenciesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListDependenciesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListDependenciesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListHVNRoutes lists h v n routes returns a list of routes for an h v n
*/
func (a *Client) ListHVNRoutes(params *ListHVNRoutesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListHVNRoutesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListHVNRoutesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListHVNRoutes",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/routes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListHVNRoutesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListHVNRoutesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListHVNRoutesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListPeerings lists peerings returns a list of peerings matching the request
*/
func (a *Client) ListPeerings(params *ListPeeringsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListPeeringsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListPeeringsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListPeerings",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{location.organization_id}/projects/{location.project_id}/networks/{hvn_id}/peerings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListPeeringsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListPeeringsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListPeeringsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListPrivateLinkService lists private link returns a list of private link matching the request
*/
func (a *Client) ListPrivateLinkService(params *ListPrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListPrivateLinkServiceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListPrivateLinkServiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListPrivateLinkService",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/private-link-services",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListPrivateLinkServiceReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListPrivateLinkServiceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListPrivateLinkServiceDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListTGWAttachments lists t g w attachments returns a list of t g w attachments matching the request
*/
func (a *Client) ListTGWAttachments(params *ListTGWAttachmentsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListTGWAttachmentsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListTGWAttachmentsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListTGWAttachments",
		Method:             "GET",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/transit-gateway-attachments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &ListTGWAttachmentsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListTGWAttachmentsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListTGWAttachmentsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
UpdatePrivateLinkService updates private link updates a private link matching the request
*/
func (a *Client) UpdatePrivateLinkService(params *UpdatePrivateLinkServiceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdatePrivateLinkServiceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdatePrivateLinkServiceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdatePrivateLinkService",
		Method:             "PATCH",
		PathPattern:        "/network/2020-09-07/organizations/{hvn.location.organization_id}/projects/{hvn.location.project_id}/networks/{hvn.id}/private-link-services/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &UpdatePrivateLinkServiceReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*UpdatePrivateLinkServiceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdatePrivateLinkServiceDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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