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

package application_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 application service API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

// New creates a new application 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 application 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 application 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 {
	ApplicationServiceCreate(params *ApplicationServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateOK, error)

	ApplicationServiceCreateAwsSnsIntegration(params *ApplicationServiceCreateAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateAwsSnsIntegrationOK, error)

	ApplicationServiceCreateAzureServiceBusIntegration(params *ApplicationServiceCreateAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateAzureServiceBusIntegrationOK, error)

	ApplicationServiceCreateGcpPubSubIntegration(params *ApplicationServiceCreateGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateGcpPubSubIntegrationOK, error)

	ApplicationServiceCreateHTTPIntegration(params *ApplicationServiceCreateHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateHTTPIntegrationOK, error)

	ApplicationServiceCreateIftttIntegration(params *ApplicationServiceCreateIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateIftttIntegrationOK, error)

	ApplicationServiceCreateInfluxDbIntegration(params *ApplicationServiceCreateInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateInfluxDbIntegrationOK, error)

	ApplicationServiceCreateMyDevicesIntegration(params *ApplicationServiceCreateMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateMyDevicesIntegrationOK, error)

	ApplicationServiceCreatePilotThingsIntegration(params *ApplicationServiceCreatePilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreatePilotThingsIntegrationOK, error)

	ApplicationServiceCreateThingsBoardIntegration(params *ApplicationServiceCreateThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateThingsBoardIntegrationOK, error)

	ApplicationServiceDelete(params *ApplicationServiceDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteOK, error)

	ApplicationServiceDeleteAwsSnsIntegration(params *ApplicationServiceDeleteAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteAwsSnsIntegrationOK, error)

	ApplicationServiceDeleteAzureServiceBusIntegration(params *ApplicationServiceDeleteAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteAzureServiceBusIntegrationOK, error)

	ApplicationServiceDeleteGcpPubSubIntegration(params *ApplicationServiceDeleteGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteGcpPubSubIntegrationOK, error)

	ApplicationServiceDeleteHTTPIntegration(params *ApplicationServiceDeleteHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteHTTPIntegrationOK, error)

	ApplicationServiceDeleteIftttIntegration(params *ApplicationServiceDeleteIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteIftttIntegrationOK, error)

	ApplicationServiceDeleteInfluxDbIntegration(params *ApplicationServiceDeleteInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteInfluxDbIntegrationOK, error)

	ApplicationServiceDeleteMyDevicesIntegration(params *ApplicationServiceDeleteMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteMyDevicesIntegrationOK, error)

	ApplicationServiceDeletePilotThingsIntegration(params *ApplicationServiceDeletePilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeletePilotThingsIntegrationOK, error)

	ApplicationServiceDeleteThingsBoardIntegration(params *ApplicationServiceDeleteThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteThingsBoardIntegrationOK, error)

	ApplicationServiceGenerateMqttIntegrationClientCertificate(params *ApplicationServiceGenerateMqttIntegrationClientCertificateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGenerateMqttIntegrationClientCertificateOK, error)

	ApplicationServiceGet(params *ApplicationServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetOK, error)

	ApplicationServiceGetAwsSnsIntegration(params *ApplicationServiceGetAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetAwsSnsIntegrationOK, error)

	ApplicationServiceGetAzureServiceBusIntegration(params *ApplicationServiceGetAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetAzureServiceBusIntegrationOK, error)

	ApplicationServiceGetGcpPubSubIntegration(params *ApplicationServiceGetGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetGcpPubSubIntegrationOK, error)

	ApplicationServiceGetHTTPIntegration(params *ApplicationServiceGetHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetHTTPIntegrationOK, error)

	ApplicationServiceGetIftttIntegration(params *ApplicationServiceGetIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetIftttIntegrationOK, error)

	ApplicationServiceGetInfluxDbIntegration(params *ApplicationServiceGetInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetInfluxDbIntegrationOK, error)

	ApplicationServiceGetMyDevicesIntegration(params *ApplicationServiceGetMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetMyDevicesIntegrationOK, error)

	ApplicationServiceGetPilotThingsIntegration(params *ApplicationServiceGetPilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetPilotThingsIntegrationOK, error)

	ApplicationServiceGetThingsBoardIntegration(params *ApplicationServiceGetThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetThingsBoardIntegrationOK, error)

	ApplicationServiceList(params *ApplicationServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListOK, error)

	ApplicationServiceListDeviceProfiles(params *ApplicationServiceListDeviceProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListDeviceProfilesOK, error)

	ApplicationServiceListDeviceTags(params *ApplicationServiceListDeviceTagsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListDeviceTagsOK, error)

	ApplicationServiceListIntegrations(params *ApplicationServiceListIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListIntegrationsOK, error)

	ApplicationServiceUpdate(params *ApplicationServiceUpdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateOK, error)

	ApplicationServiceUpdateAwsSnsIntegration(params *ApplicationServiceUpdateAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateAwsSnsIntegrationOK, error)

	ApplicationServiceUpdateAzureServiceBusIntegration(params *ApplicationServiceUpdateAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateAzureServiceBusIntegrationOK, error)

	ApplicationServiceUpdateGcpPubSubIntegration(params *ApplicationServiceUpdateGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateGcpPubSubIntegrationOK, error)

	ApplicationServiceUpdateHTTPIntegration(params *ApplicationServiceUpdateHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateHTTPIntegrationOK, error)

	ApplicationServiceUpdateIftttIntegration(params *ApplicationServiceUpdateIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateIftttIntegrationOK, error)

	ApplicationServiceUpdateInfluxDbIntegration(params *ApplicationServiceUpdateInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateInfluxDbIntegrationOK, error)

	ApplicationServiceUpdateMyDevicesIntegration(params *ApplicationServiceUpdateMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateMyDevicesIntegrationOK, error)

	ApplicationServiceUpdatePilotThingsIntegration(params *ApplicationServiceUpdatePilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdatePilotThingsIntegrationOK, error)

	ApplicationServiceUpdateThingsBoardIntegration(params *ApplicationServiceUpdateThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateThingsBoardIntegrationOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
ApplicationServiceCreate creates creates the given application
*/
func (a *Client) ApplicationServiceCreate(params *ApplicationServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_Create",
		Method:             "POST",
		PathPattern:        "/api/applications",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateReader{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.(*ApplicationServiceCreateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateAwsSnsIntegration creates a w s s n s integration
*/
func (a *Client) ApplicationServiceCreateAwsSnsIntegration(params *ApplicationServiceCreateAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateAwsSnsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateAwsSnsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateAwsSnsIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/aws-sns",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateAwsSnsIntegrationReader{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.(*ApplicationServiceCreateAwsSnsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateAwsSnsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateAzureServiceBusIntegration creates azure service bus integration
*/
func (a *Client) ApplicationServiceCreateAzureServiceBusIntegration(params *ApplicationServiceCreateAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateAzureServiceBusIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateAzureServiceBusIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateAzureServiceBusIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/azure-service-bus",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateAzureServiceBusIntegrationReader{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.(*ApplicationServiceCreateAzureServiceBusIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateAzureServiceBusIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateGcpPubSubIntegration creates g c p pub sub integration
*/
func (a *Client) ApplicationServiceCreateGcpPubSubIntegration(params *ApplicationServiceCreateGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateGcpPubSubIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateGcpPubSubIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateGcpPubSubIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/gcp-pub-sub",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateGcpPubSubIntegrationReader{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.(*ApplicationServiceCreateGcpPubSubIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateGcpPubSubIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateHTTPIntegration creates HTTP integration
*/
func (a *Client) ApplicationServiceCreateHTTPIntegration(params *ApplicationServiceCreateHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateHTTPIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateHTTPIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateHttpIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/http",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateHTTPIntegrationReader{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.(*ApplicationServiceCreateHTTPIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateHTTPIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateIftttIntegration creates i f t t t integration
*/
func (a *Client) ApplicationServiceCreateIftttIntegration(params *ApplicationServiceCreateIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateIftttIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateIftttIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateIftttIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/ifttt",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateIftttIntegrationReader{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.(*ApplicationServiceCreateIftttIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateIftttIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateInfluxDbIntegration creates influx db integration
*/
func (a *Client) ApplicationServiceCreateInfluxDbIntegration(params *ApplicationServiceCreateInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateInfluxDbIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateInfluxDbIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateInfluxDbIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/influxdb",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateInfluxDbIntegrationReader{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.(*ApplicationServiceCreateInfluxDbIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateInfluxDbIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateMyDevicesIntegration creates my devices integration
*/
func (a *Client) ApplicationServiceCreateMyDevicesIntegration(params *ApplicationServiceCreateMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateMyDevicesIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateMyDevicesIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateMyDevicesIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/mydevices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateMyDevicesIntegrationReader{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.(*ApplicationServiceCreateMyDevicesIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateMyDevicesIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreatePilotThingsIntegration creates pilot things integration
*/
func (a *Client) ApplicationServiceCreatePilotThingsIntegration(params *ApplicationServiceCreatePilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreatePilotThingsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreatePilotThingsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreatePilotThingsIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/pilot-things",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreatePilotThingsIntegrationReader{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.(*ApplicationServiceCreatePilotThingsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreatePilotThingsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceCreateThingsBoardIntegration creates things board integration
*/
func (a *Client) ApplicationServiceCreateThingsBoardIntegration(params *ApplicationServiceCreateThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceCreateThingsBoardIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceCreateThingsBoardIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_CreateThingsBoardIntegration",
		Method:             "POST",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/thingsboard",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceCreateThingsBoardIntegrationReader{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.(*ApplicationServiceCreateThingsBoardIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceCreateThingsBoardIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDelete deletes the application for the given ID
*/
func (a *Client) ApplicationServiceDelete(params *ApplicationServiceDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_Delete",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteReader{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.(*ApplicationServiceDeleteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteAwsSnsIntegration deletes a w s s n s integration
*/
func (a *Client) ApplicationServiceDeleteAwsSnsIntegration(params *ApplicationServiceDeleteAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteAwsSnsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteAwsSnsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteAwsSnsIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/aws-sns",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteAwsSnsIntegrationReader{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.(*ApplicationServiceDeleteAwsSnsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteAwsSnsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteAzureServiceBusIntegration deletes azure service bus integration
*/
func (a *Client) ApplicationServiceDeleteAzureServiceBusIntegration(params *ApplicationServiceDeleteAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteAzureServiceBusIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteAzureServiceBusIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteAzureServiceBusIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/azure-service-bus",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteAzureServiceBusIntegrationReader{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.(*ApplicationServiceDeleteAzureServiceBusIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteAzureServiceBusIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteGcpPubSubIntegration deletes g c p pub sub integration
*/
func (a *Client) ApplicationServiceDeleteGcpPubSubIntegration(params *ApplicationServiceDeleteGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteGcpPubSubIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteGcpPubSubIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteGcpPubSubIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/gcp-pub-sub",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteGcpPubSubIntegrationReader{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.(*ApplicationServiceDeleteGcpPubSubIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteGcpPubSubIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteHTTPIntegration deletes the HTTP integration
*/
func (a *Client) ApplicationServiceDeleteHTTPIntegration(params *ApplicationServiceDeleteHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteHTTPIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteHTTPIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteHttpIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/http",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteHTTPIntegrationReader{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.(*ApplicationServiceDeleteHTTPIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteHTTPIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteIftttIntegration deletes i f t t t integration
*/
func (a *Client) ApplicationServiceDeleteIftttIntegration(params *ApplicationServiceDeleteIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteIftttIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteIftttIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteIftttIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/ifttt",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteIftttIntegrationReader{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.(*ApplicationServiceDeleteIftttIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteIftttIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteInfluxDbIntegration deletes influx db integration
*/
func (a *Client) ApplicationServiceDeleteInfluxDbIntegration(params *ApplicationServiceDeleteInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteInfluxDbIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteInfluxDbIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteInfluxDbIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/influxdb",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteInfluxDbIntegrationReader{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.(*ApplicationServiceDeleteInfluxDbIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteInfluxDbIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteMyDevicesIntegration deletes my devices integration
*/
func (a *Client) ApplicationServiceDeleteMyDevicesIntegration(params *ApplicationServiceDeleteMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteMyDevicesIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteMyDevicesIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteMyDevicesIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/mydevices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteMyDevicesIntegrationReader{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.(*ApplicationServiceDeleteMyDevicesIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteMyDevicesIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeletePilotThingsIntegration deletes pilot things integration
*/
func (a *Client) ApplicationServiceDeletePilotThingsIntegration(params *ApplicationServiceDeletePilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeletePilotThingsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeletePilotThingsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeletePilotThingsIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/pilot-things",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeletePilotThingsIntegrationReader{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.(*ApplicationServiceDeletePilotThingsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeletePilotThingsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceDeleteThingsBoardIntegration deletes things board integration
*/
func (a *Client) ApplicationServiceDeleteThingsBoardIntegration(params *ApplicationServiceDeleteThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceDeleteThingsBoardIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceDeleteThingsBoardIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_DeleteThingsBoardIntegration",
		Method:             "DELETE",
		PathPattern:        "/api/applications/{applicationId}/integrations/thingsboard",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceDeleteThingsBoardIntegrationReader{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.(*ApplicationServiceDeleteThingsBoardIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceDeleteThingsBoardIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGenerateMqttIntegrationClientCertificate generates application ID specific client certificate
*/
func (a *Client) ApplicationServiceGenerateMqttIntegrationClientCertificate(params *ApplicationServiceGenerateMqttIntegrationClientCertificateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGenerateMqttIntegrationClientCertificateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGenerateMqttIntegrationClientCertificateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GenerateMqttIntegrationClientCertificate",
		Method:             "POST",
		PathPattern:        "/api/applications/{applicationId}/integrations/mqtt/certificate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGenerateMqttIntegrationClientCertificateReader{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.(*ApplicationServiceGenerateMqttIntegrationClientCertificateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGenerateMqttIntegrationClientCertificateDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGet gets the application for the given ID
*/
func (a *Client) ApplicationServiceGet(params *ApplicationServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_Get",
		Method:             "GET",
		PathPattern:        "/api/applications/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetReader{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.(*ApplicationServiceGetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetAwsSnsIntegration gets a w s s n s integration
*/
func (a *Client) ApplicationServiceGetAwsSnsIntegration(params *ApplicationServiceGetAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetAwsSnsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetAwsSnsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetAwsSnsIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/aws-sns",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetAwsSnsIntegrationReader{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.(*ApplicationServiceGetAwsSnsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetAwsSnsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetAzureServiceBusIntegration gets azure service bus integration
*/
func (a *Client) ApplicationServiceGetAzureServiceBusIntegration(params *ApplicationServiceGetAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetAzureServiceBusIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetAzureServiceBusIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetAzureServiceBusIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/azure-service-bus",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetAzureServiceBusIntegrationReader{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.(*ApplicationServiceGetAzureServiceBusIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetAzureServiceBusIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetGcpPubSubIntegration gets g c p pub sub integration
*/
func (a *Client) ApplicationServiceGetGcpPubSubIntegration(params *ApplicationServiceGetGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetGcpPubSubIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetGcpPubSubIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetGcpPubSubIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/gcp-pub-sub",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetGcpPubSubIntegrationReader{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.(*ApplicationServiceGetGcpPubSubIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetGcpPubSubIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetHTTPIntegration gets the configured HTTP integration
*/
func (a *Client) ApplicationServiceGetHTTPIntegration(params *ApplicationServiceGetHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetHTTPIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetHTTPIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetHttpIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/http",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetHTTPIntegrationReader{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.(*ApplicationServiceGetHTTPIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetHTTPIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetIftttIntegration gets i f t t t integration
*/
func (a *Client) ApplicationServiceGetIftttIntegration(params *ApplicationServiceGetIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetIftttIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetIftttIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetIftttIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/ifttt",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetIftttIntegrationReader{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.(*ApplicationServiceGetIftttIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetIftttIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetInfluxDbIntegration gets influx db integration
*/
func (a *Client) ApplicationServiceGetInfluxDbIntegration(params *ApplicationServiceGetInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetInfluxDbIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetInfluxDbIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetInfluxDbIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/influxdb",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetInfluxDbIntegrationReader{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.(*ApplicationServiceGetInfluxDbIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetInfluxDbIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetMyDevicesIntegration gets my devices integration
*/
func (a *Client) ApplicationServiceGetMyDevicesIntegration(params *ApplicationServiceGetMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetMyDevicesIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetMyDevicesIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetMyDevicesIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/mydevices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetMyDevicesIntegrationReader{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.(*ApplicationServiceGetMyDevicesIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetMyDevicesIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetPilotThingsIntegration gets pilot things integration
*/
func (a *Client) ApplicationServiceGetPilotThingsIntegration(params *ApplicationServiceGetPilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetPilotThingsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetPilotThingsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetPilotThingsIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/pilot-things",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetPilotThingsIntegrationReader{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.(*ApplicationServiceGetPilotThingsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetPilotThingsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceGetThingsBoardIntegration gets things board integration
*/
func (a *Client) ApplicationServiceGetThingsBoardIntegration(params *ApplicationServiceGetThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceGetThingsBoardIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceGetThingsBoardIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_GetThingsBoardIntegration",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations/thingsboard",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceGetThingsBoardIntegrationReader{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.(*ApplicationServiceGetThingsBoardIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceGetThingsBoardIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceList gets the list of applications
*/
func (a *Client) ApplicationServiceList(params *ApplicationServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_List",
		Method:             "GET",
		PathPattern:        "/api/applications",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceListReader{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.(*ApplicationServiceListOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceListDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceListDeviceProfiles lists device profiles used within the given application
*/
func (a *Client) ApplicationServiceListDeviceProfiles(params *ApplicationServiceListDeviceProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListDeviceProfilesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceListDeviceProfilesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_ListDeviceProfiles",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/device-profiles",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceListDeviceProfilesReader{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.(*ApplicationServiceListDeviceProfilesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceListDeviceProfilesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceListDeviceTags lists device tags used within the given application
*/
func (a *Client) ApplicationServiceListDeviceTags(params *ApplicationServiceListDeviceTagsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListDeviceTagsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceListDeviceTagsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_ListDeviceTags",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/device-tags",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceListDeviceTagsReader{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.(*ApplicationServiceListDeviceTagsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceListDeviceTagsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceListIntegrations lists all configured integrations
*/
func (a *Client) ApplicationServiceListIntegrations(params *ApplicationServiceListIntegrationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceListIntegrationsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceListIntegrationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_ListIntegrations",
		Method:             "GET",
		PathPattern:        "/api/applications/{applicationId}/integrations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceListIntegrationsReader{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.(*ApplicationServiceListIntegrationsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceListIntegrationsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdate updates updates the given application
*/
func (a *Client) ApplicationServiceUpdate(params *ApplicationServiceUpdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_Update",
		Method:             "PUT",
		PathPattern:        "/api/applications/{application.id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateReader{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.(*ApplicationServiceUpdateOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateAwsSnsIntegration updates a w s s n s integration
*/
func (a *Client) ApplicationServiceUpdateAwsSnsIntegration(params *ApplicationServiceUpdateAwsSnsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateAwsSnsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateAwsSnsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateAwsSnsIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/aws-sns",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateAwsSnsIntegrationReader{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.(*ApplicationServiceUpdateAwsSnsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateAwsSnsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateAzureServiceBusIntegration updates azure service bus integration
*/
func (a *Client) ApplicationServiceUpdateAzureServiceBusIntegration(params *ApplicationServiceUpdateAzureServiceBusIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateAzureServiceBusIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateAzureServiceBusIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateAzureServiceBusIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/azure-service-bus",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateAzureServiceBusIntegrationReader{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.(*ApplicationServiceUpdateAzureServiceBusIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateAzureServiceBusIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateGcpPubSubIntegration updates g c p pub sub integration
*/
func (a *Client) ApplicationServiceUpdateGcpPubSubIntegration(params *ApplicationServiceUpdateGcpPubSubIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateGcpPubSubIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateGcpPubSubIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateGcpPubSubIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/gcp-pub-sub",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateGcpPubSubIntegrationReader{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.(*ApplicationServiceUpdateGcpPubSubIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateGcpPubSubIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateHTTPIntegration updates the HTTP integration
*/
func (a *Client) ApplicationServiceUpdateHTTPIntegration(params *ApplicationServiceUpdateHTTPIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateHTTPIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateHTTPIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateHttpIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/http",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateHTTPIntegrationReader{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.(*ApplicationServiceUpdateHTTPIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateHTTPIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateIftttIntegration updates i f t t t integration
*/
func (a *Client) ApplicationServiceUpdateIftttIntegration(params *ApplicationServiceUpdateIftttIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateIftttIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateIftttIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateIftttIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/ifttt",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateIftttIntegrationReader{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.(*ApplicationServiceUpdateIftttIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateIftttIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateInfluxDbIntegration updates influx db integration
*/
func (a *Client) ApplicationServiceUpdateInfluxDbIntegration(params *ApplicationServiceUpdateInfluxDbIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateInfluxDbIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateInfluxDbIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateInfluxDbIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/influxdb",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateInfluxDbIntegrationReader{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.(*ApplicationServiceUpdateInfluxDbIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateInfluxDbIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateMyDevicesIntegration updates my devices integration
*/
func (a *Client) ApplicationServiceUpdateMyDevicesIntegration(params *ApplicationServiceUpdateMyDevicesIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateMyDevicesIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateMyDevicesIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateMyDevicesIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/mydevices",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateMyDevicesIntegrationReader{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.(*ApplicationServiceUpdateMyDevicesIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateMyDevicesIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdatePilotThingsIntegration updates pilot things integration
*/
func (a *Client) ApplicationServiceUpdatePilotThingsIntegration(params *ApplicationServiceUpdatePilotThingsIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdatePilotThingsIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdatePilotThingsIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdatePilotThingsIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/pilot-things",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdatePilotThingsIntegrationReader{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.(*ApplicationServiceUpdatePilotThingsIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdatePilotThingsIntegrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ApplicationServiceUpdateThingsBoardIntegration updates things board integration
*/
func (a *Client) ApplicationServiceUpdateThingsBoardIntegration(params *ApplicationServiceUpdateThingsBoardIntegrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ApplicationServiceUpdateThingsBoardIntegrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewApplicationServiceUpdateThingsBoardIntegrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ApplicationService_UpdateThingsBoardIntegration",
		Method:             "PUT",
		PathPattern:        "/api/applications/{integration.applicationId}/integrations/thingsboard",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ApplicationServiceUpdateThingsBoardIntegrationReader{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.(*ApplicationServiceUpdateThingsBoardIntegrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ApplicationServiceUpdateThingsBoardIntegrationDefault)
	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
}
