Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

data

package

Go to main page

Versions in this module

v0

v0.3.2

Mar 31, 2021

v0.2.1

Dec 2, 2019

v0.1.0

Dec 2, 2019

v0.0.4

Dec 2, 2019

Changes in this version

+ type Client struct

+ func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client

+ func (a *Client) Data(params *DataParams) (*DataCreated, error)

+ func (a *Client) DataConnectionClose(params *DataConnectionCloseParams) (*DataConnectionCloseNoContent, error)

+ func (a *Client) DataConnectionEvents(params *DataConnectionEventsParams) (*DataConnectionEventsOK, error)

+ func (a *Client) DataConnectionPut(params *DataConnectionPutParams) (*DataConnectionPutOK, error)

+ func (a *Client) DataConnectionStatus(params *DataConnectionStatusParams) (*DataConnectionStatusOK, error)

+ func (a *Client) DataConnectionsCreate(params *DataConnectionsCreateParams) (*DataConnectionsCreateAccepted, error)

+ func (a *Client) DataDelete(params *DataDeleteParams) (*DataDeleteNoContent, error)

+ func (a *Client) SetTransport(transport runtime.ClientTransport)

+ type DataBadRequest struct

+ Payload *DataBadRequestBody

+ func NewDataBadRequest() *DataBadRequest

+ func (o *DataBadRequest) Error() string

+ type DataBadRequestBody struct

+ CommandType *string

+ Params *DataBadRequestBodyParams

+ func (o *DataBadRequestBody) MarshalBinary() ([]byte, error)

+ func (o *DataBadRequestBody) UnmarshalBinary(b []byte) error

+ func (o *DataBadRequestBody) Validate(formats strfmt.Registry) error

+ type DataBadRequestBodyParams struct

+ Errors []*DataBadRequestBodyParamsErrorsItems0

+ func (o *DataBadRequestBodyParams) MarshalBinary() ([]byte, error)

+ func (o *DataBadRequestBodyParams) UnmarshalBinary(b []byte) error

+ func (o *DataBadRequestBodyParams) Validate(formats strfmt.Registry) error

+ type DataBadRequestBodyParamsErrorsItems0 struct

+ Field string

+ Message string

+ func (o *DataBadRequestBodyParamsErrorsItems0) MarshalBinary() ([]byte, error)

+ func (o *DataBadRequestBodyParamsErrorsItems0) UnmarshalBinary(b []byte) error

+ func (o *DataBadRequestBodyParamsErrorsItems0) Validate(formats strfmt.Registry) error

+ type DataConnectionCloseBadRequest struct

+ Payload *DataConnectionCloseBadRequestBody

+ func NewDataConnectionCloseBadRequest() *DataConnectionCloseBadRequest

+ func (o *DataConnectionCloseBadRequest) Error() string

+ type DataConnectionCloseBadRequestBody struct

+ CommandType *string

+ Params *DataConnectionCloseBadRequestBodyParams

+ func (o *DataConnectionCloseBadRequestBody) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionCloseBadRequestBody) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionCloseBadRequestBody) Validate(formats strfmt.Registry) error

+ type DataConnectionCloseBadRequestBodyParams struct

+ Errors []*DataConnectionCloseBadRequestBodyParamsErrorsItems0

+ func (o *DataConnectionCloseBadRequestBodyParams) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionCloseBadRequestBodyParams) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionCloseBadRequestBodyParams) Validate(formats strfmt.Registry) error

+ type DataConnectionCloseBadRequestBodyParamsErrorsItems0 struct

+ Field string

+ Message string

+ func (o *DataConnectionCloseBadRequestBodyParamsErrorsItems0) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionCloseBadRequestBodyParamsErrorsItems0) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionCloseBadRequestBodyParamsErrorsItems0) Validate(formats strfmt.Registry) error

+ type DataConnectionCloseForbidden struct

+ func NewDataConnectionCloseForbidden() *DataConnectionCloseForbidden

+ func (o *DataConnectionCloseForbidden) Error() string

+ type DataConnectionCloseMethodNotAllowed struct

+ func NewDataConnectionCloseMethodNotAllowed() *DataConnectionCloseMethodNotAllowed

+ func (o *DataConnectionCloseMethodNotAllowed) Error() string

+ type DataConnectionCloseNoContent struct

+ func NewDataConnectionCloseNoContent() *DataConnectionCloseNoContent

+ func (o *DataConnectionCloseNoContent) Error() string

+ type DataConnectionCloseNotAcceptable struct

+ func NewDataConnectionCloseNotAcceptable() *DataConnectionCloseNotAcceptable

+ func (o *DataConnectionCloseNotAcceptable) Error() string

+ type DataConnectionCloseNotFound struct

+ func NewDataConnectionCloseNotFound() *DataConnectionCloseNotFound

+ func (o *DataConnectionCloseNotFound) Error() string

+ type DataConnectionCloseParams struct

+ Context context.Context

+ DataConnectionID string

+ HTTPClient *http.Client

+ func NewDataConnectionCloseParams() *DataConnectionCloseParams

+ func NewDataConnectionCloseParamsWithContext(ctx context.Context) *DataConnectionCloseParams

+ func NewDataConnectionCloseParamsWithHTTPClient(client *http.Client) *DataConnectionCloseParams

+ func NewDataConnectionCloseParamsWithTimeout(timeout time.Duration) *DataConnectionCloseParams

+ func (o *DataConnectionCloseParams) SetContext(ctx context.Context)

+ func (o *DataConnectionCloseParams) SetDataConnectionID(dataConnectionID string)

+ func (o *DataConnectionCloseParams) SetHTTPClient(client *http.Client)

+ func (o *DataConnectionCloseParams) SetTimeout(timeout time.Duration)

+ func (o *DataConnectionCloseParams) WithContext(ctx context.Context) *DataConnectionCloseParams

+ func (o *DataConnectionCloseParams) WithDataConnectionID(dataConnectionID string) *DataConnectionCloseParams

+ func (o *DataConnectionCloseParams) WithHTTPClient(client *http.Client) *DataConnectionCloseParams

+ func (o *DataConnectionCloseParams) WithTimeout(timeout time.Duration) *DataConnectionCloseParams

+ func (o *DataConnectionCloseParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DataConnectionCloseReader struct

+ func (o *DataConnectionCloseReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DataConnectionCloseRequestTimeout struct

+ func NewDataConnectionCloseRequestTimeout() *DataConnectionCloseRequestTimeout

+ func (o *DataConnectionCloseRequestTimeout) Error() string

+ type DataConnectionEventsBadRequest struct

+ Payload *DataConnectionEventsBadRequestBody

+ func NewDataConnectionEventsBadRequest() *DataConnectionEventsBadRequest

+ func (o *DataConnectionEventsBadRequest) Error() string

+ type DataConnectionEventsBadRequestBody struct

+ CommandType *string

+ Params *DataConnectionEventsBadRequestBodyParams

+ func (o *DataConnectionEventsBadRequestBody) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionEventsBadRequestBody) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionEventsBadRequestBody) Validate(formats strfmt.Registry) error

+ type DataConnectionEventsBadRequestBodyParams struct

+ Errors []*DataConnectionEventsBadRequestBodyParamsErrorsItems0

+ func (o *DataConnectionEventsBadRequestBodyParams) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionEventsBadRequestBodyParams) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionEventsBadRequestBodyParams) Validate(formats strfmt.Registry) error

+ type DataConnectionEventsBadRequestBodyParamsErrorsItems0 struct

+ Field string

+ Message string

+ func (o *DataConnectionEventsBadRequestBodyParamsErrorsItems0) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionEventsBadRequestBodyParamsErrorsItems0) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionEventsBadRequestBodyParamsErrorsItems0) Validate(formats strfmt.Registry) error

+ type DataConnectionEventsForbidden struct

+ func NewDataConnectionEventsForbidden() *DataConnectionEventsForbidden

+ func (o *DataConnectionEventsForbidden) Error() string

+ type DataConnectionEventsMethodNotAllowed struct

+ func NewDataConnectionEventsMethodNotAllowed() *DataConnectionEventsMethodNotAllowed

+ func (o *DataConnectionEventsMethodNotAllowed) Error() string

+ type DataConnectionEventsNotAcceptable struct

+ func NewDataConnectionEventsNotAcceptable() *DataConnectionEventsNotAcceptable

+ func (o *DataConnectionEventsNotAcceptable) Error() string

+ type DataConnectionEventsNotFound struct

+ func NewDataConnectionEventsNotFound() *DataConnectionEventsNotFound

+ func (o *DataConnectionEventsNotFound) Error() string

+ type DataConnectionEventsOK struct

+ Payload *models.DataConnectionEventMessage

+ func NewDataConnectionEventsOK() *DataConnectionEventsOK

+ func (o *DataConnectionEventsOK) Error() string

+ type DataConnectionEventsParams struct

+ Context context.Context

+ DataConnectionID string

+ HTTPClient *http.Client

+ func NewDataConnectionEventsParams() *DataConnectionEventsParams

+ func NewDataConnectionEventsParamsWithContext(ctx context.Context) *DataConnectionEventsParams

+ func NewDataConnectionEventsParamsWithHTTPClient(client *http.Client) *DataConnectionEventsParams

+ func NewDataConnectionEventsParamsWithTimeout(timeout time.Duration) *DataConnectionEventsParams

+ func (o *DataConnectionEventsParams) SetContext(ctx context.Context)

+ func (o *DataConnectionEventsParams) SetDataConnectionID(dataConnectionID string)

+ func (o *DataConnectionEventsParams) SetHTTPClient(client *http.Client)

+ func (o *DataConnectionEventsParams) SetTimeout(timeout time.Duration)

+ func (o *DataConnectionEventsParams) WithContext(ctx context.Context) *DataConnectionEventsParams

+ func (o *DataConnectionEventsParams) WithDataConnectionID(dataConnectionID string) *DataConnectionEventsParams

+ func (o *DataConnectionEventsParams) WithHTTPClient(client *http.Client) *DataConnectionEventsParams

+ func (o *DataConnectionEventsParams) WithTimeout(timeout time.Duration) *DataConnectionEventsParams

+ func (o *DataConnectionEventsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DataConnectionEventsReader struct

+ func (o *DataConnectionEventsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DataConnectionEventsRequestTimeout struct

+ func NewDataConnectionEventsRequestTimeout() *DataConnectionEventsRequestTimeout

+ func (o *DataConnectionEventsRequestTimeout) Error() string

+ type DataConnectionPutBadRequest struct

+ Payload *DataConnectionPutBadRequestBody

+ func NewDataConnectionPutBadRequest() *DataConnectionPutBadRequest

+ func (o *DataConnectionPutBadRequest) Error() string

+ type DataConnectionPutBadRequestBody struct

+ CommandType *string

+ Params *DataConnectionPutBadRequestBodyParams

+ func (o *DataConnectionPutBadRequestBody) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionPutBadRequestBody) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionPutBadRequestBody) Validate(formats strfmt.Registry) error

+ type DataConnectionPutBadRequestBodyParams struct

+ Errors []*DataConnectionPutBadRequestBodyParamsErrorsItems0

+ func (o *DataConnectionPutBadRequestBodyParams) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionPutBadRequestBodyParams) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionPutBadRequestBodyParams) Validate(formats strfmt.Registry) error

+ type DataConnectionPutBadRequestBodyParamsErrorsItems0 struct

+ Field string

+ Message string

+ func (o *DataConnectionPutBadRequestBodyParamsErrorsItems0) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionPutBadRequestBodyParamsErrorsItems0) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionPutBadRequestBodyParamsErrorsItems0) Validate(formats strfmt.Registry) error

+ type DataConnectionPutForbidden struct

+ func NewDataConnectionPutForbidden() *DataConnectionPutForbidden

+ func (o *DataConnectionPutForbidden) Error() string

+ type DataConnectionPutMethodNotAllowed struct

+ func NewDataConnectionPutMethodNotAllowed() *DataConnectionPutMethodNotAllowed

+ func (o *DataConnectionPutMethodNotAllowed) Error() string

+ type DataConnectionPutNotAcceptable struct

+ func NewDataConnectionPutNotAcceptable() *DataConnectionPutNotAcceptable

+ func (o *DataConnectionPutNotAcceptable) Error() string

+ type DataConnectionPutNotFound struct

+ func NewDataConnectionPutNotFound() *DataConnectionPutNotFound

+ func (o *DataConnectionPutNotFound) Error() string

+ type DataConnectionPutOK struct

+ Payload *DataConnectionPutOKBody

+ func NewDataConnectionPutOK() *DataConnectionPutOK

+ func (o *DataConnectionPutOK) Error() string

+ type DataConnectionPutOKBody struct

+ CommandType string

+ DataID string

+ func (o *DataConnectionPutOKBody) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionPutOKBody) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionPutOKBody) Validate(formats strfmt.Registry) error

+ type DataConnectionPutParams struct

+ Body *models.DataConnectionPutOptions

+ Context context.Context

+ DataConnectionID string

+ HTTPClient *http.Client

+ func NewDataConnectionPutParams() *DataConnectionPutParams

+ func NewDataConnectionPutParamsWithContext(ctx context.Context) *DataConnectionPutParams

+ func NewDataConnectionPutParamsWithHTTPClient(client *http.Client) *DataConnectionPutParams

+ func NewDataConnectionPutParamsWithTimeout(timeout time.Duration) *DataConnectionPutParams

+ func (o *DataConnectionPutParams) SetBody(body *models.DataConnectionPutOptions)

+ func (o *DataConnectionPutParams) SetContext(ctx context.Context)

+ func (o *DataConnectionPutParams) SetDataConnectionID(dataConnectionID string)

+ func (o *DataConnectionPutParams) SetHTTPClient(client *http.Client)

+ func (o *DataConnectionPutParams) SetTimeout(timeout time.Duration)

+ func (o *DataConnectionPutParams) WithBody(body *models.DataConnectionPutOptions) *DataConnectionPutParams

+ func (o *DataConnectionPutParams) WithContext(ctx context.Context) *DataConnectionPutParams

+ func (o *DataConnectionPutParams) WithDataConnectionID(dataConnectionID string) *DataConnectionPutParams

+ func (o *DataConnectionPutParams) WithHTTPClient(client *http.Client) *DataConnectionPutParams

+ func (o *DataConnectionPutParams) WithTimeout(timeout time.Duration) *DataConnectionPutParams

+ func (o *DataConnectionPutParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DataConnectionPutReader struct

+ func (o *DataConnectionPutReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DataConnectionPutRequestTimeout struct

+ func NewDataConnectionPutRequestTimeout() *DataConnectionPutRequestTimeout

+ func (o *DataConnectionPutRequestTimeout) Error() string

+ type DataConnectionStatusBadRequest struct

+ Payload *DataConnectionStatusBadRequestBody

+ func NewDataConnectionStatusBadRequest() *DataConnectionStatusBadRequest

+ func (o *DataConnectionStatusBadRequest) Error() string

+ type DataConnectionStatusBadRequestBody struct

+ CommandType *string

+ Params *DataConnectionStatusBadRequestBodyParams

+ func (o *DataConnectionStatusBadRequestBody) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionStatusBadRequestBody) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionStatusBadRequestBody) Validate(formats strfmt.Registry) error

+ type DataConnectionStatusBadRequestBodyParams struct

+ Errors []*DataConnectionStatusBadRequestBodyParamsErrorsItems0

+ func (o *DataConnectionStatusBadRequestBodyParams) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionStatusBadRequestBodyParams) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionStatusBadRequestBodyParams) Validate(formats strfmt.Registry) error

+ type DataConnectionStatusBadRequestBodyParamsErrorsItems0 struct

+ Field string

+ Message string

+ func (o *DataConnectionStatusBadRequestBodyParamsErrorsItems0) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionStatusBadRequestBodyParamsErrorsItems0) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionStatusBadRequestBodyParamsErrorsItems0) Validate(formats strfmt.Registry) error

+ type DataConnectionStatusForbidden struct

+ func NewDataConnectionStatusForbidden() *DataConnectionStatusForbidden

+ func (o *DataConnectionStatusForbidden) Error() string

+ type DataConnectionStatusMethodNotAllowed struct

+ func NewDataConnectionStatusMethodNotAllowed() *DataConnectionStatusMethodNotAllowed

+ func (o *DataConnectionStatusMethodNotAllowed) Error() string

+ type DataConnectionStatusNotAcceptable struct

+ func NewDataConnectionStatusNotAcceptable() *DataConnectionStatusNotAcceptable

+ func (o *DataConnectionStatusNotAcceptable) Error() string

+ type DataConnectionStatusNotFound struct

+ func NewDataConnectionStatusNotFound() *DataConnectionStatusNotFound

+ func (o *DataConnectionStatusNotFound) Error() string

+ type DataConnectionStatusOK struct

+ Payload *models.DataConnectionStatusMessage

+ func NewDataConnectionStatusOK() *DataConnectionStatusOK

+ func (o *DataConnectionStatusOK) Error() string

+ type DataConnectionStatusParams struct

+ Context context.Context

+ DataConnectionID string

+ HTTPClient *http.Client

+ func NewDataConnectionStatusParams() *DataConnectionStatusParams

+ func NewDataConnectionStatusParamsWithContext(ctx context.Context) *DataConnectionStatusParams

+ func NewDataConnectionStatusParamsWithHTTPClient(client *http.Client) *DataConnectionStatusParams

+ func NewDataConnectionStatusParamsWithTimeout(timeout time.Duration) *DataConnectionStatusParams

+ func (o *DataConnectionStatusParams) SetContext(ctx context.Context)

+ func (o *DataConnectionStatusParams) SetDataConnectionID(dataConnectionID string)

+ func (o *DataConnectionStatusParams) SetHTTPClient(client *http.Client)

+ func (o *DataConnectionStatusParams) SetTimeout(timeout time.Duration)

+ func (o *DataConnectionStatusParams) WithContext(ctx context.Context) *DataConnectionStatusParams

+ func (o *DataConnectionStatusParams) WithDataConnectionID(dataConnectionID string) *DataConnectionStatusParams

+ func (o *DataConnectionStatusParams) WithHTTPClient(client *http.Client) *DataConnectionStatusParams

+ func (o *DataConnectionStatusParams) WithTimeout(timeout time.Duration) *DataConnectionStatusParams

+ func (o *DataConnectionStatusParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DataConnectionStatusReader struct

+ func (o *DataConnectionStatusReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DataConnectionStatusRequestTimeout struct

+ func NewDataConnectionStatusRequestTimeout() *DataConnectionStatusRequestTimeout

+ func (o *DataConnectionStatusRequestTimeout) Error() string

+ type DataConnectionsCreateAccepted struct

+ Payload *models.PeerConnectResponse

+ func NewDataConnectionsCreateAccepted() *DataConnectionsCreateAccepted

+ func (o *DataConnectionsCreateAccepted) Error() string

+ type DataConnectionsCreateBadRequest struct

+ Payload *DataConnectionsCreateBadRequestBody

+ func NewDataConnectionsCreateBadRequest() *DataConnectionsCreateBadRequest

+ func (o *DataConnectionsCreateBadRequest) Error() string

+ type DataConnectionsCreateBadRequestBody struct

+ CommandType *string

+ Params *DataConnectionsCreateBadRequestBodyParams

+ func (o *DataConnectionsCreateBadRequestBody) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionsCreateBadRequestBody) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionsCreateBadRequestBody) Validate(formats strfmt.Registry) error

+ type DataConnectionsCreateBadRequestBodyParams struct

+ Errors []*DataConnectionsCreateBadRequestBodyParamsErrorsItems0

+ func (o *DataConnectionsCreateBadRequestBodyParams) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionsCreateBadRequestBodyParams) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionsCreateBadRequestBodyParams) Validate(formats strfmt.Registry) error

+ type DataConnectionsCreateBadRequestBodyParamsErrorsItems0 struct

+ Field string

+ Message string

+ func (o *DataConnectionsCreateBadRequestBodyParamsErrorsItems0) MarshalBinary() ([]byte, error)

+ func (o *DataConnectionsCreateBadRequestBodyParamsErrorsItems0) UnmarshalBinary(b []byte) error

+ func (o *DataConnectionsCreateBadRequestBodyParamsErrorsItems0) Validate(formats strfmt.Registry) error

+ type DataConnectionsCreateForbidden struct

+ func NewDataConnectionsCreateForbidden() *DataConnectionsCreateForbidden

+ func (o *DataConnectionsCreateForbidden) Error() string

+ type DataConnectionsCreateMethodNotAllowed struct

+ func NewDataConnectionsCreateMethodNotAllowed() *DataConnectionsCreateMethodNotAllowed

+ func (o *DataConnectionsCreateMethodNotAllowed) Error() string

+ type DataConnectionsCreateNotAcceptable struct

+ func NewDataConnectionsCreateNotAcceptable() *DataConnectionsCreateNotAcceptable

+ func (o *DataConnectionsCreateNotAcceptable) Error() string

+ type DataConnectionsCreateNotFound struct

+ func NewDataConnectionsCreateNotFound() *DataConnectionsCreateNotFound

+ func (o *DataConnectionsCreateNotFound) Error() string

+ type DataConnectionsCreateParams struct

+ Body *models.PeerConnectOptions

+ Context context.Context

+ HTTPClient *http.Client

+ func NewDataConnectionsCreateParams() *DataConnectionsCreateParams

+ func NewDataConnectionsCreateParamsWithContext(ctx context.Context) *DataConnectionsCreateParams

+ func NewDataConnectionsCreateParamsWithHTTPClient(client *http.Client) *DataConnectionsCreateParams

+ func NewDataConnectionsCreateParamsWithTimeout(timeout time.Duration) *DataConnectionsCreateParams

+ func (o *DataConnectionsCreateParams) SetBody(body *models.PeerConnectOptions)

+ func (o *DataConnectionsCreateParams) SetContext(ctx context.Context)

+ func (o *DataConnectionsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DataConnectionsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DataConnectionsCreateParams) WithBody(body *models.PeerConnectOptions) *DataConnectionsCreateParams

+ func (o *DataConnectionsCreateParams) WithContext(ctx context.Context) *DataConnectionsCreateParams

+ func (o *DataConnectionsCreateParams) WithHTTPClient(client *http.Client) *DataConnectionsCreateParams

+ func (o *DataConnectionsCreateParams) WithTimeout(timeout time.Duration) *DataConnectionsCreateParams

+ func (o *DataConnectionsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DataConnectionsCreateReader struct

+ func (o *DataConnectionsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DataConnectionsCreateRequestTimeout struct

+ func NewDataConnectionsCreateRequestTimeout() *DataConnectionsCreateRequestTimeout

+ func (o *DataConnectionsCreateRequestTimeout) Error() string

+ type DataCreated struct

+ Payload *models.DataSockParameters

+ func NewDataCreated() *DataCreated

+ func (o *DataCreated) Error() string

+ type DataDeleteBadRequest struct

+ Payload *DataDeleteBadRequestBody

+ func NewDataDeleteBadRequest() *DataDeleteBadRequest

+ func (o *DataDeleteBadRequest) Error() string

+ type DataDeleteBadRequestBody struct

+ CommandType *string

+ Params *DataDeleteBadRequestBodyParams

+ func (o *DataDeleteBadRequestBody) MarshalBinary() ([]byte, error)

+ func (o *DataDeleteBadRequestBody) UnmarshalBinary(b []byte) error

+ func (o *DataDeleteBadRequestBody) Validate(formats strfmt.Registry) error

+ type DataDeleteBadRequestBodyParams struct

+ Errors []*DataDeleteBadRequestBodyParamsErrorsItems0

+ func (o *DataDeleteBadRequestBodyParams) MarshalBinary() ([]byte, error)

+ func (o *DataDeleteBadRequestBodyParams) UnmarshalBinary(b []byte) error

+ func (o *DataDeleteBadRequestBodyParams) Validate(formats strfmt.Registry) error

+ type DataDeleteBadRequestBodyParamsErrorsItems0 struct

+ Field string

+ Message string

+ func (o *DataDeleteBadRequestBodyParamsErrorsItems0) MarshalBinary() ([]byte, error)

+ func (o *DataDeleteBadRequestBodyParamsErrorsItems0) UnmarshalBinary(b []byte) error

+ func (o *DataDeleteBadRequestBodyParamsErrorsItems0) Validate(formats strfmt.Registry) error

+ type DataDeleteForbidden struct

+ func NewDataDeleteForbidden() *DataDeleteForbidden

+ func (o *DataDeleteForbidden) Error() string

+ type DataDeleteMethodNotAllowed struct

+ func NewDataDeleteMethodNotAllowed() *DataDeleteMethodNotAllowed

+ func (o *DataDeleteMethodNotAllowed) Error() string

+ type DataDeleteNoContent struct

+ func NewDataDeleteNoContent() *DataDeleteNoContent

+ func (o *DataDeleteNoContent) Error() string

+ type DataDeleteNotAcceptable struct

+ func NewDataDeleteNotAcceptable() *DataDeleteNotAcceptable

+ func (o *DataDeleteNotAcceptable) Error() string

+ type DataDeleteNotFound struct

+ func NewDataDeleteNotFound() *DataDeleteNotFound

+ func (o *DataDeleteNotFound) Error() string

+ type DataDeleteParams struct

+ Context context.Context

+ DataID string

+ HTTPClient *http.Client

+ func NewDataDeleteParams() *DataDeleteParams

+ func NewDataDeleteParamsWithContext(ctx context.Context) *DataDeleteParams

+ func NewDataDeleteParamsWithHTTPClient(client *http.Client) *DataDeleteParams

+ func NewDataDeleteParamsWithTimeout(timeout time.Duration) *DataDeleteParams

+ func (o *DataDeleteParams) SetContext(ctx context.Context)

+ func (o *DataDeleteParams) SetDataID(dataID string)

+ func (o *DataDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DataDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DataDeleteParams) WithContext(ctx context.Context) *DataDeleteParams

+ func (o *DataDeleteParams) WithDataID(dataID string) *DataDeleteParams

+ func (o *DataDeleteParams) WithHTTPClient(client *http.Client) *DataDeleteParams

+ func (o *DataDeleteParams) WithTimeout(timeout time.Duration) *DataDeleteParams

+ func (o *DataDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DataDeleteReader struct

+ func (o *DataDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DataDeleteRequestTimeout struct

+ func NewDataDeleteRequestTimeout() *DataDeleteRequestTimeout

+ func (o *DataDeleteRequestTimeout) Error() string

+ type DataMethodNotAllowed struct

+ func NewDataMethodNotAllowed() *DataMethodNotAllowed

+ func (o *DataMethodNotAllowed) Error() string

+ type DataNotAcceptable struct

+ func NewDataNotAcceptable() *DataNotAcceptable

+ func (o *DataNotAcceptable) Error() string

+ type DataParams struct

+ Body interface{}

+ Context context.Context

+ HTTPClient *http.Client

+ func NewDataParams() *DataParams

+ func NewDataParamsWithContext(ctx context.Context) *DataParams

+ func NewDataParamsWithHTTPClient(client *http.Client) *DataParams

+ func NewDataParamsWithTimeout(timeout time.Duration) *DataParams

+ func (o *DataParams) SetBody(body interface{})

+ func (o *DataParams) SetContext(ctx context.Context)

+ func (o *DataParams) SetHTTPClient(client *http.Client)

+ func (o *DataParams) SetTimeout(timeout time.Duration)

+ func (o *DataParams) WithBody(body interface{}) *DataParams

+ func (o *DataParams) WithContext(ctx context.Context) *DataParams

+ func (o *DataParams) WithHTTPClient(client *http.Client) *DataParams

+ func (o *DataParams) WithTimeout(timeout time.Duration) *DataParams

+ func (o *DataParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DataReader struct

+ func (o *DataReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DataRequestTimeout struct

+ func NewDataRequestTimeout() *DataRequestTimeout

+ func (o *DataRequestTimeout) Error() string