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

extras

package

Go to main page

Versions in this module

v0

v0.25.2

Dec 27, 2020

v0.25.1

Dec 27, 2020

v0.25.0

Dec 27, 2020

Changes in this version

+ type Client struct

+ func (a *Client) ExtrasApprovallistsCreate(params *ExtrasApprovallistsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsCreateCreated, error)

+ func (a *Client) ExtrasApprovallistsDelete(params *ExtrasApprovallistsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsDeleteNoContent, error)

+ func (a *Client) ExtrasApprovallistsList(params *ExtrasApprovallistsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsListOK, error)

+ func (a *Client) ExtrasApprovallistsPartialUpdate(params *ExtrasApprovallistsPartialUpdateParams, ...) (*ExtrasApprovallistsPartialUpdateOK, error)

+ func (a *Client) ExtrasApprovallistsRead(params *ExtrasApprovallistsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsReadOK, error)

+ func (a *Client) ExtrasApprovallistsUpdate(params *ExtrasApprovallistsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsUpdateOK, error)

+ func (a *Client) ExtrasChoicesList(params *ExtrasChoicesListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasChoicesListOK, error)

+ func (a *Client) ExtrasChoicesRead(params *ExtrasChoicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasChoicesReadOK, error)

+ func (a *Client) ExtrasConfigContextsCreate(params *ExtrasConfigContextsCreateParams, ...) (*ExtrasConfigContextsCreateCreated, error)

+ func (a *Client) ExtrasConfigContextsDelete(params *ExtrasConfigContextsDeleteParams, ...) (*ExtrasConfigContextsDeleteNoContent, error)

+ func (a *Client) ExtrasConfigContextsList(params *ExtrasConfigContextsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasConfigContextsListOK, error)

+ func (a *Client) ExtrasConfigContextsPartialUpdate(params *ExtrasConfigContextsPartialUpdateParams, ...) (*ExtrasConfigContextsPartialUpdateOK, error)

+ func (a *Client) ExtrasConfigContextsRead(params *ExtrasConfigContextsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasConfigContextsReadOK, error)

+ func (a *Client) ExtrasConfigContextsUpdate(params *ExtrasConfigContextsUpdateParams, ...) (*ExtrasConfigContextsUpdateOK, error)

+ func (a *Client) ExtrasExportTemplatesCreate(params *ExtrasExportTemplatesCreateParams, ...) (*ExtrasExportTemplatesCreateCreated, error)

+ func (a *Client) ExtrasExportTemplatesDelete(params *ExtrasExportTemplatesDeleteParams, ...) (*ExtrasExportTemplatesDeleteNoContent, error)

+ func (a *Client) ExtrasExportTemplatesList(params *ExtrasExportTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasExportTemplatesListOK, error)

+ func (a *Client) ExtrasExportTemplatesPartialUpdate(params *ExtrasExportTemplatesPartialUpdateParams, ...) (*ExtrasExportTemplatesPartialUpdateOK, error)

+ func (a *Client) ExtrasExportTemplatesRead(params *ExtrasExportTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasExportTemplatesReadOK, error)

+ func (a *Client) ExtrasExportTemplatesUpdate(params *ExtrasExportTemplatesUpdateParams, ...) (*ExtrasExportTemplatesUpdateOK, error)

+ func (a *Client) ExtrasGraphsCreate(params *ExtrasGraphsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsCreateCreated, error)

+ func (a *Client) ExtrasGraphsDelete(params *ExtrasGraphsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsDeleteNoContent, error)

+ func (a *Client) ExtrasGraphsList(params *ExtrasGraphsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsListOK, error)

+ func (a *Client) ExtrasGraphsPartialUpdate(params *ExtrasGraphsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsPartialUpdateOK, error)

+ func (a *Client) ExtrasGraphsRead(params *ExtrasGraphsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsReadOK, error)

+ func (a *Client) ExtrasGraphsUpdate(params *ExtrasGraphsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsUpdateOK, error)

+ func (a *Client) ExtrasImageAttachmentsCreate(params *ExtrasImageAttachmentsCreateParams, ...) (*ExtrasImageAttachmentsCreateCreated, error)

+ func (a *Client) ExtrasImageAttachmentsDelete(params *ExtrasImageAttachmentsDeleteParams, ...) (*ExtrasImageAttachmentsDeleteNoContent, error)

+ func (a *Client) ExtrasImageAttachmentsList(params *ExtrasImageAttachmentsListParams, ...) (*ExtrasImageAttachmentsListOK, error)

+ func (a *Client) ExtrasImageAttachmentsPartialUpdate(params *ExtrasImageAttachmentsPartialUpdateParams, ...) (*ExtrasImageAttachmentsPartialUpdateOK, error)

+ func (a *Client) ExtrasImageAttachmentsRead(params *ExtrasImageAttachmentsReadParams, ...) (*ExtrasImageAttachmentsReadOK, error)

+ func (a *Client) ExtrasImageAttachmentsUpdate(params *ExtrasImageAttachmentsUpdateParams, ...) (*ExtrasImageAttachmentsUpdateOK, error)

+ func (a *Client) ExtrasObjectChangesList(params *ExtrasObjectChangesListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasObjectChangesListOK, error)

+ func (a *Client) ExtrasObjectChangesRead(params *ExtrasObjectChangesReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasObjectChangesReadOK, error)

+ func (a *Client) ExtrasReportsList(params *ExtrasReportsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasReportsListOK, error)

+ func (a *Client) ExtrasReportsRead(params *ExtrasReportsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasReportsReadOK, error)

+ func (a *Client) ExtrasReportsRun(params *ExtrasReportsRunParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasReportsRunCreated, error)

+ func (a *Client) ExtrasTagsCreate(params *ExtrasTagsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsCreateCreated, error)

+ func (a *Client) ExtrasTagsDelete(params *ExtrasTagsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsDeleteNoContent, error)

+ func (a *Client) ExtrasTagsList(params *ExtrasTagsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsListOK, error)

+ func (a *Client) ExtrasTagsPartialUpdate(params *ExtrasTagsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsPartialUpdateOK, error)

+ func (a *Client) ExtrasTagsRead(params *ExtrasTagsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsReadOK, error)

+ func (a *Client) ExtrasTagsUpdate(params *ExtrasTagsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsUpdateOK, error)

+ func (a *Client) ExtrasTopologyMapsCreate(params *ExtrasTopologyMapsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsCreateCreated, error)

+ func (a *Client) ExtrasTopologyMapsDelete(params *ExtrasTopologyMapsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsDeleteNoContent, error)

+ func (a *Client) ExtrasTopologyMapsList(params *ExtrasTopologyMapsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsListOK, error)

+ func (a *Client) ExtrasTopologyMapsPartialUpdate(params *ExtrasTopologyMapsPartialUpdateParams, ...) (*ExtrasTopologyMapsPartialUpdateOK, error)

+ func (a *Client) ExtrasTopologyMapsRead(params *ExtrasTopologyMapsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsReadOK, error)

+ func (a *Client) ExtrasTopologyMapsRender(params *ExtrasTopologyMapsRenderParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsRenderOK, error)

+ func (a *Client) ExtrasTopologyMapsUpdate(params *ExtrasTopologyMapsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsUpdateOK, error)

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

+ type ClientService interface

+ ExtrasApprovallistsCreate func(params *ExtrasApprovallistsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsCreateCreated, error)

+ ExtrasApprovallistsDelete func(params *ExtrasApprovallistsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsDeleteNoContent, error)

+ ExtrasApprovallistsList func(params *ExtrasApprovallistsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsListOK, error)

+ ExtrasApprovallistsPartialUpdate func(params *ExtrasApprovallistsPartialUpdateParams, ...) (*ExtrasApprovallistsPartialUpdateOK, error)

+ ExtrasApprovallistsRead func(params *ExtrasApprovallistsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsReadOK, error)

+ ExtrasApprovallistsUpdate func(params *ExtrasApprovallistsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasApprovallistsUpdateOK, error)

+ ExtrasChoicesList func(params *ExtrasChoicesListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasChoicesListOK, error)

+ ExtrasChoicesRead func(params *ExtrasChoicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasChoicesReadOK, error)

+ ExtrasConfigContextsCreate func(params *ExtrasConfigContextsCreateParams, ...) (*ExtrasConfigContextsCreateCreated, error)

+ ExtrasConfigContextsDelete func(params *ExtrasConfigContextsDeleteParams, ...) (*ExtrasConfigContextsDeleteNoContent, error)

+ ExtrasConfigContextsList func(params *ExtrasConfigContextsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasConfigContextsListOK, error)

+ ExtrasConfigContextsPartialUpdate func(params *ExtrasConfigContextsPartialUpdateParams, ...) (*ExtrasConfigContextsPartialUpdateOK, error)

+ ExtrasConfigContextsRead func(params *ExtrasConfigContextsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasConfigContextsReadOK, error)

+ ExtrasConfigContextsUpdate func(params *ExtrasConfigContextsUpdateParams, ...) (*ExtrasConfigContextsUpdateOK, error)

+ ExtrasExportTemplatesCreate func(params *ExtrasExportTemplatesCreateParams, ...) (*ExtrasExportTemplatesCreateCreated, error)

+ ExtrasExportTemplatesDelete func(params *ExtrasExportTemplatesDeleteParams, ...) (*ExtrasExportTemplatesDeleteNoContent, error)

+ ExtrasExportTemplatesList func(params *ExtrasExportTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasExportTemplatesListOK, error)

+ ExtrasExportTemplatesPartialUpdate func(params *ExtrasExportTemplatesPartialUpdateParams, ...) (*ExtrasExportTemplatesPartialUpdateOK, error)

+ ExtrasExportTemplatesRead func(params *ExtrasExportTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasExportTemplatesReadOK, error)

+ ExtrasExportTemplatesUpdate func(params *ExtrasExportTemplatesUpdateParams, ...) (*ExtrasExportTemplatesUpdateOK, error)

+ ExtrasGraphsCreate func(params *ExtrasGraphsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsCreateCreated, error)

+ ExtrasGraphsDelete func(params *ExtrasGraphsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsDeleteNoContent, error)

+ ExtrasGraphsList func(params *ExtrasGraphsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsListOK, error)

+ ExtrasGraphsPartialUpdate func(params *ExtrasGraphsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsPartialUpdateOK, error)

+ ExtrasGraphsRead func(params *ExtrasGraphsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsReadOK, error)

+ ExtrasGraphsUpdate func(params *ExtrasGraphsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasGraphsUpdateOK, error)

+ ExtrasImageAttachmentsCreate func(params *ExtrasImageAttachmentsCreateParams, ...) (*ExtrasImageAttachmentsCreateCreated, error)

+ ExtrasImageAttachmentsDelete func(params *ExtrasImageAttachmentsDeleteParams, ...) (*ExtrasImageAttachmentsDeleteNoContent, error)

+ ExtrasImageAttachmentsList func(params *ExtrasImageAttachmentsListParams, ...) (*ExtrasImageAttachmentsListOK, error)

+ ExtrasImageAttachmentsPartialUpdate func(params *ExtrasImageAttachmentsPartialUpdateParams, ...) (*ExtrasImageAttachmentsPartialUpdateOK, error)

+ ExtrasImageAttachmentsRead func(params *ExtrasImageAttachmentsReadParams, ...) (*ExtrasImageAttachmentsReadOK, error)

+ ExtrasImageAttachmentsUpdate func(params *ExtrasImageAttachmentsUpdateParams, ...) (*ExtrasImageAttachmentsUpdateOK, error)

+ ExtrasObjectChangesList func(params *ExtrasObjectChangesListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasObjectChangesListOK, error)

+ ExtrasObjectChangesRead func(params *ExtrasObjectChangesReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasObjectChangesReadOK, error)

+ ExtrasReportsList func(params *ExtrasReportsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasReportsListOK, error)

+ ExtrasReportsRead func(params *ExtrasReportsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasReportsReadOK, error)

+ ExtrasReportsRun func(params *ExtrasReportsRunParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasReportsRunCreated, error)

+ ExtrasTagsCreate func(params *ExtrasTagsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsCreateCreated, error)

+ ExtrasTagsDelete func(params *ExtrasTagsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsDeleteNoContent, error)

+ ExtrasTagsList func(params *ExtrasTagsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsListOK, error)

+ ExtrasTagsPartialUpdate func(params *ExtrasTagsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsPartialUpdateOK, error)

+ ExtrasTagsRead func(params *ExtrasTagsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsReadOK, error)

+ ExtrasTagsUpdate func(params *ExtrasTagsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTagsUpdateOK, error)

+ ExtrasTopologyMapsCreate func(params *ExtrasTopologyMapsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsCreateCreated, error)

+ ExtrasTopologyMapsDelete func(params *ExtrasTopologyMapsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsDeleteNoContent, error)

+ ExtrasTopologyMapsList func(params *ExtrasTopologyMapsListParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsListOK, error)

+ ExtrasTopologyMapsPartialUpdate func(params *ExtrasTopologyMapsPartialUpdateParams, ...) (*ExtrasTopologyMapsPartialUpdateOK, error)

+ ExtrasTopologyMapsRead func(params *ExtrasTopologyMapsReadParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsReadOK, error)

+ ExtrasTopologyMapsRender func(params *ExtrasTopologyMapsRenderParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsRenderOK, error)

+ ExtrasTopologyMapsUpdate func(params *ExtrasTopologyMapsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*ExtrasTopologyMapsUpdateOK, error)

+ SetTransport func(transport runtime.ClientTransport)

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

+ type ExtrasApprovallistsCreateCreated struct

+ Payload *models.ApprovalList

+ func NewExtrasApprovallistsCreateCreated() *ExtrasApprovallistsCreateCreated

+ func (o *ExtrasApprovallistsCreateCreated) Error() string

+ func (o *ExtrasApprovallistsCreateCreated) GetPayload() *models.ApprovalList

+ type ExtrasApprovallistsCreateParams struct

+ Context context.Context

+ Data *models.ApprovalList

+ HTTPClient *http.Client

+ func NewExtrasApprovallistsCreateParams() *ExtrasApprovallistsCreateParams

+ func NewExtrasApprovallistsCreateParamsWithContext(ctx context.Context) *ExtrasApprovallistsCreateParams

+ func NewExtrasApprovallistsCreateParamsWithHTTPClient(client *http.Client) *ExtrasApprovallistsCreateParams

+ func NewExtrasApprovallistsCreateParamsWithTimeout(timeout time.Duration) *ExtrasApprovallistsCreateParams

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

+ func (o *ExtrasApprovallistsCreateParams) SetData(data *models.ApprovalList)

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

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

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

+ func (o *ExtrasApprovallistsCreateParams) WithData(data *models.ApprovalList) *ExtrasApprovallistsCreateParams

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

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

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

+ type ExtrasApprovallistsCreateReader struct

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

+ type ExtrasApprovallistsDeleteNoContent struct

+ func NewExtrasApprovallistsDeleteNoContent() *ExtrasApprovallistsDeleteNoContent

+ func (o *ExtrasApprovallistsDeleteNoContent) Error() string

+ type ExtrasApprovallistsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasApprovallistsDeleteParams() *ExtrasApprovallistsDeleteParams

+ func NewExtrasApprovallistsDeleteParamsWithContext(ctx context.Context) *ExtrasApprovallistsDeleteParams

+ func NewExtrasApprovallistsDeleteParamsWithHTTPClient(client *http.Client) *ExtrasApprovallistsDeleteParams

+ func NewExtrasApprovallistsDeleteParamsWithTimeout(timeout time.Duration) *ExtrasApprovallistsDeleteParams

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

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

+ func (o *ExtrasApprovallistsDeleteParams) SetID(id int64)

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

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

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

+ func (o *ExtrasApprovallistsDeleteParams) WithID(id int64) *ExtrasApprovallistsDeleteParams

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

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

+ type ExtrasApprovallistsDeleteReader struct

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

+ type ExtrasApprovallistsListOK struct

+ Payload *ExtrasApprovallistsListOKBody

+ func NewExtrasApprovallistsListOK() *ExtrasApprovallistsListOK

+ func (o *ExtrasApprovallistsListOK) Error() string

+ func (o *ExtrasApprovallistsListOK) GetPayload() *ExtrasApprovallistsListOKBody

+ type ExtrasApprovallistsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ApprovalList

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

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

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

+ type ExtrasApprovallistsListParams struct

+ Applicant *string

+ Approver *string

+ Context context.Context

+ CreatedTime *string

+ FailedReason *string

+ HTTPClient *http.Client

+ IDIn *string

+ Limit *int64

+ Offset *int64

+ Q *string

+ Raw *string

+ Servicename *string

+ Status *string

+ UUID *string

+ func NewExtrasApprovallistsListParams() *ExtrasApprovallistsListParams

+ func NewExtrasApprovallistsListParamsWithContext(ctx context.Context) *ExtrasApprovallistsListParams

+ func NewExtrasApprovallistsListParamsWithHTTPClient(client *http.Client) *ExtrasApprovallistsListParams

+ func NewExtrasApprovallistsListParamsWithTimeout(timeout time.Duration) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) SetApplicant(applicant *string)

+ func (o *ExtrasApprovallistsListParams) SetApprover(approver *string)

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

+ func (o *ExtrasApprovallistsListParams) SetCreatedTime(createdTime *string)

+ func (o *ExtrasApprovallistsListParams) SetFailedReason(failedReason *string)

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

+ func (o *ExtrasApprovallistsListParams) SetIDIn(iDIn *string)

+ func (o *ExtrasApprovallistsListParams) SetLimit(limit *int64)

+ func (o *ExtrasApprovallistsListParams) SetOffset(offset *int64)

+ func (o *ExtrasApprovallistsListParams) SetQ(q *string)

+ func (o *ExtrasApprovallistsListParams) SetRaw(raw *string)

+ func (o *ExtrasApprovallistsListParams) SetServicename(servicename *string)

+ func (o *ExtrasApprovallistsListParams) SetStatus(status *string)

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

+ func (o *ExtrasApprovallistsListParams) SetUUID(uuid *string)

+ func (o *ExtrasApprovallistsListParams) WithApplicant(applicant *string) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithApprover(approver *string) *ExtrasApprovallistsListParams

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

+ func (o *ExtrasApprovallistsListParams) WithCreatedTime(createdTime *string) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithFailedReason(failedReason *string) *ExtrasApprovallistsListParams

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

+ func (o *ExtrasApprovallistsListParams) WithIDIn(iDIn *string) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithLimit(limit *int64) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithOffset(offset *int64) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithQ(q *string) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithRaw(raw *string) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithServicename(servicename *string) *ExtrasApprovallistsListParams

+ func (o *ExtrasApprovallistsListParams) WithStatus(status *string) *ExtrasApprovallistsListParams

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

+ func (o *ExtrasApprovallistsListParams) WithUUID(uuid *string) *ExtrasApprovallistsListParams

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

+ type ExtrasApprovallistsListReader struct

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

+ type ExtrasApprovallistsPartialUpdateOK struct

+ Payload *models.ApprovalList

+ func NewExtrasApprovallistsPartialUpdateOK() *ExtrasApprovallistsPartialUpdateOK

+ func (o *ExtrasApprovallistsPartialUpdateOK) Error() string

+ func (o *ExtrasApprovallistsPartialUpdateOK) GetPayload() *models.ApprovalList

+ type ExtrasApprovallistsPartialUpdateParams struct

+ Context context.Context

+ Data *models.ApprovalList

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasApprovallistsPartialUpdateParams() *ExtrasApprovallistsPartialUpdateParams

+ func NewExtrasApprovallistsPartialUpdateParamsWithContext(ctx context.Context) *ExtrasApprovallistsPartialUpdateParams

+ func NewExtrasApprovallistsPartialUpdateParamsWithHTTPClient(client *http.Client) *ExtrasApprovallistsPartialUpdateParams

+ func NewExtrasApprovallistsPartialUpdateParamsWithTimeout(timeout time.Duration) *ExtrasApprovallistsPartialUpdateParams

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

+ func (o *ExtrasApprovallistsPartialUpdateParams) SetData(data *models.ApprovalList)

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

+ func (o *ExtrasApprovallistsPartialUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasApprovallistsPartialUpdateParams) WithData(data *models.ApprovalList) *ExtrasApprovallistsPartialUpdateParams

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

+ func (o *ExtrasApprovallistsPartialUpdateParams) WithID(id int64) *ExtrasApprovallistsPartialUpdateParams

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

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

+ type ExtrasApprovallistsPartialUpdateReader struct

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

+ type ExtrasApprovallistsReadOK struct

+ Payload *models.ApprovalList

+ func NewExtrasApprovallistsReadOK() *ExtrasApprovallistsReadOK

+ func (o *ExtrasApprovallistsReadOK) Error() string

+ func (o *ExtrasApprovallistsReadOK) GetPayload() *models.ApprovalList

+ type ExtrasApprovallistsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasApprovallistsReadParams() *ExtrasApprovallistsReadParams

+ func NewExtrasApprovallistsReadParamsWithContext(ctx context.Context) *ExtrasApprovallistsReadParams

+ func NewExtrasApprovallistsReadParamsWithHTTPClient(client *http.Client) *ExtrasApprovallistsReadParams

+ func NewExtrasApprovallistsReadParamsWithTimeout(timeout time.Duration) *ExtrasApprovallistsReadParams

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

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

+ func (o *ExtrasApprovallistsReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasApprovallistsReadParams) WithID(id int64) *ExtrasApprovallistsReadParams

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

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

+ type ExtrasApprovallistsReadReader struct

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

+ type ExtrasApprovallistsUpdateOK struct

+ Payload *models.ApprovalList

+ func NewExtrasApprovallistsUpdateOK() *ExtrasApprovallistsUpdateOK

+ func (o *ExtrasApprovallistsUpdateOK) Error() string

+ func (o *ExtrasApprovallistsUpdateOK) GetPayload() *models.ApprovalList

+ type ExtrasApprovallistsUpdateParams struct

+ Context context.Context

+ Data *models.ApprovalList

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasApprovallistsUpdateParams() *ExtrasApprovallistsUpdateParams

+ func NewExtrasApprovallistsUpdateParamsWithContext(ctx context.Context) *ExtrasApprovallistsUpdateParams

+ func NewExtrasApprovallistsUpdateParamsWithHTTPClient(client *http.Client) *ExtrasApprovallistsUpdateParams

+ func NewExtrasApprovallistsUpdateParamsWithTimeout(timeout time.Duration) *ExtrasApprovallistsUpdateParams

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

+ func (o *ExtrasApprovallistsUpdateParams) SetData(data *models.ApprovalList)

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

+ func (o *ExtrasApprovallistsUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasApprovallistsUpdateParams) WithData(data *models.ApprovalList) *ExtrasApprovallistsUpdateParams

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

+ func (o *ExtrasApprovallistsUpdateParams) WithID(id int64) *ExtrasApprovallistsUpdateParams

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

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

+ type ExtrasApprovallistsUpdateReader struct

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

+ type ExtrasChoicesListOK struct

+ func NewExtrasChoicesListOK() *ExtrasChoicesListOK

+ func (o *ExtrasChoicesListOK) Error() string

+ type ExtrasChoicesListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ func NewExtrasChoicesListParams() *ExtrasChoicesListParams

+ func NewExtrasChoicesListParamsWithContext(ctx context.Context) *ExtrasChoicesListParams

+ func NewExtrasChoicesListParamsWithHTTPClient(client *http.Client) *ExtrasChoicesListParams

+ func NewExtrasChoicesListParamsWithTimeout(timeout time.Duration) *ExtrasChoicesListParams

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

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

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

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

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

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

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

+ type ExtrasChoicesListReader struct

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

+ type ExtrasChoicesReadOK struct

+ func NewExtrasChoicesReadOK() *ExtrasChoicesReadOK

+ func (o *ExtrasChoicesReadOK) Error() string

+ type ExtrasChoicesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID string

+ func NewExtrasChoicesReadParams() *ExtrasChoicesReadParams

+ func NewExtrasChoicesReadParamsWithContext(ctx context.Context) *ExtrasChoicesReadParams

+ func NewExtrasChoicesReadParamsWithHTTPClient(client *http.Client) *ExtrasChoicesReadParams

+ func NewExtrasChoicesReadParamsWithTimeout(timeout time.Duration) *ExtrasChoicesReadParams

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

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

+ func (o *ExtrasChoicesReadParams) SetID(id string)

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

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

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

+ func (o *ExtrasChoicesReadParams) WithID(id string) *ExtrasChoicesReadParams

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

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

+ type ExtrasChoicesReadReader struct

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

+ type ExtrasConfigContextsCreateCreated struct

+ Payload *models.ConfigContext

+ func NewExtrasConfigContextsCreateCreated() *ExtrasConfigContextsCreateCreated

+ func (o *ExtrasConfigContextsCreateCreated) Error() string

+ func (o *ExtrasConfigContextsCreateCreated) GetPayload() *models.ConfigContext

+ type ExtrasConfigContextsCreateParams struct

+ Context context.Context

+ Data *models.WritableConfigContext

+ HTTPClient *http.Client

+ func NewExtrasConfigContextsCreateParams() *ExtrasConfigContextsCreateParams

+ func NewExtrasConfigContextsCreateParamsWithContext(ctx context.Context) *ExtrasConfigContextsCreateParams

+ func NewExtrasConfigContextsCreateParamsWithHTTPClient(client *http.Client) *ExtrasConfigContextsCreateParams

+ func NewExtrasConfigContextsCreateParamsWithTimeout(timeout time.Duration) *ExtrasConfigContextsCreateParams

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

+ func (o *ExtrasConfigContextsCreateParams) SetData(data *models.WritableConfigContext)

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

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

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

+ func (o *ExtrasConfigContextsCreateParams) WithData(data *models.WritableConfigContext) *ExtrasConfigContextsCreateParams

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

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

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

+ type ExtrasConfigContextsCreateReader struct

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

+ type ExtrasConfigContextsDeleteNoContent struct

+ func NewExtrasConfigContextsDeleteNoContent() *ExtrasConfigContextsDeleteNoContent

+ func (o *ExtrasConfigContextsDeleteNoContent) Error() string

+ type ExtrasConfigContextsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasConfigContextsDeleteParams() *ExtrasConfigContextsDeleteParams

+ func NewExtrasConfigContextsDeleteParamsWithContext(ctx context.Context) *ExtrasConfigContextsDeleteParams

+ func NewExtrasConfigContextsDeleteParamsWithHTTPClient(client *http.Client) *ExtrasConfigContextsDeleteParams

+ func NewExtrasConfigContextsDeleteParamsWithTimeout(timeout time.Duration) *ExtrasConfigContextsDeleteParams

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

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

+ func (o *ExtrasConfigContextsDeleteParams) SetID(id int64)

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

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

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

+ func (o *ExtrasConfigContextsDeleteParams) WithID(id int64) *ExtrasConfigContextsDeleteParams

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

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

+ type ExtrasConfigContextsDeleteReader struct

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

+ type ExtrasConfigContextsListOK struct

+ Payload *ExtrasConfigContextsListOKBody

+ func NewExtrasConfigContextsListOK() *ExtrasConfigContextsListOK

+ func (o *ExtrasConfigContextsListOK) Error() string

+ func (o *ExtrasConfigContextsListOK) GetPayload() *ExtrasConfigContextsListOKBody

+ type ExtrasConfigContextsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ConfigContext

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

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

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

+ type ExtrasConfigContextsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ IsActive *string

+ Limit *int64

+ Name *string

+ Offset *int64

+ Platform *string

+ PlatformID *string

+ Q *string

+ Region *string

+ RegionID *string

+ Role *string

+ RoleID *string

+ Site *string

+ SiteID *string

+ Tenant *string

+ TenantGroup *string

+ TenantGroupID *string

+ TenantID *string

+ func NewExtrasConfigContextsListParams() *ExtrasConfigContextsListParams

+ func NewExtrasConfigContextsListParamsWithContext(ctx context.Context) *ExtrasConfigContextsListParams

+ func NewExtrasConfigContextsListParamsWithHTTPClient(client *http.Client) *ExtrasConfigContextsListParams

+ func NewExtrasConfigContextsListParamsWithTimeout(timeout time.Duration) *ExtrasConfigContextsListParams

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

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

+ func (o *ExtrasConfigContextsListParams) SetIsActive(isActive *string)

+ func (o *ExtrasConfigContextsListParams) SetLimit(limit *int64)

+ func (o *ExtrasConfigContextsListParams) SetName(name *string)

+ func (o *ExtrasConfigContextsListParams) SetOffset(offset *int64)

+ func (o *ExtrasConfigContextsListParams) SetPlatform(platform *string)

+ func (o *ExtrasConfigContextsListParams) SetPlatformID(platformID *string)

+ func (o *ExtrasConfigContextsListParams) SetQ(q *string)

+ func (o *ExtrasConfigContextsListParams) SetRegion(region *string)

+ func (o *ExtrasConfigContextsListParams) SetRegionID(regionID *string)

+ func (o *ExtrasConfigContextsListParams) SetRole(role *string)

+ func (o *ExtrasConfigContextsListParams) SetRoleID(roleID *string)

+ func (o *ExtrasConfigContextsListParams) SetSite(site *string)

+ func (o *ExtrasConfigContextsListParams) SetSiteID(siteID *string)

+ func (o *ExtrasConfigContextsListParams) SetTenant(tenant *string)

+ func (o *ExtrasConfigContextsListParams) SetTenantGroup(tenantGroup *string)

+ func (o *ExtrasConfigContextsListParams) SetTenantGroupID(tenantGroupID *string)

+ func (o *ExtrasConfigContextsListParams) SetTenantID(tenantID *string)

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

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

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

+ func (o *ExtrasConfigContextsListParams) WithIsActive(isActive *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithLimit(limit *int64) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithName(name *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithOffset(offset *int64) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithPlatform(platform *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithPlatformID(platformID *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithQ(q *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithRegion(region *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithRegionID(regionID *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithRole(role *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithRoleID(roleID *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithSite(site *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithSiteID(siteID *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithTenant(tenant *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithTenantGroup(tenantGroup *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithTenantGroupID(tenantGroupID *string) *ExtrasConfigContextsListParams

+ func (o *ExtrasConfigContextsListParams) WithTenantID(tenantID *string) *ExtrasConfigContextsListParams

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

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

+ type ExtrasConfigContextsListReader struct

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

+ type ExtrasConfigContextsPartialUpdateOK struct

+ Payload *models.ConfigContext

+ func NewExtrasConfigContextsPartialUpdateOK() *ExtrasConfigContextsPartialUpdateOK

+ func (o *ExtrasConfigContextsPartialUpdateOK) Error() string

+ func (o *ExtrasConfigContextsPartialUpdateOK) GetPayload() *models.ConfigContext

+ type ExtrasConfigContextsPartialUpdateParams struct

+ Context context.Context

+ Data *models.WritableConfigContext

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasConfigContextsPartialUpdateParams() *ExtrasConfigContextsPartialUpdateParams

+ func NewExtrasConfigContextsPartialUpdateParamsWithContext(ctx context.Context) *ExtrasConfigContextsPartialUpdateParams

+ func NewExtrasConfigContextsPartialUpdateParamsWithHTTPClient(client *http.Client) *ExtrasConfigContextsPartialUpdateParams

+ func NewExtrasConfigContextsPartialUpdateParamsWithTimeout(timeout time.Duration) *ExtrasConfigContextsPartialUpdateParams

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

+ func (o *ExtrasConfigContextsPartialUpdateParams) SetData(data *models.WritableConfigContext)

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

+ func (o *ExtrasConfigContextsPartialUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasConfigContextsPartialUpdateParams) WithData(data *models.WritableConfigContext) *ExtrasConfigContextsPartialUpdateParams

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

+ func (o *ExtrasConfigContextsPartialUpdateParams) WithID(id int64) *ExtrasConfigContextsPartialUpdateParams

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

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

+ type ExtrasConfigContextsPartialUpdateReader struct

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

+ type ExtrasConfigContextsReadOK struct

+ Payload *models.ConfigContext

+ func NewExtrasConfigContextsReadOK() *ExtrasConfigContextsReadOK

+ func (o *ExtrasConfigContextsReadOK) Error() string

+ func (o *ExtrasConfigContextsReadOK) GetPayload() *models.ConfigContext

+ type ExtrasConfigContextsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasConfigContextsReadParams() *ExtrasConfigContextsReadParams

+ func NewExtrasConfigContextsReadParamsWithContext(ctx context.Context) *ExtrasConfigContextsReadParams

+ func NewExtrasConfigContextsReadParamsWithHTTPClient(client *http.Client) *ExtrasConfigContextsReadParams

+ func NewExtrasConfigContextsReadParamsWithTimeout(timeout time.Duration) *ExtrasConfigContextsReadParams

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

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

+ func (o *ExtrasConfigContextsReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasConfigContextsReadParams) WithID(id int64) *ExtrasConfigContextsReadParams

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

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

+ type ExtrasConfigContextsReadReader struct

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

+ type ExtrasConfigContextsUpdateOK struct

+ Payload *models.ConfigContext

+ func NewExtrasConfigContextsUpdateOK() *ExtrasConfigContextsUpdateOK

+ func (o *ExtrasConfigContextsUpdateOK) Error() string

+ func (o *ExtrasConfigContextsUpdateOK) GetPayload() *models.ConfigContext

+ type ExtrasConfigContextsUpdateParams struct

+ Context context.Context

+ Data *models.WritableConfigContext

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasConfigContextsUpdateParams() *ExtrasConfigContextsUpdateParams

+ func NewExtrasConfigContextsUpdateParamsWithContext(ctx context.Context) *ExtrasConfigContextsUpdateParams

+ func NewExtrasConfigContextsUpdateParamsWithHTTPClient(client *http.Client) *ExtrasConfigContextsUpdateParams

+ func NewExtrasConfigContextsUpdateParamsWithTimeout(timeout time.Duration) *ExtrasConfigContextsUpdateParams

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

+ func (o *ExtrasConfigContextsUpdateParams) SetData(data *models.WritableConfigContext)

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

+ func (o *ExtrasConfigContextsUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasConfigContextsUpdateParams) WithData(data *models.WritableConfigContext) *ExtrasConfigContextsUpdateParams

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

+ func (o *ExtrasConfigContextsUpdateParams) WithID(id int64) *ExtrasConfigContextsUpdateParams

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

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

+ type ExtrasConfigContextsUpdateReader struct

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

+ type ExtrasExportTemplatesCreateCreated struct

+ Payload *models.ExportTemplate

+ func NewExtrasExportTemplatesCreateCreated() *ExtrasExportTemplatesCreateCreated

+ func (o *ExtrasExportTemplatesCreateCreated) Error() string

+ func (o *ExtrasExportTemplatesCreateCreated) GetPayload() *models.ExportTemplate

+ type ExtrasExportTemplatesCreateParams struct

+ Context context.Context

+ Data *models.ExportTemplate

+ HTTPClient *http.Client

+ func NewExtrasExportTemplatesCreateParams() *ExtrasExportTemplatesCreateParams

+ func NewExtrasExportTemplatesCreateParamsWithContext(ctx context.Context) *ExtrasExportTemplatesCreateParams

+ func NewExtrasExportTemplatesCreateParamsWithHTTPClient(client *http.Client) *ExtrasExportTemplatesCreateParams

+ func NewExtrasExportTemplatesCreateParamsWithTimeout(timeout time.Duration) *ExtrasExportTemplatesCreateParams

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

+ func (o *ExtrasExportTemplatesCreateParams) SetData(data *models.ExportTemplate)

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

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

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

+ func (o *ExtrasExportTemplatesCreateParams) WithData(data *models.ExportTemplate) *ExtrasExportTemplatesCreateParams

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

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

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

+ type ExtrasExportTemplatesCreateReader struct

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

+ type ExtrasExportTemplatesDeleteNoContent struct

+ func NewExtrasExportTemplatesDeleteNoContent() *ExtrasExportTemplatesDeleteNoContent

+ func (o *ExtrasExportTemplatesDeleteNoContent) Error() string

+ type ExtrasExportTemplatesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasExportTemplatesDeleteParams() *ExtrasExportTemplatesDeleteParams

+ func NewExtrasExportTemplatesDeleteParamsWithContext(ctx context.Context) *ExtrasExportTemplatesDeleteParams

+ func NewExtrasExportTemplatesDeleteParamsWithHTTPClient(client *http.Client) *ExtrasExportTemplatesDeleteParams

+ func NewExtrasExportTemplatesDeleteParamsWithTimeout(timeout time.Duration) *ExtrasExportTemplatesDeleteParams

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

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

+ func (o *ExtrasExportTemplatesDeleteParams) SetID(id int64)

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

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

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

+ func (o *ExtrasExportTemplatesDeleteParams) WithID(id int64) *ExtrasExportTemplatesDeleteParams

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

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

+ type ExtrasExportTemplatesDeleteReader struct

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

+ type ExtrasExportTemplatesListOK struct

+ Payload *ExtrasExportTemplatesListOKBody

+ func NewExtrasExportTemplatesListOK() *ExtrasExportTemplatesListOK

+ func (o *ExtrasExportTemplatesListOK) Error() string

+ func (o *ExtrasExportTemplatesListOK) GetPayload() *ExtrasExportTemplatesListOKBody

+ type ExtrasExportTemplatesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ExportTemplate

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

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

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

+ type ExtrasExportTemplatesListParams struct

+ ContentType *string

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ func NewExtrasExportTemplatesListParams() *ExtrasExportTemplatesListParams

+ func NewExtrasExportTemplatesListParamsWithContext(ctx context.Context) *ExtrasExportTemplatesListParams

+ func NewExtrasExportTemplatesListParamsWithHTTPClient(client *http.Client) *ExtrasExportTemplatesListParams

+ func NewExtrasExportTemplatesListParamsWithTimeout(timeout time.Duration) *ExtrasExportTemplatesListParams

+ func (o *ExtrasExportTemplatesListParams) SetContentType(contentType *string)

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

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

+ func (o *ExtrasExportTemplatesListParams) SetLimit(limit *int64)

+ func (o *ExtrasExportTemplatesListParams) SetName(name *string)

+ func (o *ExtrasExportTemplatesListParams) SetOffset(offset *int64)

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

+ func (o *ExtrasExportTemplatesListParams) WithContentType(contentType *string) *ExtrasExportTemplatesListParams

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

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

+ func (o *ExtrasExportTemplatesListParams) WithLimit(limit *int64) *ExtrasExportTemplatesListParams

+ func (o *ExtrasExportTemplatesListParams) WithName(name *string) *ExtrasExportTemplatesListParams

+ func (o *ExtrasExportTemplatesListParams) WithOffset(offset *int64) *ExtrasExportTemplatesListParams

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

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

+ type ExtrasExportTemplatesListReader struct

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

+ type ExtrasExportTemplatesPartialUpdateOK struct

+ Payload *models.ExportTemplate

+ func NewExtrasExportTemplatesPartialUpdateOK() *ExtrasExportTemplatesPartialUpdateOK

+ func (o *ExtrasExportTemplatesPartialUpdateOK) Error() string

+ func (o *ExtrasExportTemplatesPartialUpdateOK) GetPayload() *models.ExportTemplate

+ type ExtrasExportTemplatesPartialUpdateParams struct

+ Context context.Context

+ Data *models.ExportTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasExportTemplatesPartialUpdateParams() *ExtrasExportTemplatesPartialUpdateParams

+ func NewExtrasExportTemplatesPartialUpdateParamsWithContext(ctx context.Context) *ExtrasExportTemplatesPartialUpdateParams

+ func NewExtrasExportTemplatesPartialUpdateParamsWithHTTPClient(client *http.Client) *ExtrasExportTemplatesPartialUpdateParams

+ func NewExtrasExportTemplatesPartialUpdateParamsWithTimeout(timeout time.Duration) *ExtrasExportTemplatesPartialUpdateParams

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

+ func (o *ExtrasExportTemplatesPartialUpdateParams) SetData(data *models.ExportTemplate)

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

+ func (o *ExtrasExportTemplatesPartialUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasExportTemplatesPartialUpdateParams) WithData(data *models.ExportTemplate) *ExtrasExportTemplatesPartialUpdateParams

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

+ func (o *ExtrasExportTemplatesPartialUpdateParams) WithID(id int64) *ExtrasExportTemplatesPartialUpdateParams

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

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

+ type ExtrasExportTemplatesPartialUpdateReader struct

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

+ type ExtrasExportTemplatesReadOK struct

+ Payload *models.ExportTemplate

+ func NewExtrasExportTemplatesReadOK() *ExtrasExportTemplatesReadOK

+ func (o *ExtrasExportTemplatesReadOK) Error() string

+ func (o *ExtrasExportTemplatesReadOK) GetPayload() *models.ExportTemplate

+ type ExtrasExportTemplatesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasExportTemplatesReadParams() *ExtrasExportTemplatesReadParams

+ func NewExtrasExportTemplatesReadParamsWithContext(ctx context.Context) *ExtrasExportTemplatesReadParams

+ func NewExtrasExportTemplatesReadParamsWithHTTPClient(client *http.Client) *ExtrasExportTemplatesReadParams

+ func NewExtrasExportTemplatesReadParamsWithTimeout(timeout time.Duration) *ExtrasExportTemplatesReadParams

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

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

+ func (o *ExtrasExportTemplatesReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasExportTemplatesReadParams) WithID(id int64) *ExtrasExportTemplatesReadParams

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

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

+ type ExtrasExportTemplatesReadReader struct

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

+ type ExtrasExportTemplatesUpdateOK struct

+ Payload *models.ExportTemplate

+ func NewExtrasExportTemplatesUpdateOK() *ExtrasExportTemplatesUpdateOK

+ func (o *ExtrasExportTemplatesUpdateOK) Error() string

+ func (o *ExtrasExportTemplatesUpdateOK) GetPayload() *models.ExportTemplate

+ type ExtrasExportTemplatesUpdateParams struct

+ Context context.Context

+ Data *models.ExportTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasExportTemplatesUpdateParams() *ExtrasExportTemplatesUpdateParams

+ func NewExtrasExportTemplatesUpdateParamsWithContext(ctx context.Context) *ExtrasExportTemplatesUpdateParams

+ func NewExtrasExportTemplatesUpdateParamsWithHTTPClient(client *http.Client) *ExtrasExportTemplatesUpdateParams

+ func NewExtrasExportTemplatesUpdateParamsWithTimeout(timeout time.Duration) *ExtrasExportTemplatesUpdateParams

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

+ func (o *ExtrasExportTemplatesUpdateParams) SetData(data *models.ExportTemplate)

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

+ func (o *ExtrasExportTemplatesUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasExportTemplatesUpdateParams) WithData(data *models.ExportTemplate) *ExtrasExportTemplatesUpdateParams

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

+ func (o *ExtrasExportTemplatesUpdateParams) WithID(id int64) *ExtrasExportTemplatesUpdateParams

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

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

+ type ExtrasExportTemplatesUpdateReader struct

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

+ type ExtrasGraphsCreateCreated struct

+ Payload *models.Graph

+ func NewExtrasGraphsCreateCreated() *ExtrasGraphsCreateCreated

+ func (o *ExtrasGraphsCreateCreated) Error() string

+ func (o *ExtrasGraphsCreateCreated) GetPayload() *models.Graph

+ type ExtrasGraphsCreateParams struct

+ Context context.Context

+ Data *models.WritableGraph

+ HTTPClient *http.Client

+ func NewExtrasGraphsCreateParams() *ExtrasGraphsCreateParams

+ func NewExtrasGraphsCreateParamsWithContext(ctx context.Context) *ExtrasGraphsCreateParams

+ func NewExtrasGraphsCreateParamsWithHTTPClient(client *http.Client) *ExtrasGraphsCreateParams

+ func NewExtrasGraphsCreateParamsWithTimeout(timeout time.Duration) *ExtrasGraphsCreateParams

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

+ func (o *ExtrasGraphsCreateParams) SetData(data *models.WritableGraph)

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

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

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

+ func (o *ExtrasGraphsCreateParams) WithData(data *models.WritableGraph) *ExtrasGraphsCreateParams

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

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

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

+ type ExtrasGraphsCreateReader struct

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

+ type ExtrasGraphsDeleteNoContent struct

+ func NewExtrasGraphsDeleteNoContent() *ExtrasGraphsDeleteNoContent

+ func (o *ExtrasGraphsDeleteNoContent) Error() string

+ type ExtrasGraphsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasGraphsDeleteParams() *ExtrasGraphsDeleteParams

+ func NewExtrasGraphsDeleteParamsWithContext(ctx context.Context) *ExtrasGraphsDeleteParams

+ func NewExtrasGraphsDeleteParamsWithHTTPClient(client *http.Client) *ExtrasGraphsDeleteParams

+ func NewExtrasGraphsDeleteParamsWithTimeout(timeout time.Duration) *ExtrasGraphsDeleteParams

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

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

+ func (o *ExtrasGraphsDeleteParams) SetID(id int64)

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

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

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

+ func (o *ExtrasGraphsDeleteParams) WithID(id int64) *ExtrasGraphsDeleteParams

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

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

+ type ExtrasGraphsDeleteReader struct

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

+ type ExtrasGraphsListOK struct

+ Payload *ExtrasGraphsListOKBody

+ func NewExtrasGraphsListOK() *ExtrasGraphsListOK

+ func (o *ExtrasGraphsListOK) Error() string

+ func (o *ExtrasGraphsListOK) GetPayload() *ExtrasGraphsListOKBody

+ type ExtrasGraphsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Graph

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

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

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

+ type ExtrasGraphsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Type *string

+ func NewExtrasGraphsListParams() *ExtrasGraphsListParams

+ func NewExtrasGraphsListParamsWithContext(ctx context.Context) *ExtrasGraphsListParams

+ func NewExtrasGraphsListParamsWithHTTPClient(client *http.Client) *ExtrasGraphsListParams

+ func NewExtrasGraphsListParamsWithTimeout(timeout time.Duration) *ExtrasGraphsListParams

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

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

+ func (o *ExtrasGraphsListParams) SetLimit(limit *int64)

+ func (o *ExtrasGraphsListParams) SetName(name *string)

+ func (o *ExtrasGraphsListParams) SetOffset(offset *int64)

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

+ func (o *ExtrasGraphsListParams) SetType(typeVar *string)

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

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

+ func (o *ExtrasGraphsListParams) WithLimit(limit *int64) *ExtrasGraphsListParams

+ func (o *ExtrasGraphsListParams) WithName(name *string) *ExtrasGraphsListParams

+ func (o *ExtrasGraphsListParams) WithOffset(offset *int64) *ExtrasGraphsListParams

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

+ func (o *ExtrasGraphsListParams) WithType(typeVar *string) *ExtrasGraphsListParams

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

+ type ExtrasGraphsListReader struct

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

+ type ExtrasGraphsPartialUpdateOK struct

+ Payload *models.Graph

+ func NewExtrasGraphsPartialUpdateOK() *ExtrasGraphsPartialUpdateOK

+ func (o *ExtrasGraphsPartialUpdateOK) Error() string

+ func (o *ExtrasGraphsPartialUpdateOK) GetPayload() *models.Graph

+ type ExtrasGraphsPartialUpdateParams struct

+ Context context.Context

+ Data *models.WritableGraph

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasGraphsPartialUpdateParams() *ExtrasGraphsPartialUpdateParams

+ func NewExtrasGraphsPartialUpdateParamsWithContext(ctx context.Context) *ExtrasGraphsPartialUpdateParams

+ func NewExtrasGraphsPartialUpdateParamsWithHTTPClient(client *http.Client) *ExtrasGraphsPartialUpdateParams

+ func NewExtrasGraphsPartialUpdateParamsWithTimeout(timeout time.Duration) *ExtrasGraphsPartialUpdateParams

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

+ func (o *ExtrasGraphsPartialUpdateParams) SetData(data *models.WritableGraph)

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

+ func (o *ExtrasGraphsPartialUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasGraphsPartialUpdateParams) WithData(data *models.WritableGraph) *ExtrasGraphsPartialUpdateParams

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

+ func (o *ExtrasGraphsPartialUpdateParams) WithID(id int64) *ExtrasGraphsPartialUpdateParams

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

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

+ type ExtrasGraphsPartialUpdateReader struct

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

+ type ExtrasGraphsReadOK struct

+ Payload *models.Graph

+ func NewExtrasGraphsReadOK() *ExtrasGraphsReadOK

+ func (o *ExtrasGraphsReadOK) Error() string

+ func (o *ExtrasGraphsReadOK) GetPayload() *models.Graph

+ type ExtrasGraphsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasGraphsReadParams() *ExtrasGraphsReadParams

+ func NewExtrasGraphsReadParamsWithContext(ctx context.Context) *ExtrasGraphsReadParams

+ func NewExtrasGraphsReadParamsWithHTTPClient(client *http.Client) *ExtrasGraphsReadParams

+ func NewExtrasGraphsReadParamsWithTimeout(timeout time.Duration) *ExtrasGraphsReadParams

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

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

+ func (o *ExtrasGraphsReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasGraphsReadParams) WithID(id int64) *ExtrasGraphsReadParams

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

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

+ type ExtrasGraphsReadReader struct

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

+ type ExtrasGraphsUpdateOK struct

+ Payload *models.Graph

+ func NewExtrasGraphsUpdateOK() *ExtrasGraphsUpdateOK

+ func (o *ExtrasGraphsUpdateOK) Error() string

+ func (o *ExtrasGraphsUpdateOK) GetPayload() *models.Graph

+ type ExtrasGraphsUpdateParams struct

+ Context context.Context

+ Data *models.WritableGraph

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasGraphsUpdateParams() *ExtrasGraphsUpdateParams

+ func NewExtrasGraphsUpdateParamsWithContext(ctx context.Context) *ExtrasGraphsUpdateParams

+ func NewExtrasGraphsUpdateParamsWithHTTPClient(client *http.Client) *ExtrasGraphsUpdateParams

+ func NewExtrasGraphsUpdateParamsWithTimeout(timeout time.Duration) *ExtrasGraphsUpdateParams

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

+ func (o *ExtrasGraphsUpdateParams) SetData(data *models.WritableGraph)

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

+ func (o *ExtrasGraphsUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasGraphsUpdateParams) WithData(data *models.WritableGraph) *ExtrasGraphsUpdateParams

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

+ func (o *ExtrasGraphsUpdateParams) WithID(id int64) *ExtrasGraphsUpdateParams

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

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

+ type ExtrasGraphsUpdateReader struct

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

+ type ExtrasImageAttachmentsCreateCreated struct

+ Payload *models.ImageAttachment

+ func NewExtrasImageAttachmentsCreateCreated() *ExtrasImageAttachmentsCreateCreated

+ func (o *ExtrasImageAttachmentsCreateCreated) Error() string

+ func (o *ExtrasImageAttachmentsCreateCreated) GetPayload() *models.ImageAttachment

+ type ExtrasImageAttachmentsCreateParams struct

+ Context context.Context

+ Data *models.ImageAttachment

+ HTTPClient *http.Client

+ func NewExtrasImageAttachmentsCreateParams() *ExtrasImageAttachmentsCreateParams

+ func NewExtrasImageAttachmentsCreateParamsWithContext(ctx context.Context) *ExtrasImageAttachmentsCreateParams

+ func NewExtrasImageAttachmentsCreateParamsWithHTTPClient(client *http.Client) *ExtrasImageAttachmentsCreateParams

+ func NewExtrasImageAttachmentsCreateParamsWithTimeout(timeout time.Duration) *ExtrasImageAttachmentsCreateParams

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

+ func (o *ExtrasImageAttachmentsCreateParams) SetData(data *models.ImageAttachment)

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

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

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

+ func (o *ExtrasImageAttachmentsCreateParams) WithData(data *models.ImageAttachment) *ExtrasImageAttachmentsCreateParams

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

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

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

+ type ExtrasImageAttachmentsCreateReader struct

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

+ type ExtrasImageAttachmentsDeleteNoContent struct

+ func NewExtrasImageAttachmentsDeleteNoContent() *ExtrasImageAttachmentsDeleteNoContent

+ func (o *ExtrasImageAttachmentsDeleteNoContent) Error() string

+ type ExtrasImageAttachmentsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasImageAttachmentsDeleteParams() *ExtrasImageAttachmentsDeleteParams

+ func NewExtrasImageAttachmentsDeleteParamsWithContext(ctx context.Context) *ExtrasImageAttachmentsDeleteParams

+ func NewExtrasImageAttachmentsDeleteParamsWithHTTPClient(client *http.Client) *ExtrasImageAttachmentsDeleteParams

+ func NewExtrasImageAttachmentsDeleteParamsWithTimeout(timeout time.Duration) *ExtrasImageAttachmentsDeleteParams

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

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

+ func (o *ExtrasImageAttachmentsDeleteParams) SetID(id int64)

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

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

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

+ func (o *ExtrasImageAttachmentsDeleteParams) WithID(id int64) *ExtrasImageAttachmentsDeleteParams

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

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

+ type ExtrasImageAttachmentsDeleteReader struct

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

+ type ExtrasImageAttachmentsListOK struct

+ Payload *ExtrasImageAttachmentsListOKBody

+ func NewExtrasImageAttachmentsListOK() *ExtrasImageAttachmentsListOK

+ func (o *ExtrasImageAttachmentsListOK) Error() string

+ func (o *ExtrasImageAttachmentsListOK) GetPayload() *ExtrasImageAttachmentsListOKBody

+ type ExtrasImageAttachmentsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ImageAttachment

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

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

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

+ type ExtrasImageAttachmentsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Offset *int64

+ func NewExtrasImageAttachmentsListParams() *ExtrasImageAttachmentsListParams

+ func NewExtrasImageAttachmentsListParamsWithContext(ctx context.Context) *ExtrasImageAttachmentsListParams

+ func NewExtrasImageAttachmentsListParamsWithHTTPClient(client *http.Client) *ExtrasImageAttachmentsListParams

+ func NewExtrasImageAttachmentsListParamsWithTimeout(timeout time.Duration) *ExtrasImageAttachmentsListParams

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

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

+ func (o *ExtrasImageAttachmentsListParams) SetLimit(limit *int64)

+ func (o *ExtrasImageAttachmentsListParams) SetOffset(offset *int64)

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

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

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

+ func (o *ExtrasImageAttachmentsListParams) WithLimit(limit *int64) *ExtrasImageAttachmentsListParams

+ func (o *ExtrasImageAttachmentsListParams) WithOffset(offset *int64) *ExtrasImageAttachmentsListParams

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

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

+ type ExtrasImageAttachmentsListReader struct

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

+ type ExtrasImageAttachmentsPartialUpdateOK struct

+ Payload *models.ImageAttachment

+ func NewExtrasImageAttachmentsPartialUpdateOK() *ExtrasImageAttachmentsPartialUpdateOK

+ func (o *ExtrasImageAttachmentsPartialUpdateOK) Error() string

+ func (o *ExtrasImageAttachmentsPartialUpdateOK) GetPayload() *models.ImageAttachment

+ type ExtrasImageAttachmentsPartialUpdateParams struct

+ Context context.Context

+ Data *models.ImageAttachment

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasImageAttachmentsPartialUpdateParams() *ExtrasImageAttachmentsPartialUpdateParams

+ func NewExtrasImageAttachmentsPartialUpdateParamsWithContext(ctx context.Context) *ExtrasImageAttachmentsPartialUpdateParams

+ func NewExtrasImageAttachmentsPartialUpdateParamsWithHTTPClient(client *http.Client) *ExtrasImageAttachmentsPartialUpdateParams

+ func NewExtrasImageAttachmentsPartialUpdateParamsWithTimeout(timeout time.Duration) *ExtrasImageAttachmentsPartialUpdateParams

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

+ func (o *ExtrasImageAttachmentsPartialUpdateParams) SetData(data *models.ImageAttachment)

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

+ func (o *ExtrasImageAttachmentsPartialUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasImageAttachmentsPartialUpdateParams) WithData(data *models.ImageAttachment) *ExtrasImageAttachmentsPartialUpdateParams

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

+ func (o *ExtrasImageAttachmentsPartialUpdateParams) WithID(id int64) *ExtrasImageAttachmentsPartialUpdateParams

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

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

+ type ExtrasImageAttachmentsPartialUpdateReader struct

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

+ type ExtrasImageAttachmentsReadOK struct

+ Payload *models.ImageAttachment

+ func NewExtrasImageAttachmentsReadOK() *ExtrasImageAttachmentsReadOK

+ func (o *ExtrasImageAttachmentsReadOK) Error() string

+ func (o *ExtrasImageAttachmentsReadOK) GetPayload() *models.ImageAttachment

+ type ExtrasImageAttachmentsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasImageAttachmentsReadParams() *ExtrasImageAttachmentsReadParams

+ func NewExtrasImageAttachmentsReadParamsWithContext(ctx context.Context) *ExtrasImageAttachmentsReadParams

+ func NewExtrasImageAttachmentsReadParamsWithHTTPClient(client *http.Client) *ExtrasImageAttachmentsReadParams

+ func NewExtrasImageAttachmentsReadParamsWithTimeout(timeout time.Duration) *ExtrasImageAttachmentsReadParams

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

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

+ func (o *ExtrasImageAttachmentsReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasImageAttachmentsReadParams) WithID(id int64) *ExtrasImageAttachmentsReadParams

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

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

+ type ExtrasImageAttachmentsReadReader struct

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

+ type ExtrasImageAttachmentsUpdateOK struct

+ Payload *models.ImageAttachment

+ func NewExtrasImageAttachmentsUpdateOK() *ExtrasImageAttachmentsUpdateOK

+ func (o *ExtrasImageAttachmentsUpdateOK) Error() string

+ func (o *ExtrasImageAttachmentsUpdateOK) GetPayload() *models.ImageAttachment

+ type ExtrasImageAttachmentsUpdateParams struct

+ Context context.Context

+ Data *models.ImageAttachment

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasImageAttachmentsUpdateParams() *ExtrasImageAttachmentsUpdateParams

+ func NewExtrasImageAttachmentsUpdateParamsWithContext(ctx context.Context) *ExtrasImageAttachmentsUpdateParams

+ func NewExtrasImageAttachmentsUpdateParamsWithHTTPClient(client *http.Client) *ExtrasImageAttachmentsUpdateParams

+ func NewExtrasImageAttachmentsUpdateParamsWithTimeout(timeout time.Duration) *ExtrasImageAttachmentsUpdateParams

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

+ func (o *ExtrasImageAttachmentsUpdateParams) SetData(data *models.ImageAttachment)

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

+ func (o *ExtrasImageAttachmentsUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasImageAttachmentsUpdateParams) WithData(data *models.ImageAttachment) *ExtrasImageAttachmentsUpdateParams

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

+ func (o *ExtrasImageAttachmentsUpdateParams) WithID(id int64) *ExtrasImageAttachmentsUpdateParams

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

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

+ type ExtrasImageAttachmentsUpdateReader struct

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

+ type ExtrasObjectChangesListOK struct

+ Payload *ExtrasObjectChangesListOKBody

+ func NewExtrasObjectChangesListOK() *ExtrasObjectChangesListOK

+ func (o *ExtrasObjectChangesListOK) Error() string

+ func (o *ExtrasObjectChangesListOK) GetPayload() *ExtrasObjectChangesListOKBody

+ type ExtrasObjectChangesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ObjectChange

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

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

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

+ type ExtrasObjectChangesListParams struct

+ Action *string

+ ChangedObjectType *string

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ ObjectRepr *string

+ Offset *int64

+ Q *string

+ RequestID *string

+ Time *string

+ User *string

+ UserName *string

+ func NewExtrasObjectChangesListParams() *ExtrasObjectChangesListParams

+ func NewExtrasObjectChangesListParamsWithContext(ctx context.Context) *ExtrasObjectChangesListParams

+ func NewExtrasObjectChangesListParamsWithHTTPClient(client *http.Client) *ExtrasObjectChangesListParams

+ func NewExtrasObjectChangesListParamsWithTimeout(timeout time.Duration) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) SetAction(action *string)

+ func (o *ExtrasObjectChangesListParams) SetChangedObjectType(changedObjectType *string)

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

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

+ func (o *ExtrasObjectChangesListParams) SetLimit(limit *int64)

+ func (o *ExtrasObjectChangesListParams) SetObjectRepr(objectRepr *string)

+ func (o *ExtrasObjectChangesListParams) SetOffset(offset *int64)

+ func (o *ExtrasObjectChangesListParams) SetQ(q *string)

+ func (o *ExtrasObjectChangesListParams) SetRequestID(requestID *string)

+ func (o *ExtrasObjectChangesListParams) SetTime(time *string)

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

+ func (o *ExtrasObjectChangesListParams) SetUser(user *string)

+ func (o *ExtrasObjectChangesListParams) SetUserName(userName *string)

+ func (o *ExtrasObjectChangesListParams) WithAction(action *string) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) WithChangedObjectType(changedObjectType *string) *ExtrasObjectChangesListParams

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

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

+ func (o *ExtrasObjectChangesListParams) WithLimit(limit *int64) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) WithObjectRepr(objectRepr *string) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) WithOffset(offset *int64) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) WithQ(q *string) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) WithRequestID(requestID *string) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) WithTime(time *string) *ExtrasObjectChangesListParams

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

+ func (o *ExtrasObjectChangesListParams) WithUser(user *string) *ExtrasObjectChangesListParams

+ func (o *ExtrasObjectChangesListParams) WithUserName(userName *string) *ExtrasObjectChangesListParams

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

+ type ExtrasObjectChangesListReader struct

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

+ type ExtrasObjectChangesReadOK struct

+ Payload *models.ObjectChange

+ func NewExtrasObjectChangesReadOK() *ExtrasObjectChangesReadOK

+ func (o *ExtrasObjectChangesReadOK) Error() string

+ func (o *ExtrasObjectChangesReadOK) GetPayload() *models.ObjectChange

+ type ExtrasObjectChangesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasObjectChangesReadParams() *ExtrasObjectChangesReadParams

+ func NewExtrasObjectChangesReadParamsWithContext(ctx context.Context) *ExtrasObjectChangesReadParams

+ func NewExtrasObjectChangesReadParamsWithHTTPClient(client *http.Client) *ExtrasObjectChangesReadParams

+ func NewExtrasObjectChangesReadParamsWithTimeout(timeout time.Duration) *ExtrasObjectChangesReadParams

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

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

+ func (o *ExtrasObjectChangesReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasObjectChangesReadParams) WithID(id int64) *ExtrasObjectChangesReadParams

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

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

+ type ExtrasObjectChangesReadReader struct

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

+ type ExtrasReportsListOK struct

+ func NewExtrasReportsListOK() *ExtrasReportsListOK

+ func (o *ExtrasReportsListOK) Error() string

+ type ExtrasReportsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ func NewExtrasReportsListParams() *ExtrasReportsListParams

+ func NewExtrasReportsListParamsWithContext(ctx context.Context) *ExtrasReportsListParams

+ func NewExtrasReportsListParamsWithHTTPClient(client *http.Client) *ExtrasReportsListParams

+ func NewExtrasReportsListParamsWithTimeout(timeout time.Duration) *ExtrasReportsListParams

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

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

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

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

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

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

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

+ type ExtrasReportsListReader struct

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

+ type ExtrasReportsReadOK struct

+ func NewExtrasReportsReadOK() *ExtrasReportsReadOK

+ func (o *ExtrasReportsReadOK) Error() string

+ type ExtrasReportsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID string

+ func NewExtrasReportsReadParams() *ExtrasReportsReadParams

+ func NewExtrasReportsReadParamsWithContext(ctx context.Context) *ExtrasReportsReadParams

+ func NewExtrasReportsReadParamsWithHTTPClient(client *http.Client) *ExtrasReportsReadParams

+ func NewExtrasReportsReadParamsWithTimeout(timeout time.Duration) *ExtrasReportsReadParams

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

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

+ func (o *ExtrasReportsReadParams) SetID(id string)

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

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

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

+ func (o *ExtrasReportsReadParams) WithID(id string) *ExtrasReportsReadParams

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

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

+ type ExtrasReportsReadReader struct

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

+ type ExtrasReportsRunCreated struct

+ func NewExtrasReportsRunCreated() *ExtrasReportsRunCreated

+ func (o *ExtrasReportsRunCreated) Error() string

+ type ExtrasReportsRunParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID string

+ func NewExtrasReportsRunParams() *ExtrasReportsRunParams

+ func NewExtrasReportsRunParamsWithContext(ctx context.Context) *ExtrasReportsRunParams

+ func NewExtrasReportsRunParamsWithHTTPClient(client *http.Client) *ExtrasReportsRunParams

+ func NewExtrasReportsRunParamsWithTimeout(timeout time.Duration) *ExtrasReportsRunParams

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

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

+ func (o *ExtrasReportsRunParams) SetID(id string)

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

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

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

+ func (o *ExtrasReportsRunParams) WithID(id string) *ExtrasReportsRunParams

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

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

+ type ExtrasReportsRunReader struct

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

+ type ExtrasTagsCreateCreated struct

+ Payload *models.Tag

+ func NewExtrasTagsCreateCreated() *ExtrasTagsCreateCreated

+ func (o *ExtrasTagsCreateCreated) Error() string

+ func (o *ExtrasTagsCreateCreated) GetPayload() *models.Tag

+ type ExtrasTagsCreateParams struct

+ Context context.Context

+ Data *models.Tag

+ HTTPClient *http.Client

+ func NewExtrasTagsCreateParams() *ExtrasTagsCreateParams

+ func NewExtrasTagsCreateParamsWithContext(ctx context.Context) *ExtrasTagsCreateParams

+ func NewExtrasTagsCreateParamsWithHTTPClient(client *http.Client) *ExtrasTagsCreateParams

+ func NewExtrasTagsCreateParamsWithTimeout(timeout time.Duration) *ExtrasTagsCreateParams

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

+ func (o *ExtrasTagsCreateParams) SetData(data *models.Tag)

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

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

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

+ func (o *ExtrasTagsCreateParams) WithData(data *models.Tag) *ExtrasTagsCreateParams

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

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

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

+ type ExtrasTagsCreateReader struct

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

+ type ExtrasTagsDeleteNoContent struct

+ func NewExtrasTagsDeleteNoContent() *ExtrasTagsDeleteNoContent

+ func (o *ExtrasTagsDeleteNoContent) Error() string

+ type ExtrasTagsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTagsDeleteParams() *ExtrasTagsDeleteParams

+ func NewExtrasTagsDeleteParamsWithContext(ctx context.Context) *ExtrasTagsDeleteParams

+ func NewExtrasTagsDeleteParamsWithHTTPClient(client *http.Client) *ExtrasTagsDeleteParams

+ func NewExtrasTagsDeleteParamsWithTimeout(timeout time.Duration) *ExtrasTagsDeleteParams

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

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

+ func (o *ExtrasTagsDeleteParams) SetID(id int64)

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

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

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

+ func (o *ExtrasTagsDeleteParams) WithID(id int64) *ExtrasTagsDeleteParams

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

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

+ type ExtrasTagsDeleteReader struct

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

+ type ExtrasTagsListOK struct

+ Payload *ExtrasTagsListOKBody

+ func NewExtrasTagsListOK() *ExtrasTagsListOK

+ func (o *ExtrasTagsListOK) Error() string

+ func (o *ExtrasTagsListOK) GetPayload() *ExtrasTagsListOKBody

+ type ExtrasTagsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Tag

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

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

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

+ type ExtrasTagsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Q *string

+ Slug *string

+ func NewExtrasTagsListParams() *ExtrasTagsListParams

+ func NewExtrasTagsListParamsWithContext(ctx context.Context) *ExtrasTagsListParams

+ func NewExtrasTagsListParamsWithHTTPClient(client *http.Client) *ExtrasTagsListParams

+ func NewExtrasTagsListParamsWithTimeout(timeout time.Duration) *ExtrasTagsListParams

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

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

+ func (o *ExtrasTagsListParams) SetLimit(limit *int64)

+ func (o *ExtrasTagsListParams) SetName(name *string)

+ func (o *ExtrasTagsListParams) SetOffset(offset *int64)

+ func (o *ExtrasTagsListParams) SetQ(q *string)

+ func (o *ExtrasTagsListParams) SetSlug(slug *string)

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

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

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

+ func (o *ExtrasTagsListParams) WithLimit(limit *int64) *ExtrasTagsListParams

+ func (o *ExtrasTagsListParams) WithName(name *string) *ExtrasTagsListParams

+ func (o *ExtrasTagsListParams) WithOffset(offset *int64) *ExtrasTagsListParams

+ func (o *ExtrasTagsListParams) WithQ(q *string) *ExtrasTagsListParams

+ func (o *ExtrasTagsListParams) WithSlug(slug *string) *ExtrasTagsListParams

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

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

+ type ExtrasTagsListReader struct

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

+ type ExtrasTagsPartialUpdateOK struct

+ Payload *models.Tag

+ func NewExtrasTagsPartialUpdateOK() *ExtrasTagsPartialUpdateOK

+ func (o *ExtrasTagsPartialUpdateOK) Error() string

+ func (o *ExtrasTagsPartialUpdateOK) GetPayload() *models.Tag

+ type ExtrasTagsPartialUpdateParams struct

+ Context context.Context

+ Data *models.Tag

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTagsPartialUpdateParams() *ExtrasTagsPartialUpdateParams

+ func NewExtrasTagsPartialUpdateParamsWithContext(ctx context.Context) *ExtrasTagsPartialUpdateParams

+ func NewExtrasTagsPartialUpdateParamsWithHTTPClient(client *http.Client) *ExtrasTagsPartialUpdateParams

+ func NewExtrasTagsPartialUpdateParamsWithTimeout(timeout time.Duration) *ExtrasTagsPartialUpdateParams

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

+ func (o *ExtrasTagsPartialUpdateParams) SetData(data *models.Tag)

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

+ func (o *ExtrasTagsPartialUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasTagsPartialUpdateParams) WithData(data *models.Tag) *ExtrasTagsPartialUpdateParams

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

+ func (o *ExtrasTagsPartialUpdateParams) WithID(id int64) *ExtrasTagsPartialUpdateParams

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

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

+ type ExtrasTagsPartialUpdateReader struct

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

+ type ExtrasTagsReadOK struct

+ Payload *models.Tag

+ func NewExtrasTagsReadOK() *ExtrasTagsReadOK

+ func (o *ExtrasTagsReadOK) Error() string

+ func (o *ExtrasTagsReadOK) GetPayload() *models.Tag

+ type ExtrasTagsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTagsReadParams() *ExtrasTagsReadParams

+ func NewExtrasTagsReadParamsWithContext(ctx context.Context) *ExtrasTagsReadParams

+ func NewExtrasTagsReadParamsWithHTTPClient(client *http.Client) *ExtrasTagsReadParams

+ func NewExtrasTagsReadParamsWithTimeout(timeout time.Duration) *ExtrasTagsReadParams

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

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

+ func (o *ExtrasTagsReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasTagsReadParams) WithID(id int64) *ExtrasTagsReadParams

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

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

+ type ExtrasTagsReadReader struct

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

+ type ExtrasTagsUpdateOK struct

+ Payload *models.Tag

+ func NewExtrasTagsUpdateOK() *ExtrasTagsUpdateOK

+ func (o *ExtrasTagsUpdateOK) Error() string

+ func (o *ExtrasTagsUpdateOK) GetPayload() *models.Tag

+ type ExtrasTagsUpdateParams struct

+ Context context.Context

+ Data *models.Tag

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTagsUpdateParams() *ExtrasTagsUpdateParams

+ func NewExtrasTagsUpdateParamsWithContext(ctx context.Context) *ExtrasTagsUpdateParams

+ func NewExtrasTagsUpdateParamsWithHTTPClient(client *http.Client) *ExtrasTagsUpdateParams

+ func NewExtrasTagsUpdateParamsWithTimeout(timeout time.Duration) *ExtrasTagsUpdateParams

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

+ func (o *ExtrasTagsUpdateParams) SetData(data *models.Tag)

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

+ func (o *ExtrasTagsUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasTagsUpdateParams) WithData(data *models.Tag) *ExtrasTagsUpdateParams

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

+ func (o *ExtrasTagsUpdateParams) WithID(id int64) *ExtrasTagsUpdateParams

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

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

+ type ExtrasTagsUpdateReader struct

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

+ type ExtrasTopologyMapsCreateCreated struct

+ Payload *models.TopologyMap

+ func NewExtrasTopologyMapsCreateCreated() *ExtrasTopologyMapsCreateCreated

+ func (o *ExtrasTopologyMapsCreateCreated) Error() string

+ func (o *ExtrasTopologyMapsCreateCreated) GetPayload() *models.TopologyMap

+ type ExtrasTopologyMapsCreateParams struct

+ Context context.Context

+ Data *models.WritableTopologyMap

+ HTTPClient *http.Client

+ func NewExtrasTopologyMapsCreateParams() *ExtrasTopologyMapsCreateParams

+ func NewExtrasTopologyMapsCreateParamsWithContext(ctx context.Context) *ExtrasTopologyMapsCreateParams

+ func NewExtrasTopologyMapsCreateParamsWithHTTPClient(client *http.Client) *ExtrasTopologyMapsCreateParams

+ func NewExtrasTopologyMapsCreateParamsWithTimeout(timeout time.Duration) *ExtrasTopologyMapsCreateParams

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

+ func (o *ExtrasTopologyMapsCreateParams) SetData(data *models.WritableTopologyMap)

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

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

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

+ func (o *ExtrasTopologyMapsCreateParams) WithData(data *models.WritableTopologyMap) *ExtrasTopologyMapsCreateParams

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

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

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

+ type ExtrasTopologyMapsCreateReader struct

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

+ type ExtrasTopologyMapsDeleteNoContent struct

+ func NewExtrasTopologyMapsDeleteNoContent() *ExtrasTopologyMapsDeleteNoContent

+ func (o *ExtrasTopologyMapsDeleteNoContent) Error() string

+ type ExtrasTopologyMapsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTopologyMapsDeleteParams() *ExtrasTopologyMapsDeleteParams

+ func NewExtrasTopologyMapsDeleteParamsWithContext(ctx context.Context) *ExtrasTopologyMapsDeleteParams

+ func NewExtrasTopologyMapsDeleteParamsWithHTTPClient(client *http.Client) *ExtrasTopologyMapsDeleteParams

+ func NewExtrasTopologyMapsDeleteParamsWithTimeout(timeout time.Duration) *ExtrasTopologyMapsDeleteParams

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

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

+ func (o *ExtrasTopologyMapsDeleteParams) SetID(id int64)

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

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

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

+ func (o *ExtrasTopologyMapsDeleteParams) WithID(id int64) *ExtrasTopologyMapsDeleteParams

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

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

+ type ExtrasTopologyMapsDeleteReader struct

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

+ type ExtrasTopologyMapsListOK struct

+ Payload *ExtrasTopologyMapsListOKBody

+ func NewExtrasTopologyMapsListOK() *ExtrasTopologyMapsListOK

+ func (o *ExtrasTopologyMapsListOK) Error() string

+ func (o *ExtrasTopologyMapsListOK) GetPayload() *ExtrasTopologyMapsListOKBody

+ type ExtrasTopologyMapsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.TopologyMap

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

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

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

+ type ExtrasTopologyMapsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Site *string

+ SiteID *string

+ Slug *string

+ func NewExtrasTopologyMapsListParams() *ExtrasTopologyMapsListParams

+ func NewExtrasTopologyMapsListParamsWithContext(ctx context.Context) *ExtrasTopologyMapsListParams

+ func NewExtrasTopologyMapsListParamsWithHTTPClient(client *http.Client) *ExtrasTopologyMapsListParams

+ func NewExtrasTopologyMapsListParamsWithTimeout(timeout time.Duration) *ExtrasTopologyMapsListParams

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

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

+ func (o *ExtrasTopologyMapsListParams) SetLimit(limit *int64)

+ func (o *ExtrasTopologyMapsListParams) SetName(name *string)

+ func (o *ExtrasTopologyMapsListParams) SetOffset(offset *int64)

+ func (o *ExtrasTopologyMapsListParams) SetSite(site *string)

+ func (o *ExtrasTopologyMapsListParams) SetSiteID(siteID *string)

+ func (o *ExtrasTopologyMapsListParams) SetSlug(slug *string)

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

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

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

+ func (o *ExtrasTopologyMapsListParams) WithLimit(limit *int64) *ExtrasTopologyMapsListParams

+ func (o *ExtrasTopologyMapsListParams) WithName(name *string) *ExtrasTopologyMapsListParams

+ func (o *ExtrasTopologyMapsListParams) WithOffset(offset *int64) *ExtrasTopologyMapsListParams

+ func (o *ExtrasTopologyMapsListParams) WithSite(site *string) *ExtrasTopologyMapsListParams

+ func (o *ExtrasTopologyMapsListParams) WithSiteID(siteID *string) *ExtrasTopologyMapsListParams

+ func (o *ExtrasTopologyMapsListParams) WithSlug(slug *string) *ExtrasTopologyMapsListParams

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

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

+ type ExtrasTopologyMapsListReader struct

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

+ type ExtrasTopologyMapsPartialUpdateOK struct

+ Payload *models.TopologyMap

+ func NewExtrasTopologyMapsPartialUpdateOK() *ExtrasTopologyMapsPartialUpdateOK

+ func (o *ExtrasTopologyMapsPartialUpdateOK) Error() string

+ func (o *ExtrasTopologyMapsPartialUpdateOK) GetPayload() *models.TopologyMap

+ type ExtrasTopologyMapsPartialUpdateParams struct

+ Context context.Context

+ Data *models.WritableTopologyMap

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTopologyMapsPartialUpdateParams() *ExtrasTopologyMapsPartialUpdateParams

+ func NewExtrasTopologyMapsPartialUpdateParamsWithContext(ctx context.Context) *ExtrasTopologyMapsPartialUpdateParams

+ func NewExtrasTopologyMapsPartialUpdateParamsWithHTTPClient(client *http.Client) *ExtrasTopologyMapsPartialUpdateParams

+ func NewExtrasTopologyMapsPartialUpdateParamsWithTimeout(timeout time.Duration) *ExtrasTopologyMapsPartialUpdateParams

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

+ func (o *ExtrasTopologyMapsPartialUpdateParams) SetData(data *models.WritableTopologyMap)

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

+ func (o *ExtrasTopologyMapsPartialUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasTopologyMapsPartialUpdateParams) WithData(data *models.WritableTopologyMap) *ExtrasTopologyMapsPartialUpdateParams

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

+ func (o *ExtrasTopologyMapsPartialUpdateParams) WithID(id int64) *ExtrasTopologyMapsPartialUpdateParams

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

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

+ type ExtrasTopologyMapsPartialUpdateReader struct

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

+ type ExtrasTopologyMapsReadOK struct

+ Payload *models.TopologyMap

+ func NewExtrasTopologyMapsReadOK() *ExtrasTopologyMapsReadOK

+ func (o *ExtrasTopologyMapsReadOK) Error() string

+ func (o *ExtrasTopologyMapsReadOK) GetPayload() *models.TopologyMap

+ type ExtrasTopologyMapsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTopologyMapsReadParams() *ExtrasTopologyMapsReadParams

+ func NewExtrasTopologyMapsReadParamsWithContext(ctx context.Context) *ExtrasTopologyMapsReadParams

+ func NewExtrasTopologyMapsReadParamsWithHTTPClient(client *http.Client) *ExtrasTopologyMapsReadParams

+ func NewExtrasTopologyMapsReadParamsWithTimeout(timeout time.Duration) *ExtrasTopologyMapsReadParams

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

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

+ func (o *ExtrasTopologyMapsReadParams) SetID(id int64)

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

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

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

+ func (o *ExtrasTopologyMapsReadParams) WithID(id int64) *ExtrasTopologyMapsReadParams

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

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

+ type ExtrasTopologyMapsReadReader struct

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

+ type ExtrasTopologyMapsRenderOK struct

+ Payload *models.TopologyMap

+ func NewExtrasTopologyMapsRenderOK() *ExtrasTopologyMapsRenderOK

+ func (o *ExtrasTopologyMapsRenderOK) Error() string

+ func (o *ExtrasTopologyMapsRenderOK) GetPayload() *models.TopologyMap

+ type ExtrasTopologyMapsRenderParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTopologyMapsRenderParams() *ExtrasTopologyMapsRenderParams

+ func NewExtrasTopologyMapsRenderParamsWithContext(ctx context.Context) *ExtrasTopologyMapsRenderParams

+ func NewExtrasTopologyMapsRenderParamsWithHTTPClient(client *http.Client) *ExtrasTopologyMapsRenderParams

+ func NewExtrasTopologyMapsRenderParamsWithTimeout(timeout time.Duration) *ExtrasTopologyMapsRenderParams

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

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

+ func (o *ExtrasTopologyMapsRenderParams) SetID(id int64)

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

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

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

+ func (o *ExtrasTopologyMapsRenderParams) WithID(id int64) *ExtrasTopologyMapsRenderParams

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

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

+ type ExtrasTopologyMapsRenderReader struct

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

+ type ExtrasTopologyMapsUpdateOK struct

+ Payload *models.TopologyMap

+ func NewExtrasTopologyMapsUpdateOK() *ExtrasTopologyMapsUpdateOK

+ func (o *ExtrasTopologyMapsUpdateOK) Error() string

+ func (o *ExtrasTopologyMapsUpdateOK) GetPayload() *models.TopologyMap

+ type ExtrasTopologyMapsUpdateParams struct

+ Context context.Context

+ Data *models.WritableTopologyMap

+ HTTPClient *http.Client

+ ID int64

+ func NewExtrasTopologyMapsUpdateParams() *ExtrasTopologyMapsUpdateParams

+ func NewExtrasTopologyMapsUpdateParamsWithContext(ctx context.Context) *ExtrasTopologyMapsUpdateParams

+ func NewExtrasTopologyMapsUpdateParamsWithHTTPClient(client *http.Client) *ExtrasTopologyMapsUpdateParams

+ func NewExtrasTopologyMapsUpdateParamsWithTimeout(timeout time.Duration) *ExtrasTopologyMapsUpdateParams

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

+ func (o *ExtrasTopologyMapsUpdateParams) SetData(data *models.WritableTopologyMap)

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

+ func (o *ExtrasTopologyMapsUpdateParams) SetID(id int64)

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

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

+ func (o *ExtrasTopologyMapsUpdateParams) WithData(data *models.WritableTopologyMap) *ExtrasTopologyMapsUpdateParams

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

+ func (o *ExtrasTopologyMapsUpdateParams) WithID(id int64) *ExtrasTopologyMapsUpdateParams

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

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

+ type ExtrasTopologyMapsUpdateReader struct

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

JackTT - Gopher 🇻🇳