item

package
v0.0.0-...-f573b6e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 16, 2021 License: MIT Imports: 13 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AcquireItemNotFound 

type AcquireItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

AcquireItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewAcquireItemNotFound 

func NewAcquireItemNotFound() *AcquireItemNotFound

NewAcquireItemNotFound creates a AcquireItemNotFound with default headers values

func (*AcquireItemNotFound) Error 

func (o *AcquireItemNotFound) Error() string

func (*AcquireItemNotFound) GetPayload 

func (o *AcquireItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type AcquireItemOK 

type AcquireItemOK struct {
	Payload *platformclientmodels.ItemAcquireResult
}

AcquireItemOK handles this case with default header values. 

successful operation

func NewAcquireItemOK 

func NewAcquireItemOK() *AcquireItemOK

NewAcquireItemOK creates a AcquireItemOK with default headers values

func (*AcquireItemOK) Error 

func (o *AcquireItemOK) Error() string

func (*AcquireItemOK) GetPayload 

func (o *AcquireItemOK) GetPayload() *platformclientmodels.ItemAcquireResult

type AcquireItemParams 

type AcquireItemParams struct {

	/*Body*/
	Body *platformclientmodels.ItemAcquireRequest
	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

AcquireItemParams contains all the parameters to send to the API endpoint for the acquire item operation typically these are written to a http.Request

func NewAcquireItemParams 

func NewAcquireItemParams() *AcquireItemParams

NewAcquireItemParams creates a new AcquireItemParams object with the default values initialized.

func NewAcquireItemParamsWithContext 

func NewAcquireItemParamsWithContext(ctx context.Context) *AcquireItemParams

NewAcquireItemParamsWithContext creates a new AcquireItemParams object with the default values initialized, and the ability to set a context for a request

func NewAcquireItemParamsWithHTTPClient 

func NewAcquireItemParamsWithHTTPClient(client *http.Client) *AcquireItemParams

NewAcquireItemParamsWithHTTPClient creates a new AcquireItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewAcquireItemParamsWithTimeout 

func NewAcquireItemParamsWithTimeout(timeout time.Duration) *AcquireItemParams

NewAcquireItemParamsWithTimeout creates a new AcquireItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*AcquireItemParams) SetBody 

func (o *AcquireItemParams) SetBody(body *platformclientmodels.ItemAcquireRequest)

SetBody adds the body to the acquire item params

func (*AcquireItemParams) SetContext 

func (o *AcquireItemParams) SetContext(ctx context.Context)

SetContext adds the context to the acquire item params

func (*AcquireItemParams) SetHTTPClient 

func (o *AcquireItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the acquire item params

func (*AcquireItemParams) SetItemID 

func (o *AcquireItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the acquire item params

func (*AcquireItemParams) SetNamespace 

func (o *AcquireItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the acquire item params

func (*AcquireItemParams) SetTimeout 

func (o *AcquireItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the acquire item params

func (*AcquireItemParams) WithBody 

func (o *AcquireItemParams) WithBody(body *platformclientmodels.ItemAcquireRequest) *AcquireItemParams

WithBody adds the body to the acquire item params

func (*AcquireItemParams) WithContext 

func (o *AcquireItemParams) WithContext(ctx context.Context) *AcquireItemParams

WithContext adds the context to the acquire item params

func (*AcquireItemParams) WithHTTPClient 

func (o *AcquireItemParams) WithHTTPClient(client *http.Client) *AcquireItemParams

WithHTTPClient adds the HTTPClient to the acquire item params

func (*AcquireItemParams) WithItemID 

func (o *AcquireItemParams) WithItemID(itemID string) *AcquireItemParams

WithItemID adds the itemID to the acquire item params

func (*AcquireItemParams) WithNamespace 

func (o *AcquireItemParams) WithNamespace(namespace string) *AcquireItemParams

WithNamespace adds the namespace to the acquire item params

func (*AcquireItemParams) WithTimeout 

func (o *AcquireItemParams) WithTimeout(timeout time.Duration) *AcquireItemParams

WithTimeout adds the timeout to the acquire item params

func (*AcquireItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type AcquireItemReader 

type AcquireItemReader struct {
	// contains filtered or unexported fields
}

AcquireItemReader is a Reader for the AcquireItem structure.

func (*AcquireItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type BulkGetLocaleItemsOK 

type BulkGetLocaleItemsOK struct {
	Payload []*platformclientmodels.ItemInfo
}

BulkGetLocaleItemsOK handles this case with default header values. 

successful operation

func NewBulkGetLocaleItemsOK 

func NewBulkGetLocaleItemsOK() *BulkGetLocaleItemsOK

NewBulkGetLocaleItemsOK creates a BulkGetLocaleItemsOK with default headers values

func (*BulkGetLocaleItemsOK) Error 

func (o *BulkGetLocaleItemsOK) Error() string

func (*BulkGetLocaleItemsOK) GetPayload 

func (o *BulkGetLocaleItemsOK) GetPayload() []*platformclientmodels.ItemInfo

type BulkGetLocaleItemsParams 

type BulkGetLocaleItemsParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*ItemIds
	  commas separated item ids

	*/
	ItemIds string
	/*Language*/
	Language *string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*Region*/
	Region *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

BulkGetLocaleItemsParams contains all the parameters to send to the API endpoint for the bulk get locale items operation typically these are written to a http.Request

func NewBulkGetLocaleItemsParams 

func NewBulkGetLocaleItemsParams() *BulkGetLocaleItemsParams

NewBulkGetLocaleItemsParams creates a new BulkGetLocaleItemsParams object with the default values initialized.

func NewBulkGetLocaleItemsParamsWithContext 

func NewBulkGetLocaleItemsParamsWithContext(ctx context.Context) *BulkGetLocaleItemsParams

NewBulkGetLocaleItemsParamsWithContext creates a new BulkGetLocaleItemsParams object with the default values initialized, and the ability to set a context for a request

func NewBulkGetLocaleItemsParamsWithHTTPClient 

func NewBulkGetLocaleItemsParamsWithHTTPClient(client *http.Client) *BulkGetLocaleItemsParams

NewBulkGetLocaleItemsParamsWithHTTPClient creates a new BulkGetLocaleItemsParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewBulkGetLocaleItemsParamsWithTimeout 

func NewBulkGetLocaleItemsParamsWithTimeout(timeout time.Duration) *BulkGetLocaleItemsParams

NewBulkGetLocaleItemsParamsWithTimeout creates a new BulkGetLocaleItemsParams object with the default values initialized, and the ability to set a timeout on a request

func (*BulkGetLocaleItemsParams) SetActiveOnly 

func (o *BulkGetLocaleItemsParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetContext 

func (o *BulkGetLocaleItemsParams) SetContext(ctx context.Context)

SetContext adds the context to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetHTTPClient 

func (o *BulkGetLocaleItemsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetItemIds 

func (o *BulkGetLocaleItemsParams) SetItemIds(itemIds string)

SetItemIds adds the itemIds to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetLanguage 

func (o *BulkGetLocaleItemsParams) SetLanguage(language *string)

SetLanguage adds the language to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetNamespace 

func (o *BulkGetLocaleItemsParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetRegion 

func (o *BulkGetLocaleItemsParams) SetRegion(region *string)

SetRegion adds the region to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetStoreID 

func (o *BulkGetLocaleItemsParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the bulk get locale items params

func (*BulkGetLocaleItemsParams) SetTimeout 

func (o *BulkGetLocaleItemsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithActiveOnly 

func (o *BulkGetLocaleItemsParams) WithActiveOnly(activeOnly *bool) *BulkGetLocaleItemsParams

WithActiveOnly adds the activeOnly to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithContext 

func (o *BulkGetLocaleItemsParams) WithContext(ctx context.Context) *BulkGetLocaleItemsParams

WithContext adds the context to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithHTTPClient 

func (o *BulkGetLocaleItemsParams) WithHTTPClient(client *http.Client) *BulkGetLocaleItemsParams

WithHTTPClient adds the HTTPClient to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithItemIds 

func (o *BulkGetLocaleItemsParams) WithItemIds(itemIds string) *BulkGetLocaleItemsParams

WithItemIds adds the itemIds to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithLanguage 

func (o *BulkGetLocaleItemsParams) WithLanguage(language *string) *BulkGetLocaleItemsParams

WithLanguage adds the language to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithNamespace 

func (o *BulkGetLocaleItemsParams) WithNamespace(namespace string) *BulkGetLocaleItemsParams

WithNamespace adds the namespace to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithRegion 

func (o *BulkGetLocaleItemsParams) WithRegion(region *string) *BulkGetLocaleItemsParams

WithRegion adds the region to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithStoreID 

func (o *BulkGetLocaleItemsParams) WithStoreID(storeID *string) *BulkGetLocaleItemsParams

WithStoreID adds the storeID to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WithTimeout 

func (o *BulkGetLocaleItemsParams) WithTimeout(timeout time.Duration) *BulkGetLocaleItemsParams

WithTimeout adds the timeout to the bulk get locale items params

func (*BulkGetLocaleItemsParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type BulkGetLocaleItemsReader 

type BulkGetLocaleItemsReader struct {
	// contains filtered or unexported fields
}

BulkGetLocaleItemsReader is a Reader for the BulkGetLocaleItems structure.

func (*BulkGetLocaleItemsReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client for item API

func (*Client) AcquireItem 

func (a *Client) AcquireItem(params *AcquireItemParams, authInfo runtime.ClientAuthInfoWriter) (*AcquireItemOK, *AcquireItemNotFound, error)

AcquireItem acquires item

<b>[SERVICE COMMUNICATION ONLY]</b> This api is used for acquiring a published item while the item is maxCount limited, it will decrease the sale available count.<br>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: acquire result</li></ul>

func (*Client) BulkGetLocaleItems 

func (a *Client) BulkGetLocaleItems(params *BulkGetLocaleItemsParams, authInfo runtime.ClientAuthInfoWriter) (*BulkGetLocaleItemsOK, error)

BulkGetLocaleItems bulks get locale items

This API is used to bulk get locale items. If item not exist in specific region, default region item will return.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: the list of items info</li></ul>

func (*Client) CreateItem 

func (a *Client) CreateItem(params *CreateItemParams, authInfo runtime.ClientAuthInfoWriter) (*CreateItemCreated, *CreateItemBadRequest, *CreateItemNotFound, *CreateItemConflict, *CreateItemUnprocessableEntity, error)
  CreateItem creates an item

  This API is used to create an item. APP item only can created in publisher namespace.<p>An item create example:<p><pre><code>{
   "categoryPath": "/games",
   "localizations": \{
       "en": \{
           "title":"required",
           "description":"optional",
           "longDescription":"optional",
           "localExt": \{
                  "properties":\[
                                   \{
                                       "key1":"value1",
                                       "key2":"value2"
                                   \}
                  \],
                  "functions":\[
                                   \{
                                       "key1":"value1",
                                       "key2":"value2"
                                   \}
                 \]
           \}
        \}
   \},
   "images": \[
     \{
           "as":"optional, image for",
           "caption":"optional",
           "height":10,
           "width":10,
           "imageUrl":"http://img-url-required",
           "smallImageUrl":"http://small-img-url-required"
     \}
   \],
   "thumbnailUrl": "optional, thumbnail url",
   "status": "ACTIVE",
   "itemType": "APP(allowed: [APP,COINS,INGAMEITEM,CODE,BUNDLE])",
   "name": "required, also will be used as entitlement name",
   "entitlementType": "DURABLE(allowed:[DURABLE,CONSUMABLE], should be CONSUMABLE when item type is COINS)",
   "useCount": 1(optional, required if the entitlement type is consumable),
   "stackable": false,
   "appId": "optional, required if itemType is APP",
   "appType": "GAME(optional, required if itemType is APP)",
   "baseAppId": "optional, set value of game app id if you want to link to a game",
   "targetCurrencyCode": "optional, required if itemType is COINS",
   "targetNamespace": "optional, required when itemType is INGAMEITEM, the targetNamespace will only take effect when the item
   created belongs to the publisher namespace",
   "sku": "optional, commonly unique item code",
   "regionData": \{
       "US(store's default region is required)": \[
         \{
            "price":10,
            "discountPercentage": 0(integer, optional, range[0,100], discountedPrice = price  \* ((100 - discountPercentage) \* 0.01),
              will use it to calculate discounted price if it is not 0),
            "discountAmount":0(integer, optional, range[0,itemPrice], will use it to calculate discounted price if discountPercentage is 0),
            "currencyCode":"code(required, example: USD)",
            "currencyNamespace":"test-ns-required",
            "trialPrice":5(required while fixedTrialCycles set, should >=0 and <= price, will same as price if not present),
            "purchaseAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
            "expireAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
            "discountPurchaseAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
            "discountExpireAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
         \}
       \]
   \},
   "itemIds": \[
       "itemId"
   \],
   "recurring": \{
       "cycle":"MONTHLY(allowed: [WEEKLY,MONTHLY,QUARTERLY,YEARLY])",
       "fixedFreeDays":0(integer, fixed free days, 0 means not set),
       "fixedTrialCycles":0(integer, fixed trial cycles, 0 means not set, will not take effect if fixedFreeDays set),
       "graceDays":7(integer, recurring grace days, retry recurring charge within configured days if charge fail, default 7)
   \},
   "tags": \[
       "tag"
   \],
   "features": \[
       "feature"
   \],
   "clazz": "weapon",
   "boothName": "C_campaign1",
   "displayOrder": 1000,
   "ext": \{
       "properties":\[
           \{
               "key1":"value1",
               "key2":"value2"
           \}
       \],
       "functions":\[
           \{
               "key1":"value1",
               "key2":"value2"
           \}
       \]
   \},
   "maxCountPerUser": 1(integer, optional, -1 means UNLIMITED),
   "maxCount": 1(integer, optional, -1 means UNLIMITED, unset when itemType is CODE)
}</code></pre>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=1 (CREATE)</li><li><i>Returns</i>: created item data</li></ul>

func (*Client) DefeatureItem 

func (a *Client) DefeatureItem(params *DefeatureItemParams, authInfo runtime.ClientAuthInfoWriter) (*DefeatureItemOK, *DefeatureItemNotFound, *DefeatureItemConflict, error)

DefeatureItem defeatures an item

Remove a feature from an item.<br>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: updated item</li></ul>

func (*Client) DeleteItem 

func (a *Client) DeleteItem(params *DeleteItemParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteItemNoContent, *DeleteItemNotFound, error)

DeleteItem deletes an item

This API is used to delete an item permanently, usually for test purpose.<b>DO NOT delete already published item.</b><p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=8 (DELETE)</li></ul>

func (*Client) DisableItem 

func (a *Client) DisableItem(params *DisableItemParams, authInfo runtime.ClientAuthInfoWriter) (*DisableItemOK, *DisableItemNotFound, *DisableItemConflict, error)

DisableItem disables an item

Disable an item.<br>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: updated item</li></ul>

func (*Client) EnableItem 

func (a *Client) EnableItem(params *EnableItemParams, authInfo runtime.ClientAuthInfoWriter) (*EnableItemOK, *EnableItemNotFound, *EnableItemConflict, error)

EnableItem enables an item

Enable an item.<br>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: updated item</li></ul>

func (*Client) FeatureItem 

func (a *Client) FeatureItem(params *FeatureItemParams, authInfo runtime.ClientAuthInfoWriter) (*FeatureItemOK, *FeatureItemNotFound, *FeatureItemConflict, error)

FeatureItem features an item

Add a feature to an item.<br>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: updated item</li></ul>

func (*Client) GetApp 

func (a *Client) GetApp(params *GetAppParams, authInfo runtime.ClientAuthInfoWriter) (*GetAppOK, error)

GetApp gets an app info

This API is used to get an app info.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: app data</li></ul>

func (*Client) GetItem 

func (a *Client) GetItem(params *GetItemParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemOK, *GetItemNotFound, error)

GetItem gets an item

This API is used to get an item.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: item data</li></ul>

func (*Client) GetItemByAppID 

func (a *Client) GetItemByAppID(params *GetItemByAppIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemByAppIDOK, *GetItemByAppIDNotFound, error)

GetItemByAppID gets item by app Id

This API is used to get the item by appId.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)<li><i>Returns</i>: the item with that appId</li></ul>

func (*Client) GetItemBySku 

func (a *Client) GetItemBySku(params *GetItemBySkuParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemBySkuOK, *GetItemBySkuNotFound, error)

GetItemBySku gets item by sku

This API is used to get the item by sku.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)<li><i>Returns</i>: the item with sku</li></ul>

func (*Client) GetItemDynamicData 

func (a *Client) GetItemDynamicData(params *GetItemDynamicDataParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemDynamicDataOK, *GetItemDynamicDataNotFound, error)

GetItemDynamicData gets item dynamic data

Get item dynamic data for published item.<br>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: item dynamic data</li></ul>

func (*Client) GetItemIDBySku 

func (a *Client) GetItemIDBySku(params *GetItemIDBySkuParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemIDBySkuOK, *GetItemIDBySkuNotFound, error)

GetItemIDBySku gets item Id by sku

<b>[SERVICE COMMUNICATION ONLY]</b> This API is used to get the itemId by sku.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)<li><i>Returns</i>: the itemId with sku</li></ul>

func (*Client) GetLocaleItem 

func (a *Client) GetLocaleItem(params *GetLocaleItemParams, authInfo runtime.ClientAuthInfoWriter) (*GetLocaleItemOK, *GetLocaleItemNotFound, error)

GetLocaleItem gets an item in locale

This API is used to get an item in specific locale. If item not exist in specific region, default region item will return.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: item data</li></ul>

func (*Client) GetLocaleItemBySku 

func (a *Client) GetLocaleItemBySku(params *GetLocaleItemBySkuParams, authInfo runtime.ClientAuthInfoWriter) (*GetLocaleItemBySkuOK, *GetLocaleItemBySkuNotFound, error)

GetLocaleItemBySku gets an item by sku in locale

This API is used to get an item by sku in specific locale. If item not exist in specific region, default region item will return.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: item data</li></ul>

func (*Client) ListBasicItemsByFeatures 

func (a *Client) ListBasicItemsByFeatures(params *ListBasicItemsByFeaturesParams, authInfo runtime.ClientAuthInfoWriter) (*ListBasicItemsByFeaturesOK, error)

ListBasicItemsByFeatures lists basic items by features

<b>[SERVICE COMMUNICATION ONLY]</b> This API is used to list basic items by features.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: the list of basic items</li></ul>

func (*Client) PublicBulkGetItems 

func (a *Client) PublicBulkGetItems(params *PublicBulkGetItemsParams) (*PublicBulkGetItemsOK, error)

PublicBulkGetItems bulks get locale items

This API is used to bulk get locale items. If item not exist in specific region, default region item will return.<p>Other detail info: <ul><li><i>Optional permission</i>: resource="SANDBOX", action=1(CREATE) (user with this permission can view draft store items)</li><li><i>Returns</i>: the list of items info</li></ul>

func (*Client) PublicGetApp 

func (a *Client) PublicGetApp(params *PublicGetAppParams) (*PublicGetAppOK, *PublicGetAppNotFound, error)

PublicGetApp gets an app in locale

This API is used to get an app in locale. If app not exist in specific region, default region app will return.<p>Other detail info: <ul><li><i>Optional permission</i>: resource="SANDBOX", action=1(CREATE) (user with this permission can view draft store app)</li><li><i>Returns</i>: app data</li></ul>

func (*Client) PublicGetItem 

func (a *Client) PublicGetItem(params *PublicGetItemParams) (*PublicGetItemOK, *PublicGetItemNotFound, error)

PublicGetItem gets an item in locale

This API is used to get an item in locale. If item not exist in specific region, default region item will return.<p>Other detail info: <ul><li><i>Optional permission</i>: resource="SANDBOX", action=1(CREATE) (user with this permission can view draft store item)</li><li><i>Returns</i>: item data</li></ul>

func (*Client) PublicGetItemByAppID 

func (a *Client) PublicGetItemByAppID(params *PublicGetItemByAppIDParams) (*PublicGetItemByAppIDOK, *PublicGetItemByAppIDNotFound, error)

PublicGetItemByAppID gets item by app Id

This API is used to get item by appId.<p>Other detail info: <ul><li><i>Optional permission</i>: resource="SANDBOX", action=1(CREATE) (user with this permission can view draft store item)</li><li><i>Returns</i>: the item with that appId</li></ul>

func (*Client) PublicGetItemBySku 

func (a *Client) PublicGetItemBySku(params *PublicGetItemBySkuParams) (*PublicGetItemBySkuOK, *PublicGetItemBySkuNotFound, error)

PublicGetItemBySku gets item by sku

This API is used to get the item by sku.<p>Other detail info: <ul><li><i>Optional permission</i>: resource="SANDBOX", action=1(CREATE) (user with this permission can view draft store item)</li><li><i>Returns</i>: the item with sku</li></ul>

func (*Client) PublicGetItemDynamicData 

func (a *Client) PublicGetItemDynamicData(params *PublicGetItemDynamicDataParams) (*PublicGetItemDynamicDataOK, *PublicGetItemDynamicDataNotFound, error)

PublicGetItemDynamicData gets item dynamic data

Get item dynamic data for a published item.<br>Other detail info: <ul><li><i>Returns</i>: item dynamic data</li></ul>

func (*Client) PublicQueryItems 

func (a *Client) PublicQueryItems(params *PublicQueryItemsParams) (*PublicQueryItemsOK, *PublicQueryItemsNotFound, *PublicQueryItemsUnprocessableEntity, error)

PublicQueryItems queries items by criteria

This API is used to query items by criteria within a store. If item not exist in specific region, default region item will return.<p>Other detail info: <ul><li><i>Optional permission</i>: resource="SANDBOX", action=1(CREATE) (user with this permission can view draft store item)</li><li><i>Returns</i>: the list of items</li></ul>

func (*Client) PublicSearchItems 

func (a *Client) PublicSearchItems(params *PublicSearchItemsParams) (*PublicSearchItemsOK, error)

PublicSearchItems searches items by keyword

This API is used to search items by keyword in title, description and long description, It's language constrained, also if item not exist in specific region, default region item will return.<p>Other detail info: <ul><li><i>Optional permission</i>: resource="SANDBOX", action=1(CREATE) (user with this permission can view draft store item)</li><li><i>Returns</i>: the list of items</li></ul>

func (*Client) QueryItems 

func (a *Client) QueryItems(params *QueryItemsParams, authInfo runtime.ClientAuthInfoWriter) (*QueryItemsOK, *QueryItemsNotFound, *QueryItemsUnprocessableEntity, error)

QueryItems queries items by criteria

This API is used to query items by criteria within a store.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: the list of items</li></ul>

func (*Client) QueryUncategorizedItems 

func (a *Client) QueryUncategorizedItems(params *QueryUncategorizedItemsParams, authInfo runtime.ClientAuthInfoWriter) (*QueryUncategorizedItemsOK, *QueryUncategorizedItemsNotFound, *QueryUncategorizedItemsUnprocessableEntity, error)

QueryUncategorizedItems queries uncategorized items

This API is used to query uncategorized items within a store.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)</li><li><i>Returns</i>: the list of uncategorized items</li></ul>

func (*Client) ReturnItem 

func (a *Client) ReturnItem(params *ReturnItemParams, authInfo runtime.ClientAuthInfoWriter) (*ReturnItemNoContent, *ReturnItemNotFound, *ReturnItemUnprocessableEntity, error)

ReturnItem returns item

<b>[SERVICE COMMUNICATION ONLY]</b> This api is used for returning a published item while the item is maxCount limited, it will increase the sale available count if orderNo already acquired.<br>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li></ul>

func (*Client) SearchItems 

func (a *Client) SearchItems(params *SearchItemsParams, authInfo runtime.ClientAuthInfoWriter) (*SearchItemsOK, error)

SearchItems searches items by keyword

This API is used to search items by keyword in title, description and long description within a store.<p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=2 (READ)<li><i>Returns</i>: the list of items</li></ul>

func (*Client) SetTransport 

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

SetTransport changes the transport on the client

func (*Client) SyncInGameItem 

func (a *Client) SyncInGameItem(params *SyncInGameItemParams, authInfo runtime.ClientAuthInfoWriter) (*SyncInGameItemOK, *SyncInGameItemBadRequest, *SyncInGameItemNotFound, *SyncInGameItemConflict, *SyncInGameItemUnprocessableEntity, error)

SyncInGameItem syncs an in game item

This API is used to sync an in game item in game namespace to publisher namespace, at current BUNDLE can't be synced.<p>The synced item has an additional field targetItemId besides targetNamespace, mostly this item should not modified manually again. <p>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: item data</li></ul>

func (*Client) UpdateApp 

func (a *Client) UpdateApp(params *UpdateAppParams, authInfo runtime.ClientAuthInfoWriter) (*UpdateAppOK, *UpdateAppNotFound, *UpdateAppConflict, *UpdateAppUnprocessableEntity, error)
  UpdateApp updates an app

  This API is used to update an app.<p>An app update example:<p><pre><code>{
  "developer": "accelbyte",
  "publisher": "accelbyte",
  "websiteUrl": "http://accelbyte.io",
  "forumUrl": "http://accelbyte.io",
  "platforms": \["Windows(allowed values: Windows, MacOS, Linux, IOS, Android)"\],
  "platformRequirements": \{
    "Windows": \[
      \{
        "label":"minimum(can be minimum or recommended)",
        "osVersion":"os version",
        "processor":"processor",
        "ram":"RAM",
        "graphics":"graphics",
        "directXVersion":"directXVersion",
        "diskSpace":"diskSpace",
        "soundCard":"soundCard",
        "additionals":"additionals"
      \}
     \]
  \},
  "carousel": \[
    \{
      "type":"image(allowed values: image, video)",
      "videoSource":"generic(allowed values:generic, youtube, viemo)",
      "url":"url",
      "alt":"alternative url or text",
      "thumbnailUrl":"thumbnail url",
      "previewUrl":"preview url",
    \}
  \],
  "localizations": \{
    "en": \{
      "slogan":"slogan",
      "announcement":"announcement",
    \}
  \},
  "primaryGenre": "Action",
  "genres": \["Action", "Adventure"\],
  "players": \["Single"\],
  "releaseDate": "optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
}</code></pre>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: updated app data</li></ul>

func (*Client) UpdateItem 

func (a *Client) UpdateItem(params *UpdateItemParams, authInfo runtime.ClientAuthInfoWriter) (*UpdateItemOK, *UpdateItemBadRequest, *UpdateItemNotFound, *UpdateItemConflict, *UpdateItemUnprocessableEntity, error)
  UpdateItem updates an item

  This API is used to update an item.<p>An item update example:<p><pre><code>{
	"categoryPath": "/games",
	"localizations": \{
       "en": \{
           "title":"required",
           "description":"optional",
           "longDescription":"optional",
           "localExt": \{
                  "properties":\[
                                   \{
                                       "key1":"value1",
                                       "key2":"value2"
                                   \}
                  \],
                  "functions":\[
                                   \{
                                       "key1":"value1",
                                       "key2":"value2"
                                   \}
                 \]
           \}
       \}
   \},
   "images": \[
     \{
           "as":"optional, image for",
           "caption":"optional",
           "height":10,
           "width":10,
           "imageUrl":"http://img-url-required",
           "smallImageUrl":"http://small-img-url-required"
     \}
   \],
   "thumbnailUrl": "optional, thumbnail url",
   "status": "ACTIVE",
   "itemType": "APP(allowed: [APP,COINS,INGAMEITEM,CODE,BUNDLE])",
   "name": "optional",
   "entitlementType": "DURABLE(allowed:[DURABLE,CONSUMABLE], should be CONSUMABLE when item type is COINS)",
   "useCount": 1(optional, required if the entitlement type is consumable),
   "stackable": false,
   "appId": "optional, required if itemType is APP",
   "baseAppId": "optional, set value of game app id if you want to link to a game",
   "appType": "GAME(optional, required if itemType is APP)",
   "sku": "optional, commonly unique item code",
   "targetCurrencyCode": "optional, required if itemType is COINS",
   "targetNamespace": "optional, required when itemType is INGAMEITEM, the targetNamespace will only take effect when the item
   created belongs to the publisher namespace",
   "regionData": \{
       "US(store's default region is required)": \[
         \{
            "price":10,
            "discountPercentage":0(integer, optional, range[0,100], discountedPrice = price\*((100 - discountPercentage) \* 0.01),
              if it is not 0, will use it to calculate discounted price),
            "discountAmount":0(integer, optional, range[0,itemPrice], will use it to calculate discounted price if discountPercentage is 0),
            "currencyCode":"code(required, example: USD)",
            "currencyNamespace":"test-ns-required",
            "trialPrice":5(required while fixedTrialCycles set, should >=0 and <= price, will same as price if not present),
            "purchaseAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
            "expireAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
            "discountPurchaseAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
            "discountExpireAt":"optional yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
         \}
       \]
   \},
   "itemIds": \[
       "itemId"
   \],
   "recurring": \{
       "cycle":"MONTHLY(allowed: [WEEKLY,MONTHLY,QUARTERLY,YEARLY])",
       "fixedFreeDays":0(integer, fixed free days, 0 means not set),
       "fixedTrialCycles":0(integer, fixed trial cycles, 0 means not set, will not take effect if fixedFreeDays set),
       "graceDays":7(integer, recurring grace days, retry recurring charge within configured days if charge fail, default 7)
   \},
   "tags": \[
       "tag"
   \],
   "features": \[
       "feature"
   \],
   "clazz": "weapon",
   "boothName": "C_campaign1",
   "displayOrder": 1000,
   "ext": \{
       "properties":\[
           \{
               "key1":"value1",
               "key2":"value2"
           \}
       \],
       "functions":\[
           \{
               "key1":"value1",
               "key2":"value2"
           \}
       \]
   \},
   "maxCountPerUser": 1(integer, optional, -1 means UNLIMITED),
   "maxCount": 1(integer, optional, -1 means UNLIMITED, new value should >= old value if both old value and new value is
   limited, unset when item type is CODE)
}</code></pre>Other detail info: <ul><li><i>Required permission</i>: resource="ADMIN:NAMESPACE:{namespace}:ITEM", action=4 (UPDATE)</li><li><i>Returns</i>: updated item data</li></ul>

type ClientService 

type ClientService interface {
	AcquireItem(params *AcquireItemParams, authInfo runtime.ClientAuthInfoWriter) (*AcquireItemOK, *AcquireItemNotFound, error)

	BulkGetLocaleItems(params *BulkGetLocaleItemsParams, authInfo runtime.ClientAuthInfoWriter) (*BulkGetLocaleItemsOK, error)

	CreateItem(params *CreateItemParams, authInfo runtime.ClientAuthInfoWriter) (*CreateItemCreated, *CreateItemBadRequest, *CreateItemNotFound, *CreateItemConflict, *CreateItemUnprocessableEntity, error)

	DefeatureItem(params *DefeatureItemParams, authInfo runtime.ClientAuthInfoWriter) (*DefeatureItemOK, *DefeatureItemNotFound, *DefeatureItemConflict, error)

	DeleteItem(params *DeleteItemParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteItemNoContent, *DeleteItemNotFound, error)

	DisableItem(params *DisableItemParams, authInfo runtime.ClientAuthInfoWriter) (*DisableItemOK, *DisableItemNotFound, *DisableItemConflict, error)

	EnableItem(params *EnableItemParams, authInfo runtime.ClientAuthInfoWriter) (*EnableItemOK, *EnableItemNotFound, *EnableItemConflict, error)

	FeatureItem(params *FeatureItemParams, authInfo runtime.ClientAuthInfoWriter) (*FeatureItemOK, *FeatureItemNotFound, *FeatureItemConflict, error)

	GetApp(params *GetAppParams, authInfo runtime.ClientAuthInfoWriter) (*GetAppOK, error)

	GetItem(params *GetItemParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemOK, *GetItemNotFound, error)

	GetItemByAppID(params *GetItemByAppIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemByAppIDOK, *GetItemByAppIDNotFound, error)

	GetItemBySku(params *GetItemBySkuParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemBySkuOK, *GetItemBySkuNotFound, error)

	GetItemDynamicData(params *GetItemDynamicDataParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemDynamicDataOK, *GetItemDynamicDataNotFound, error)

	GetItemIDBySku(params *GetItemIDBySkuParams, authInfo runtime.ClientAuthInfoWriter) (*GetItemIDBySkuOK, *GetItemIDBySkuNotFound, error)

	GetLocaleItem(params *GetLocaleItemParams, authInfo runtime.ClientAuthInfoWriter) (*GetLocaleItemOK, *GetLocaleItemNotFound, error)

	GetLocaleItemBySku(params *GetLocaleItemBySkuParams, authInfo runtime.ClientAuthInfoWriter) (*GetLocaleItemBySkuOK, *GetLocaleItemBySkuNotFound, error)

	ListBasicItemsByFeatures(params *ListBasicItemsByFeaturesParams, authInfo runtime.ClientAuthInfoWriter) (*ListBasicItemsByFeaturesOK, error)

	PublicBulkGetItems(params *PublicBulkGetItemsParams) (*PublicBulkGetItemsOK, error)

	PublicGetApp(params *PublicGetAppParams) (*PublicGetAppOK, *PublicGetAppNotFound, error)

	PublicGetItem(params *PublicGetItemParams) (*PublicGetItemOK, *PublicGetItemNotFound, error)

	PublicGetItemByAppID(params *PublicGetItemByAppIDParams) (*PublicGetItemByAppIDOK, *PublicGetItemByAppIDNotFound, error)

	PublicGetItemBySku(params *PublicGetItemBySkuParams) (*PublicGetItemBySkuOK, *PublicGetItemBySkuNotFound, error)

	PublicGetItemDynamicData(params *PublicGetItemDynamicDataParams) (*PublicGetItemDynamicDataOK, *PublicGetItemDynamicDataNotFound, error)

	PublicQueryItems(params *PublicQueryItemsParams) (*PublicQueryItemsOK, *PublicQueryItemsNotFound, *PublicQueryItemsUnprocessableEntity, error)

	PublicSearchItems(params *PublicSearchItemsParams) (*PublicSearchItemsOK, error)

	QueryItems(params *QueryItemsParams, authInfo runtime.ClientAuthInfoWriter) (*QueryItemsOK, *QueryItemsNotFound, *QueryItemsUnprocessableEntity, error)

	QueryUncategorizedItems(params *QueryUncategorizedItemsParams, authInfo runtime.ClientAuthInfoWriter) (*QueryUncategorizedItemsOK, *QueryUncategorizedItemsNotFound, *QueryUncategorizedItemsUnprocessableEntity, error)

	ReturnItem(params *ReturnItemParams, authInfo runtime.ClientAuthInfoWriter) (*ReturnItemNoContent, *ReturnItemNotFound, *ReturnItemUnprocessableEntity, error)

	SearchItems(params *SearchItemsParams, authInfo runtime.ClientAuthInfoWriter) (*SearchItemsOK, error)

	SyncInGameItem(params *SyncInGameItemParams, authInfo runtime.ClientAuthInfoWriter) (*SyncInGameItemOK, *SyncInGameItemBadRequest, *SyncInGameItemNotFound, *SyncInGameItemConflict, *SyncInGameItemUnprocessableEntity, error)

	UpdateApp(params *UpdateAppParams, authInfo runtime.ClientAuthInfoWriter) (*UpdateAppOK, *UpdateAppNotFound, *UpdateAppConflict, *UpdateAppUnprocessableEntity, error)

	UpdateItem(params *UpdateItemParams, authInfo runtime.ClientAuthInfoWriter) (*UpdateItemOK, *UpdateItemBadRequest, *UpdateItemNotFound, *UpdateItemConflict, *UpdateItemUnprocessableEntity, error)

	SetTransport(transport runtime.ClientTransport)
}

ClientService is the interface for Client methods

func New 

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

New creates a new item API client.

type CreateItemBadRequest 

type CreateItemBadRequest struct {
	Payload *platformclientmodels.ErrorEntity
}

CreateItemBadRequest handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30322</td><td>Bundle item [{itemId}] can't be bundled</td></tr><tr><td>30325</td><td>Code item [{itemId}] can't be bundled</td></tr><tr><td>30326</td><td>Subscription item [{itemId}] can't be bundled</td></tr><tr><td>30021</td><td>Default language [{language}] required</td></tr><tr><td>30321</td><td>Invalid item discount amount</td></tr><tr><td>30022</td><td>Default region [{region}] is required</td></tr><tr><td>30323</td><td>Target namespace is required</td></tr><tr><td>30327</td><td>Invalid item trial price</td></tr></table>

func NewCreateItemBadRequest 

func NewCreateItemBadRequest() *CreateItemBadRequest

NewCreateItemBadRequest creates a CreateItemBadRequest with default headers values

func (*CreateItemBadRequest) Error 

func (o *CreateItemBadRequest) Error() string

func (*CreateItemBadRequest) GetPayload 

func (o *CreateItemBadRequest) GetPayload() *platformclientmodels.ErrorEntity

type CreateItemConflict 

type CreateItemConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

CreateItemConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr><tr><td>30373</td><td>ItemType [{itemType}] is not allowed in namespace [{namespace}]</td></tr></table>

func NewCreateItemConflict 

func NewCreateItemConflict() *CreateItemConflict

NewCreateItemConflict creates a CreateItemConflict with default headers values

func (*CreateItemConflict) Error 

func (o *CreateItemConflict) Error() string

func (*CreateItemConflict) GetPayload 

func (o *CreateItemConflict) GetPayload() *platformclientmodels.ErrorEntity

type CreateItemCreated 

type CreateItemCreated struct {
	Payload *platformclientmodels.FullItemInfo
}

CreateItemCreated handles this case with default header values. 

successful operation

func NewCreateItemCreated 

func NewCreateItemCreated() *CreateItemCreated

NewCreateItemCreated creates a CreateItemCreated with default headers values

func (*CreateItemCreated) Error 

func (o *CreateItemCreated) Error() string

func (*CreateItemCreated) GetPayload 

func (o *CreateItemCreated) GetPayload() *platformclientmodels.FullItemInfo

type CreateItemNotFound 

type CreateItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

CreateItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30241</td><td>Category [{categoryPath}] does not exist in namespace [{namespace}]</td></tr><tr><td>36141</td><td>Currency [{currencyCode}] does not exist in namespace [{namespace}]</td></tr><tr><td>30141</td><td>Store [{storeId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewCreateItemNotFound 

func NewCreateItemNotFound() *CreateItemNotFound

NewCreateItemNotFound creates a CreateItemNotFound with default headers values

func (*CreateItemNotFound) Error 

func (o *CreateItemNotFound) Error() string

func (*CreateItemNotFound) GetPayload 

func (o *CreateItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type CreateItemParams 

type CreateItemParams struct {

	/*Body*/
	Body *platformclientmodels.ItemCreate
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

CreateItemParams contains all the parameters to send to the API endpoint for the create item operation typically these are written to a http.Request

func NewCreateItemParams 

func NewCreateItemParams() *CreateItemParams

NewCreateItemParams creates a new CreateItemParams object with the default values initialized.

func NewCreateItemParamsWithContext 

func NewCreateItemParamsWithContext(ctx context.Context) *CreateItemParams

NewCreateItemParamsWithContext creates a new CreateItemParams object with the default values initialized, and the ability to set a context for a request

func NewCreateItemParamsWithHTTPClient 

func NewCreateItemParamsWithHTTPClient(client *http.Client) *CreateItemParams

NewCreateItemParamsWithHTTPClient creates a new CreateItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewCreateItemParamsWithTimeout 

func NewCreateItemParamsWithTimeout(timeout time.Duration) *CreateItemParams

NewCreateItemParamsWithTimeout creates a new CreateItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*CreateItemParams) SetBody 

func (o *CreateItemParams) SetBody(body *platformclientmodels.ItemCreate)

SetBody adds the body to the create item params

func (*CreateItemParams) SetContext 

func (o *CreateItemParams) SetContext(ctx context.Context)

SetContext adds the context to the create item params

func (*CreateItemParams) SetHTTPClient 

func (o *CreateItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the create item params

func (*CreateItemParams) SetNamespace 

func (o *CreateItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the create item params

func (*CreateItemParams) SetStoreID 

func (o *CreateItemParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the create item params

func (*CreateItemParams) SetTimeout 

func (o *CreateItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the create item params

func (*CreateItemParams) WithBody 

func (o *CreateItemParams) WithBody(body *platformclientmodels.ItemCreate) *CreateItemParams

WithBody adds the body to the create item params

func (*CreateItemParams) WithContext 

func (o *CreateItemParams) WithContext(ctx context.Context) *CreateItemParams

WithContext adds the context to the create item params

func (*CreateItemParams) WithHTTPClient 

func (o *CreateItemParams) WithHTTPClient(client *http.Client) *CreateItemParams

WithHTTPClient adds the HTTPClient to the create item params

func (*CreateItemParams) WithNamespace 

func (o *CreateItemParams) WithNamespace(namespace string) *CreateItemParams

WithNamespace adds the namespace to the create item params

func (*CreateItemParams) WithStoreID 

func (o *CreateItemParams) WithStoreID(storeID string) *CreateItemParams

WithStoreID adds the storeID to the create item params

func (*CreateItemParams) WithTimeout 

func (o *CreateItemParams) WithTimeout(timeout time.Duration) *CreateItemParams

WithTimeout adds the timeout to the create item params

func (*CreateItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type CreateItemReader 

type CreateItemReader struct {
	// contains filtered or unexported fields
}

CreateItemReader is a Reader for the CreateItem structure.

func (*CreateItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type CreateItemUnprocessableEntity 

type CreateItemUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

CreateItemUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewCreateItemUnprocessableEntity 

func NewCreateItemUnprocessableEntity() *CreateItemUnprocessableEntity

NewCreateItemUnprocessableEntity creates a CreateItemUnprocessableEntity with default headers values

func (*CreateItemUnprocessableEntity) Error 

func (o *CreateItemUnprocessableEntity) Error() string

func (*CreateItemUnprocessableEntity) GetPayload 

func (o *CreateItemUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

type DefeatureItemConflict 

type DefeatureItemConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

DefeatureItemConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr></table>

func NewDefeatureItemConflict 

func NewDefeatureItemConflict() *DefeatureItemConflict

NewDefeatureItemConflict creates a DefeatureItemConflict with default headers values

func (*DefeatureItemConflict) Error 

func (o *DefeatureItemConflict) Error() string

func (*DefeatureItemConflict) GetPayload 

func (o *DefeatureItemConflict) GetPayload() *platformclientmodels.ErrorEntity

type DefeatureItemNotFound 

type DefeatureItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

DefeatureItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewDefeatureItemNotFound 

func NewDefeatureItemNotFound() *DefeatureItemNotFound

NewDefeatureItemNotFound creates a DefeatureItemNotFound with default headers values

func (*DefeatureItemNotFound) Error 

func (o *DefeatureItemNotFound) Error() string

func (*DefeatureItemNotFound) GetPayload 

func (o *DefeatureItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type DefeatureItemOK 

type DefeatureItemOK struct {
	Payload *platformclientmodels.FullItemInfo
}

DefeatureItemOK handles this case with default header values. 

successful operation

func NewDefeatureItemOK 

func NewDefeatureItemOK() *DefeatureItemOK

NewDefeatureItemOK creates a DefeatureItemOK with default headers values

func (*DefeatureItemOK) Error 

func (o *DefeatureItemOK) Error() string

func (*DefeatureItemOK) GetPayload 

func (o *DefeatureItemOK) GetPayload() *platformclientmodels.FullItemInfo

type DefeatureItemParams 

type DefeatureItemParams struct {

	/*Feature*/
	Feature string
	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

DefeatureItemParams contains all the parameters to send to the API endpoint for the defeature item operation typically these are written to a http.Request

func NewDefeatureItemParams 

func NewDefeatureItemParams() *DefeatureItemParams

NewDefeatureItemParams creates a new DefeatureItemParams object with the default values initialized.

func NewDefeatureItemParamsWithContext 

func NewDefeatureItemParamsWithContext(ctx context.Context) *DefeatureItemParams

NewDefeatureItemParamsWithContext creates a new DefeatureItemParams object with the default values initialized, and the ability to set a context for a request

func NewDefeatureItemParamsWithHTTPClient 

func NewDefeatureItemParamsWithHTTPClient(client *http.Client) *DefeatureItemParams

NewDefeatureItemParamsWithHTTPClient creates a new DefeatureItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewDefeatureItemParamsWithTimeout 

func NewDefeatureItemParamsWithTimeout(timeout time.Duration) *DefeatureItemParams

NewDefeatureItemParamsWithTimeout creates a new DefeatureItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*DefeatureItemParams) SetContext 

func (o *DefeatureItemParams) SetContext(ctx context.Context)

SetContext adds the context to the defeature item params

func (*DefeatureItemParams) SetFeature 

func (o *DefeatureItemParams) SetFeature(feature string)

SetFeature adds the feature to the defeature item params

func (*DefeatureItemParams) SetHTTPClient 

func (o *DefeatureItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the defeature item params

func (*DefeatureItemParams) SetItemID 

func (o *DefeatureItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the defeature item params

func (*DefeatureItemParams) SetNamespace 

func (o *DefeatureItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the defeature item params

func (*DefeatureItemParams) SetStoreID 

func (o *DefeatureItemParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the defeature item params

func (*DefeatureItemParams) SetTimeout 

func (o *DefeatureItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the defeature item params

func (*DefeatureItemParams) WithContext 

func (o *DefeatureItemParams) WithContext(ctx context.Context) *DefeatureItemParams

WithContext adds the context to the defeature item params

func (*DefeatureItemParams) WithFeature 

func (o *DefeatureItemParams) WithFeature(feature string) *DefeatureItemParams

WithFeature adds the feature to the defeature item params

func (*DefeatureItemParams) WithHTTPClient 

func (o *DefeatureItemParams) WithHTTPClient(client *http.Client) *DefeatureItemParams

WithHTTPClient adds the HTTPClient to the defeature item params

func (*DefeatureItemParams) WithItemID 

func (o *DefeatureItemParams) WithItemID(itemID string) *DefeatureItemParams

WithItemID adds the itemID to the defeature item params

func (*DefeatureItemParams) WithNamespace 

func (o *DefeatureItemParams) WithNamespace(namespace string) *DefeatureItemParams

WithNamespace adds the namespace to the defeature item params

func (*DefeatureItemParams) WithStoreID 

func (o *DefeatureItemParams) WithStoreID(storeID string) *DefeatureItemParams

WithStoreID adds the storeID to the defeature item params

func (*DefeatureItemParams) WithTimeout 

func (o *DefeatureItemParams) WithTimeout(timeout time.Duration) *DefeatureItemParams

WithTimeout adds the timeout to the defeature item params

func (*DefeatureItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type DefeatureItemReader 

type DefeatureItemReader struct {
	// contains filtered or unexported fields
}

DefeatureItemReader is a Reader for the DefeatureItem structure.

func (*DefeatureItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type DeleteItemNoContent 

type DeleteItemNoContent struct {
}

DeleteItemNoContent handles this case with default header values. 

Delete item successfully

func NewDeleteItemNoContent 

func NewDeleteItemNoContent() *DeleteItemNoContent

NewDeleteItemNoContent creates a DeleteItemNoContent with default headers values

func (*DeleteItemNoContent) Error 

func (o *DeleteItemNoContent) Error() string

type DeleteItemNotFound 

type DeleteItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

DeleteItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewDeleteItemNotFound 

func NewDeleteItemNotFound() *DeleteItemNotFound

NewDeleteItemNotFound creates a DeleteItemNotFound with default headers values

func (*DeleteItemNotFound) Error 

func (o *DeleteItemNotFound) Error() string

func (*DeleteItemNotFound) GetPayload 

func (o *DeleteItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type DeleteItemParams 

type DeleteItemParams struct {

	/*ItemID*/
	ItemID string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

DeleteItemParams contains all the parameters to send to the API endpoint for the delete item operation typically these are written to a http.Request

func NewDeleteItemParams 

func NewDeleteItemParams() *DeleteItemParams

NewDeleteItemParams creates a new DeleteItemParams object with the default values initialized.

func NewDeleteItemParamsWithContext 

func NewDeleteItemParamsWithContext(ctx context.Context) *DeleteItemParams

NewDeleteItemParamsWithContext creates a new DeleteItemParams object with the default values initialized, and the ability to set a context for a request

func NewDeleteItemParamsWithHTTPClient 

func NewDeleteItemParamsWithHTTPClient(client *http.Client) *DeleteItemParams

NewDeleteItemParamsWithHTTPClient creates a new DeleteItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewDeleteItemParamsWithTimeout 

func NewDeleteItemParamsWithTimeout(timeout time.Duration) *DeleteItemParams

NewDeleteItemParamsWithTimeout creates a new DeleteItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*DeleteItemParams) SetContext 

func (o *DeleteItemParams) SetContext(ctx context.Context)

SetContext adds the context to the delete item params

func (*DeleteItemParams) SetHTTPClient 

func (o *DeleteItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the delete item params

func (*DeleteItemParams) SetItemID 

func (o *DeleteItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the delete item params

func (*DeleteItemParams) SetNamespace 

func (o *DeleteItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the delete item params

func (*DeleteItemParams) SetStoreID 

func (o *DeleteItemParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the delete item params

func (*DeleteItemParams) SetTimeout 

func (o *DeleteItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the delete item params

func (*DeleteItemParams) WithContext 

func (o *DeleteItemParams) WithContext(ctx context.Context) *DeleteItemParams

WithContext adds the context to the delete item params

func (*DeleteItemParams) WithHTTPClient 

func (o *DeleteItemParams) WithHTTPClient(client *http.Client) *DeleteItemParams

WithHTTPClient adds the HTTPClient to the delete item params

func (*DeleteItemParams) WithItemID 

func (o *DeleteItemParams) WithItemID(itemID string) *DeleteItemParams

WithItemID adds the itemID to the delete item params

func (*DeleteItemParams) WithNamespace 

func (o *DeleteItemParams) WithNamespace(namespace string) *DeleteItemParams

WithNamespace adds the namespace to the delete item params

func (*DeleteItemParams) WithStoreID 

func (o *DeleteItemParams) WithStoreID(storeID *string) *DeleteItemParams

WithStoreID adds the storeID to the delete item params

func (*DeleteItemParams) WithTimeout 

func (o *DeleteItemParams) WithTimeout(timeout time.Duration) *DeleteItemParams

WithTimeout adds the timeout to the delete item params

func (*DeleteItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type DeleteItemReader 

type DeleteItemReader struct {
	// contains filtered or unexported fields
}

DeleteItemReader is a Reader for the DeleteItem structure.

func (*DeleteItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type DisableItemConflict 

type DisableItemConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

DisableItemConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr></table>

func NewDisableItemConflict 

func NewDisableItemConflict() *DisableItemConflict

NewDisableItemConflict creates a DisableItemConflict with default headers values

func (*DisableItemConflict) Error 

func (o *DisableItemConflict) Error() string

func (*DisableItemConflict) GetPayload 

func (o *DisableItemConflict) GetPayload() *platformclientmodels.ErrorEntity

type DisableItemNotFound 

type DisableItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

DisableItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewDisableItemNotFound 

func NewDisableItemNotFound() *DisableItemNotFound

NewDisableItemNotFound creates a DisableItemNotFound with default headers values

func (*DisableItemNotFound) Error 

func (o *DisableItemNotFound) Error() string

func (*DisableItemNotFound) GetPayload 

func (o *DisableItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type DisableItemOK 

type DisableItemOK struct {
	Payload *platformclientmodels.FullItemInfo
}

DisableItemOK handles this case with default header values. 

successful operation

func NewDisableItemOK 

func NewDisableItemOK() *DisableItemOK

NewDisableItemOK creates a DisableItemOK with default headers values

func (*DisableItemOK) Error 

func (o *DisableItemOK) Error() string

func (*DisableItemOK) GetPayload 

func (o *DisableItemOK) GetPayload() *platformclientmodels.FullItemInfo

type DisableItemParams 

type DisableItemParams struct {

	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

DisableItemParams contains all the parameters to send to the API endpoint for the disable item operation typically these are written to a http.Request

func NewDisableItemParams 

func NewDisableItemParams() *DisableItemParams

NewDisableItemParams creates a new DisableItemParams object with the default values initialized.

func NewDisableItemParamsWithContext 

func NewDisableItemParamsWithContext(ctx context.Context) *DisableItemParams

NewDisableItemParamsWithContext creates a new DisableItemParams object with the default values initialized, and the ability to set a context for a request

func NewDisableItemParamsWithHTTPClient 

func NewDisableItemParamsWithHTTPClient(client *http.Client) *DisableItemParams

NewDisableItemParamsWithHTTPClient creates a new DisableItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewDisableItemParamsWithTimeout 

func NewDisableItemParamsWithTimeout(timeout time.Duration) *DisableItemParams

NewDisableItemParamsWithTimeout creates a new DisableItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*DisableItemParams) SetContext 

func (o *DisableItemParams) SetContext(ctx context.Context)

SetContext adds the context to the disable item params

func (*DisableItemParams) SetHTTPClient 

func (o *DisableItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the disable item params

func (*DisableItemParams) SetItemID 

func (o *DisableItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the disable item params

func (*DisableItemParams) SetNamespace 

func (o *DisableItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the disable item params

func (*DisableItemParams) SetStoreID 

func (o *DisableItemParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the disable item params

func (*DisableItemParams) SetTimeout 

func (o *DisableItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the disable item params

func (*DisableItemParams) WithContext 

func (o *DisableItemParams) WithContext(ctx context.Context) *DisableItemParams

WithContext adds the context to the disable item params

func (*DisableItemParams) WithHTTPClient 

func (o *DisableItemParams) WithHTTPClient(client *http.Client) *DisableItemParams

WithHTTPClient adds the HTTPClient to the disable item params

func (*DisableItemParams) WithItemID 

func (o *DisableItemParams) WithItemID(itemID string) *DisableItemParams

WithItemID adds the itemID to the disable item params

func (*DisableItemParams) WithNamespace 

func (o *DisableItemParams) WithNamespace(namespace string) *DisableItemParams

WithNamespace adds the namespace to the disable item params

func (*DisableItemParams) WithStoreID 

func (o *DisableItemParams) WithStoreID(storeID string) *DisableItemParams

WithStoreID adds the storeID to the disable item params

func (*DisableItemParams) WithTimeout 

func (o *DisableItemParams) WithTimeout(timeout time.Duration) *DisableItemParams

WithTimeout adds the timeout to the disable item params

func (*DisableItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type DisableItemReader 

type DisableItemReader struct {
	// contains filtered or unexported fields
}

DisableItemReader is a Reader for the DisableItem structure.

func (*DisableItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type EnableItemConflict 

type EnableItemConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

EnableItemConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr></table>

func NewEnableItemConflict 

func NewEnableItemConflict() *EnableItemConflict

NewEnableItemConflict creates a EnableItemConflict with default headers values

func (*EnableItemConflict) Error 

func (o *EnableItemConflict) Error() string

func (*EnableItemConflict) GetPayload 

func (o *EnableItemConflict) GetPayload() *platformclientmodels.ErrorEntity

type EnableItemNotFound 

type EnableItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

EnableItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewEnableItemNotFound 

func NewEnableItemNotFound() *EnableItemNotFound

NewEnableItemNotFound creates a EnableItemNotFound with default headers values

func (*EnableItemNotFound) Error 

func (o *EnableItemNotFound) Error() string

func (*EnableItemNotFound) GetPayload 

func (o *EnableItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type EnableItemOK 

type EnableItemOK struct {
	Payload *platformclientmodels.FullItemInfo
}

EnableItemOK handles this case with default header values. 

successful operation

func NewEnableItemOK 

func NewEnableItemOK() *EnableItemOK

NewEnableItemOK creates a EnableItemOK with default headers values

func (*EnableItemOK) Error 

func (o *EnableItemOK) Error() string

func (*EnableItemOK) GetPayload 

func (o *EnableItemOK) GetPayload() *platformclientmodels.FullItemInfo

type EnableItemParams 

type EnableItemParams struct {

	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

EnableItemParams contains all the parameters to send to the API endpoint for the enable item operation typically these are written to a http.Request

func NewEnableItemParams 

func NewEnableItemParams() *EnableItemParams

NewEnableItemParams creates a new EnableItemParams object with the default values initialized.

func NewEnableItemParamsWithContext 

func NewEnableItemParamsWithContext(ctx context.Context) *EnableItemParams

NewEnableItemParamsWithContext creates a new EnableItemParams object with the default values initialized, and the ability to set a context for a request

func NewEnableItemParamsWithHTTPClient 

func NewEnableItemParamsWithHTTPClient(client *http.Client) *EnableItemParams

NewEnableItemParamsWithHTTPClient creates a new EnableItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewEnableItemParamsWithTimeout 

func NewEnableItemParamsWithTimeout(timeout time.Duration) *EnableItemParams

NewEnableItemParamsWithTimeout creates a new EnableItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*EnableItemParams) SetContext 

func (o *EnableItemParams) SetContext(ctx context.Context)

SetContext adds the context to the enable item params

func (*EnableItemParams) SetHTTPClient 

func (o *EnableItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the enable item params

func (*EnableItemParams) SetItemID 

func (o *EnableItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the enable item params

func (*EnableItemParams) SetNamespace 

func (o *EnableItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the enable item params

func (*EnableItemParams) SetStoreID 

func (o *EnableItemParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the enable item params

func (*EnableItemParams) SetTimeout 

func (o *EnableItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the enable item params

func (*EnableItemParams) WithContext 

func (o *EnableItemParams) WithContext(ctx context.Context) *EnableItemParams

WithContext adds the context to the enable item params

func (*EnableItemParams) WithHTTPClient 

func (o *EnableItemParams) WithHTTPClient(client *http.Client) *EnableItemParams

WithHTTPClient adds the HTTPClient to the enable item params

func (*EnableItemParams) WithItemID 

func (o *EnableItemParams) WithItemID(itemID string) *EnableItemParams

WithItemID adds the itemID to the enable item params

func (*EnableItemParams) WithNamespace 

func (o *EnableItemParams) WithNamespace(namespace string) *EnableItemParams

WithNamespace adds the namespace to the enable item params

func (*EnableItemParams) WithStoreID 

func (o *EnableItemParams) WithStoreID(storeID string) *EnableItemParams

WithStoreID adds the storeID to the enable item params

func (*EnableItemParams) WithTimeout 

func (o *EnableItemParams) WithTimeout(timeout time.Duration) *EnableItemParams

WithTimeout adds the timeout to the enable item params

func (*EnableItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type EnableItemReader 

type EnableItemReader struct {
	// contains filtered or unexported fields
}

EnableItemReader is a Reader for the EnableItem structure.

func (*EnableItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type FeatureItemConflict 

type FeatureItemConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

FeatureItemConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr></table>

func NewFeatureItemConflict 

func NewFeatureItemConflict() *FeatureItemConflict

NewFeatureItemConflict creates a FeatureItemConflict with default headers values

func (*FeatureItemConflict) Error 

func (o *FeatureItemConflict) Error() string

func (*FeatureItemConflict) GetPayload 

func (o *FeatureItemConflict) GetPayload() *platformclientmodels.ErrorEntity

type FeatureItemNotFound 

type FeatureItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

FeatureItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewFeatureItemNotFound 

func NewFeatureItemNotFound() *FeatureItemNotFound

NewFeatureItemNotFound creates a FeatureItemNotFound with default headers values

func (*FeatureItemNotFound) Error 

func (o *FeatureItemNotFound) Error() string

func (*FeatureItemNotFound) GetPayload 

func (o *FeatureItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type FeatureItemOK 

type FeatureItemOK struct {
	Payload *platformclientmodels.FullItemInfo
}

FeatureItemOK handles this case with default header values. 

successful operation

func NewFeatureItemOK 

func NewFeatureItemOK() *FeatureItemOK

NewFeatureItemOK creates a FeatureItemOK with default headers values

func (*FeatureItemOK) Error 

func (o *FeatureItemOK) Error() string

func (*FeatureItemOK) GetPayload 

func (o *FeatureItemOK) GetPayload() *platformclientmodels.FullItemInfo

type FeatureItemParams 

type FeatureItemParams struct {

	/*Feature*/
	Feature string
	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

FeatureItemParams contains all the parameters to send to the API endpoint for the feature item operation typically these are written to a http.Request

func NewFeatureItemParams 

func NewFeatureItemParams() *FeatureItemParams

NewFeatureItemParams creates a new FeatureItemParams object with the default values initialized.

func NewFeatureItemParamsWithContext 

func NewFeatureItemParamsWithContext(ctx context.Context) *FeatureItemParams

NewFeatureItemParamsWithContext creates a new FeatureItemParams object with the default values initialized, and the ability to set a context for a request

func NewFeatureItemParamsWithHTTPClient 

func NewFeatureItemParamsWithHTTPClient(client *http.Client) *FeatureItemParams

NewFeatureItemParamsWithHTTPClient creates a new FeatureItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewFeatureItemParamsWithTimeout 

func NewFeatureItemParamsWithTimeout(timeout time.Duration) *FeatureItemParams

NewFeatureItemParamsWithTimeout creates a new FeatureItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*FeatureItemParams) SetContext 

func (o *FeatureItemParams) SetContext(ctx context.Context)

SetContext adds the context to the feature item params

func (*FeatureItemParams) SetFeature 

func (o *FeatureItemParams) SetFeature(feature string)

SetFeature adds the feature to the feature item params

func (*FeatureItemParams) SetHTTPClient 

func (o *FeatureItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the feature item params

func (*FeatureItemParams) SetItemID 

func (o *FeatureItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the feature item params

func (*FeatureItemParams) SetNamespace 

func (o *FeatureItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the feature item params

func (*FeatureItemParams) SetStoreID 

func (o *FeatureItemParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the feature item params

func (*FeatureItemParams) SetTimeout 

func (o *FeatureItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the feature item params

func (*FeatureItemParams) WithContext 

func (o *FeatureItemParams) WithContext(ctx context.Context) *FeatureItemParams

WithContext adds the context to the feature item params

func (*FeatureItemParams) WithFeature 

func (o *FeatureItemParams) WithFeature(feature string) *FeatureItemParams

WithFeature adds the feature to the feature item params

func (*FeatureItemParams) WithHTTPClient 

func (o *FeatureItemParams) WithHTTPClient(client *http.Client) *FeatureItemParams

WithHTTPClient adds the HTTPClient to the feature item params

func (*FeatureItemParams) WithItemID 

func (o *FeatureItemParams) WithItemID(itemID string) *FeatureItemParams

WithItemID adds the itemID to the feature item params

func (*FeatureItemParams) WithNamespace 

func (o *FeatureItemParams) WithNamespace(namespace string) *FeatureItemParams

WithNamespace adds the namespace to the feature item params

func (*FeatureItemParams) WithStoreID 

func (o *FeatureItemParams) WithStoreID(storeID string) *FeatureItemParams

WithStoreID adds the storeID to the feature item params

func (*FeatureItemParams) WithTimeout 

func (o *FeatureItemParams) WithTimeout(timeout time.Duration) *FeatureItemParams

WithTimeout adds the timeout to the feature item params

func (*FeatureItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type FeatureItemReader 

type FeatureItemReader struct {
	// contains filtered or unexported fields
}

FeatureItemReader is a Reader for the FeatureItem structure.

func (*FeatureItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetAppOK 

type GetAppOK struct {
	Payload *platformclientmodels.FullAppInfo
}

GetAppOK handles this case with default header values. 

successful operation

func NewGetAppOK 

func NewGetAppOK() *GetAppOK

NewGetAppOK creates a GetAppOK with default headers values

func (*GetAppOK) Error 

func (o *GetAppOK) Error() string

func (*GetAppOK) GetPayload 

func (o *GetAppOK) GetPayload() *platformclientmodels.FullAppInfo

type GetAppParams 

type GetAppParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*ItemID*/
	ItemID string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetAppParams contains all the parameters to send to the API endpoint for the get app operation typically these are written to a http.Request

func NewGetAppParams 

func NewGetAppParams() *GetAppParams

NewGetAppParams creates a new GetAppParams object with the default values initialized.

func NewGetAppParamsWithContext 

func NewGetAppParamsWithContext(ctx context.Context) *GetAppParams

NewGetAppParamsWithContext creates a new GetAppParams object with the default values initialized, and the ability to set a context for a request

func NewGetAppParamsWithHTTPClient 

func NewGetAppParamsWithHTTPClient(client *http.Client) *GetAppParams

NewGetAppParamsWithHTTPClient creates a new GetAppParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetAppParamsWithTimeout 

func NewGetAppParamsWithTimeout(timeout time.Duration) *GetAppParams

NewGetAppParamsWithTimeout creates a new GetAppParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetAppParams) SetActiveOnly 

func (o *GetAppParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the get app params

func (*GetAppParams) SetContext 

func (o *GetAppParams) SetContext(ctx context.Context)

SetContext adds the context to the get app params

func (*GetAppParams) SetHTTPClient 

func (o *GetAppParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get app params

func (*GetAppParams) SetItemID 

func (o *GetAppParams) SetItemID(itemID string)

SetItemID adds the itemId to the get app params

func (*GetAppParams) SetNamespace 

func (o *GetAppParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get app params

func (*GetAppParams) SetStoreID 

func (o *GetAppParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the get app params

func (*GetAppParams) SetTimeout 

func (o *GetAppParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get app params

func (*GetAppParams) WithActiveOnly 

func (o *GetAppParams) WithActiveOnly(activeOnly *bool) *GetAppParams

WithActiveOnly adds the activeOnly to the get app params

func (*GetAppParams) WithContext 

func (o *GetAppParams) WithContext(ctx context.Context) *GetAppParams

WithContext adds the context to the get app params

func (*GetAppParams) WithHTTPClient 

func (o *GetAppParams) WithHTTPClient(client *http.Client) *GetAppParams

WithHTTPClient adds the HTTPClient to the get app params

func (*GetAppParams) WithItemID 

func (o *GetAppParams) WithItemID(itemID string) *GetAppParams

WithItemID adds the itemID to the get app params

func (*GetAppParams) WithNamespace 

func (o *GetAppParams) WithNamespace(namespace string) *GetAppParams

WithNamespace adds the namespace to the get app params

func (*GetAppParams) WithStoreID 

func (o *GetAppParams) WithStoreID(storeID *string) *GetAppParams

WithStoreID adds the storeID to the get app params

func (*GetAppParams) WithTimeout 

func (o *GetAppParams) WithTimeout(timeout time.Duration) *GetAppParams

WithTimeout adds the timeout to the get app params

func (*GetAppParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetAppReader 

type GetAppReader struct {
	// contains filtered or unexported fields
}

GetAppReader is a Reader for the GetApp structure.

func (*GetAppReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetItemByAppIDNotFound 

type GetItemByAppIDNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

GetItemByAppIDNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30342</td><td>Item of appId [{appId}] does not exist</td></tr></table>

func NewGetItemByAppIDNotFound 

func NewGetItemByAppIDNotFound() *GetItemByAppIDNotFound

NewGetItemByAppIDNotFound creates a GetItemByAppIDNotFound with default headers values

func (*GetItemByAppIDNotFound) Error 

func (o *GetItemByAppIDNotFound) Error() string

func (*GetItemByAppIDNotFound) GetPayload 

func (o *GetItemByAppIDNotFound) GetPayload() *platformclientmodels.ErrorEntity

type GetItemByAppIDOK 

type GetItemByAppIDOK struct {
	Payload *platformclientmodels.FullItemInfo
}

GetItemByAppIDOK handles this case with default header values. 

successful operation

func NewGetItemByAppIDOK 

func NewGetItemByAppIDOK() *GetItemByAppIDOK

NewGetItemByAppIDOK creates a GetItemByAppIDOK with default headers values

func (*GetItemByAppIDOK) Error 

func (o *GetItemByAppIDOK) Error() string

func (*GetItemByAppIDOK) GetPayload 

func (o *GetItemByAppIDOK) GetPayload() *platformclientmodels.FullItemInfo

type GetItemByAppIDParams 

type GetItemByAppIDParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*AppID*/
	AppID string
	/*Namespace*/
	Namespace string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetItemByAppIDParams contains all the parameters to send to the API endpoint for the get item by app Id operation typically these are written to a http.Request

func NewGetItemByAppIDParams 

func NewGetItemByAppIDParams() *GetItemByAppIDParams

NewGetItemByAppIDParams creates a new GetItemByAppIDParams object with the default values initialized.

func NewGetItemByAppIDParamsWithContext 

func NewGetItemByAppIDParamsWithContext(ctx context.Context) *GetItemByAppIDParams

NewGetItemByAppIDParamsWithContext creates a new GetItemByAppIDParams object with the default values initialized, and the ability to set a context for a request

func NewGetItemByAppIDParamsWithHTTPClient 

func NewGetItemByAppIDParamsWithHTTPClient(client *http.Client) *GetItemByAppIDParams

NewGetItemByAppIDParamsWithHTTPClient creates a new GetItemByAppIDParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetItemByAppIDParamsWithTimeout 

func NewGetItemByAppIDParamsWithTimeout(timeout time.Duration) *GetItemByAppIDParams

NewGetItemByAppIDParamsWithTimeout creates a new GetItemByAppIDParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetItemByAppIDParams) SetActiveOnly 

func (o *GetItemByAppIDParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the get item by app Id params

func (*GetItemByAppIDParams) SetAppID 

func (o *GetItemByAppIDParams) SetAppID(appID string)

SetAppID adds the appId to the get item by app Id params

func (*GetItemByAppIDParams) SetContext 

func (o *GetItemByAppIDParams) SetContext(ctx context.Context)

SetContext adds the context to the get item by app Id params

func (*GetItemByAppIDParams) SetHTTPClient 

func (o *GetItemByAppIDParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get item by app Id params

func (*GetItemByAppIDParams) SetNamespace 

func (o *GetItemByAppIDParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get item by app Id params

func (*GetItemByAppIDParams) SetStoreID 

func (o *GetItemByAppIDParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the get item by app Id params

func (*GetItemByAppIDParams) SetTimeout 

func (o *GetItemByAppIDParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get item by app Id params

func (*GetItemByAppIDParams) WithActiveOnly 

func (o *GetItemByAppIDParams) WithActiveOnly(activeOnly *bool) *GetItemByAppIDParams

WithActiveOnly adds the activeOnly to the get item by app Id params

func (*GetItemByAppIDParams) WithAppID 

func (o *GetItemByAppIDParams) WithAppID(appID string) *GetItemByAppIDParams

WithAppID adds the appID to the get item by app Id params

func (*GetItemByAppIDParams) WithContext 

func (o *GetItemByAppIDParams) WithContext(ctx context.Context) *GetItemByAppIDParams

WithContext adds the context to the get item by app Id params

func (*GetItemByAppIDParams) WithHTTPClient 

func (o *GetItemByAppIDParams) WithHTTPClient(client *http.Client) *GetItemByAppIDParams

WithHTTPClient adds the HTTPClient to the get item by app Id params

func (*GetItemByAppIDParams) WithNamespace 

func (o *GetItemByAppIDParams) WithNamespace(namespace string) *GetItemByAppIDParams

WithNamespace adds the namespace to the get item by app Id params

func (*GetItemByAppIDParams) WithStoreID 

func (o *GetItemByAppIDParams) WithStoreID(storeID *string) *GetItemByAppIDParams

WithStoreID adds the storeID to the get item by app Id params

func (*GetItemByAppIDParams) WithTimeout 

func (o *GetItemByAppIDParams) WithTimeout(timeout time.Duration) *GetItemByAppIDParams

WithTimeout adds the timeout to the get item by app Id params

func (*GetItemByAppIDParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetItemByAppIDReader 

type GetItemByAppIDReader struct {
	// contains filtered or unexported fields
}

GetItemByAppIDReader is a Reader for the GetItemByAppID structure.

func (*GetItemByAppIDReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetItemBySkuNotFound 

type GetItemBySkuNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

GetItemBySkuNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30343</td><td>Item of sku [{sku}] does not exist</td></tr></table>

func NewGetItemBySkuNotFound 

func NewGetItemBySkuNotFound() *GetItemBySkuNotFound

NewGetItemBySkuNotFound creates a GetItemBySkuNotFound with default headers values

func (*GetItemBySkuNotFound) Error 

func (o *GetItemBySkuNotFound) Error() string

func (*GetItemBySkuNotFound) GetPayload 

func (o *GetItemBySkuNotFound) GetPayload() *platformclientmodels.ErrorEntity

type GetItemBySkuOK 

type GetItemBySkuOK struct {
	Payload *platformclientmodels.FullItemInfo
}

GetItemBySkuOK handles this case with default header values. 

successful operation

func NewGetItemBySkuOK 

func NewGetItemBySkuOK() *GetItemBySkuOK

NewGetItemBySkuOK creates a GetItemBySkuOK with default headers values

func (*GetItemBySkuOK) Error 

func (o *GetItemBySkuOK) Error() string

func (*GetItemBySkuOK) GetPayload 

func (o *GetItemBySkuOK) GetPayload() *platformclientmodels.FullItemInfo

type GetItemBySkuParams 

type GetItemBySkuParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*Namespace*/
	Namespace string
	/*Sku*/
	Sku string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetItemBySkuParams contains all the parameters to send to the API endpoint for the get item by sku operation typically these are written to a http.Request

func NewGetItemBySkuParams 

func NewGetItemBySkuParams() *GetItemBySkuParams

NewGetItemBySkuParams creates a new GetItemBySkuParams object with the default values initialized.

func NewGetItemBySkuParamsWithContext 

func NewGetItemBySkuParamsWithContext(ctx context.Context) *GetItemBySkuParams

NewGetItemBySkuParamsWithContext creates a new GetItemBySkuParams object with the default values initialized, and the ability to set a context for a request

func NewGetItemBySkuParamsWithHTTPClient 

func NewGetItemBySkuParamsWithHTTPClient(client *http.Client) *GetItemBySkuParams

NewGetItemBySkuParamsWithHTTPClient creates a new GetItemBySkuParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetItemBySkuParamsWithTimeout 

func NewGetItemBySkuParamsWithTimeout(timeout time.Duration) *GetItemBySkuParams

NewGetItemBySkuParamsWithTimeout creates a new GetItemBySkuParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetItemBySkuParams) SetActiveOnly 

func (o *GetItemBySkuParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the get item by sku params

func (*GetItemBySkuParams) SetContext 

func (o *GetItemBySkuParams) SetContext(ctx context.Context)

SetContext adds the context to the get item by sku params

func (*GetItemBySkuParams) SetHTTPClient 

func (o *GetItemBySkuParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get item by sku params

func (*GetItemBySkuParams) SetNamespace 

func (o *GetItemBySkuParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get item by sku params

func (*GetItemBySkuParams) SetSku 

func (o *GetItemBySkuParams) SetSku(sku string)

SetSku adds the sku to the get item by sku params

func (*GetItemBySkuParams) SetStoreID 

func (o *GetItemBySkuParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the get item by sku params

func (*GetItemBySkuParams) SetTimeout 

func (o *GetItemBySkuParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get item by sku params

func (*GetItemBySkuParams) WithActiveOnly 

func (o *GetItemBySkuParams) WithActiveOnly(activeOnly *bool) *GetItemBySkuParams

WithActiveOnly adds the activeOnly to the get item by sku params

func (*GetItemBySkuParams) WithContext 

func (o *GetItemBySkuParams) WithContext(ctx context.Context) *GetItemBySkuParams

WithContext adds the context to the get item by sku params

func (*GetItemBySkuParams) WithHTTPClient 

func (o *GetItemBySkuParams) WithHTTPClient(client *http.Client) *GetItemBySkuParams

WithHTTPClient adds the HTTPClient to the get item by sku params

func (*GetItemBySkuParams) WithNamespace 

func (o *GetItemBySkuParams) WithNamespace(namespace string) *GetItemBySkuParams

WithNamespace adds the namespace to the get item by sku params

func (*GetItemBySkuParams) WithSku 

func (o *GetItemBySkuParams) WithSku(sku string) *GetItemBySkuParams

WithSku adds the sku to the get item by sku params

func (*GetItemBySkuParams) WithStoreID 

func (o *GetItemBySkuParams) WithStoreID(storeID *string) *GetItemBySkuParams

WithStoreID adds the storeID to the get item by sku params

func (*GetItemBySkuParams) WithTimeout 

func (o *GetItemBySkuParams) WithTimeout(timeout time.Duration) *GetItemBySkuParams

WithTimeout adds the timeout to the get item by sku params

func (*GetItemBySkuParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetItemBySkuReader 

type GetItemBySkuReader struct {
	// contains filtered or unexported fields
}

GetItemBySkuReader is a Reader for the GetItemBySku structure.

func (*GetItemBySkuReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetItemDynamicDataNotFound 

type GetItemDynamicDataNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

GetItemDynamicDataNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewGetItemDynamicDataNotFound 

func NewGetItemDynamicDataNotFound() *GetItemDynamicDataNotFound

NewGetItemDynamicDataNotFound creates a GetItemDynamicDataNotFound with default headers values

func (*GetItemDynamicDataNotFound) Error 

func (o *GetItemDynamicDataNotFound) Error() string

func (*GetItemDynamicDataNotFound) GetPayload 

func (o *GetItemDynamicDataNotFound) GetPayload() *platformclientmodels.ErrorEntity

type GetItemDynamicDataOK 

type GetItemDynamicDataOK struct {
	Payload *platformclientmodels.ItemDynamicDataInfo
}

GetItemDynamicDataOK handles this case with default header values. 

successful operation

func NewGetItemDynamicDataOK 

func NewGetItemDynamicDataOK() *GetItemDynamicDataOK

NewGetItemDynamicDataOK creates a GetItemDynamicDataOK with default headers values

func (*GetItemDynamicDataOK) Error 

func (o *GetItemDynamicDataOK) Error() string

func (*GetItemDynamicDataOK) GetPayload 

func (o *GetItemDynamicDataOK) GetPayload() *platformclientmodels.ItemDynamicDataInfo

type GetItemDynamicDataParams 

type GetItemDynamicDataParams struct {

	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetItemDynamicDataParams contains all the parameters to send to the API endpoint for the get item dynamic data operation typically these are written to a http.Request

func NewGetItemDynamicDataParams 

func NewGetItemDynamicDataParams() *GetItemDynamicDataParams

NewGetItemDynamicDataParams creates a new GetItemDynamicDataParams object with the default values initialized.

func NewGetItemDynamicDataParamsWithContext 

func NewGetItemDynamicDataParamsWithContext(ctx context.Context) *GetItemDynamicDataParams

NewGetItemDynamicDataParamsWithContext creates a new GetItemDynamicDataParams object with the default values initialized, and the ability to set a context for a request

func NewGetItemDynamicDataParamsWithHTTPClient 

func NewGetItemDynamicDataParamsWithHTTPClient(client *http.Client) *GetItemDynamicDataParams

NewGetItemDynamicDataParamsWithHTTPClient creates a new GetItemDynamicDataParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetItemDynamicDataParamsWithTimeout 

func NewGetItemDynamicDataParamsWithTimeout(timeout time.Duration) *GetItemDynamicDataParams

NewGetItemDynamicDataParamsWithTimeout creates a new GetItemDynamicDataParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetItemDynamicDataParams) SetContext 

func (o *GetItemDynamicDataParams) SetContext(ctx context.Context)

SetContext adds the context to the get item dynamic data params

func (*GetItemDynamicDataParams) SetHTTPClient 

func (o *GetItemDynamicDataParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get item dynamic data params

func (*GetItemDynamicDataParams) SetItemID 

func (o *GetItemDynamicDataParams) SetItemID(itemID string)

SetItemID adds the itemId to the get item dynamic data params

func (*GetItemDynamicDataParams) SetNamespace 

func (o *GetItemDynamicDataParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get item dynamic data params

func (*GetItemDynamicDataParams) SetTimeout 

func (o *GetItemDynamicDataParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get item dynamic data params

func (*GetItemDynamicDataParams) WithContext 

func (o *GetItemDynamicDataParams) WithContext(ctx context.Context) *GetItemDynamicDataParams

WithContext adds the context to the get item dynamic data params

func (*GetItemDynamicDataParams) WithHTTPClient 

func (o *GetItemDynamicDataParams) WithHTTPClient(client *http.Client) *GetItemDynamicDataParams

WithHTTPClient adds the HTTPClient to the get item dynamic data params

func (*GetItemDynamicDataParams) WithItemID 

func (o *GetItemDynamicDataParams) WithItemID(itemID string) *GetItemDynamicDataParams

WithItemID adds the itemID to the get item dynamic data params

func (*GetItemDynamicDataParams) WithNamespace 

func (o *GetItemDynamicDataParams) WithNamespace(namespace string) *GetItemDynamicDataParams

WithNamespace adds the namespace to the get item dynamic data params

func (*GetItemDynamicDataParams) WithTimeout 

func (o *GetItemDynamicDataParams) WithTimeout(timeout time.Duration) *GetItemDynamicDataParams

WithTimeout adds the timeout to the get item dynamic data params

func (*GetItemDynamicDataParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetItemDynamicDataReader 

type GetItemDynamicDataReader struct {
	// contains filtered or unexported fields
}

GetItemDynamicDataReader is a Reader for the GetItemDynamicData structure.

func (*GetItemDynamicDataReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetItemIDBySkuNotFound 

type GetItemIDBySkuNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

GetItemIDBySkuNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30343</td><td>Item of sku [{sku}] does not exist</td></tr></table>

func NewGetItemIDBySkuNotFound 

func NewGetItemIDBySkuNotFound() *GetItemIDBySkuNotFound

NewGetItemIDBySkuNotFound creates a GetItemIDBySkuNotFound with default headers values

func (*GetItemIDBySkuNotFound) Error 

func (o *GetItemIDBySkuNotFound) Error() string

func (*GetItemIDBySkuNotFound) GetPayload 

func (o *GetItemIDBySkuNotFound) GetPayload() *platformclientmodels.ErrorEntity

type GetItemIDBySkuOK 

type GetItemIDBySkuOK struct {
	Payload *platformclientmodels.ItemID
}

GetItemIDBySkuOK handles this case with default header values. 

successful operation

func NewGetItemIDBySkuOK 

func NewGetItemIDBySkuOK() *GetItemIDBySkuOK

NewGetItemIDBySkuOK creates a GetItemIDBySkuOK with default headers values

func (*GetItemIDBySkuOK) Error 

func (o *GetItemIDBySkuOK) Error() string

func (*GetItemIDBySkuOK) GetPayload 

func (o *GetItemIDBySkuOK) GetPayload() *platformclientmodels.ItemID

type GetItemIDBySkuParams 

type GetItemIDBySkuParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*Namespace*/
	Namespace string
	/*Sku*/
	Sku string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetItemIDBySkuParams contains all the parameters to send to the API endpoint for the get item Id by sku operation typically these are written to a http.Request

func NewGetItemIDBySkuParams 

func NewGetItemIDBySkuParams() *GetItemIDBySkuParams

NewGetItemIDBySkuParams creates a new GetItemIDBySkuParams object with the default values initialized.

func NewGetItemIDBySkuParamsWithContext 

func NewGetItemIDBySkuParamsWithContext(ctx context.Context) *GetItemIDBySkuParams

NewGetItemIDBySkuParamsWithContext creates a new GetItemIDBySkuParams object with the default values initialized, and the ability to set a context for a request

func NewGetItemIDBySkuParamsWithHTTPClient 

func NewGetItemIDBySkuParamsWithHTTPClient(client *http.Client) *GetItemIDBySkuParams

NewGetItemIDBySkuParamsWithHTTPClient creates a new GetItemIDBySkuParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetItemIDBySkuParamsWithTimeout 

func NewGetItemIDBySkuParamsWithTimeout(timeout time.Duration) *GetItemIDBySkuParams

NewGetItemIDBySkuParamsWithTimeout creates a new GetItemIDBySkuParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetItemIDBySkuParams) SetActiveOnly 

func (o *GetItemIDBySkuParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the get item Id by sku params

func (*GetItemIDBySkuParams) SetContext 

func (o *GetItemIDBySkuParams) SetContext(ctx context.Context)

SetContext adds the context to the get item Id by sku params

func (*GetItemIDBySkuParams) SetHTTPClient 

func (o *GetItemIDBySkuParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get item Id by sku params

func (*GetItemIDBySkuParams) SetNamespace 

func (o *GetItemIDBySkuParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get item Id by sku params

func (*GetItemIDBySkuParams) SetSku 

func (o *GetItemIDBySkuParams) SetSku(sku string)

SetSku adds the sku to the get item Id by sku params

func (*GetItemIDBySkuParams) SetStoreID 

func (o *GetItemIDBySkuParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the get item Id by sku params

func (*GetItemIDBySkuParams) SetTimeout 

func (o *GetItemIDBySkuParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get item Id by sku params

func (*GetItemIDBySkuParams) WithActiveOnly 

func (o *GetItemIDBySkuParams) WithActiveOnly(activeOnly *bool) *GetItemIDBySkuParams

WithActiveOnly adds the activeOnly to the get item Id by sku params

func (*GetItemIDBySkuParams) WithContext 

func (o *GetItemIDBySkuParams) WithContext(ctx context.Context) *GetItemIDBySkuParams

WithContext adds the context to the get item Id by sku params

func (*GetItemIDBySkuParams) WithHTTPClient 

func (o *GetItemIDBySkuParams) WithHTTPClient(client *http.Client) *GetItemIDBySkuParams

WithHTTPClient adds the HTTPClient to the get item Id by sku params

func (*GetItemIDBySkuParams) WithNamespace 

func (o *GetItemIDBySkuParams) WithNamespace(namespace string) *GetItemIDBySkuParams

WithNamespace adds the namespace to the get item Id by sku params

func (*GetItemIDBySkuParams) WithSku 

func (o *GetItemIDBySkuParams) WithSku(sku string) *GetItemIDBySkuParams

WithSku adds the sku to the get item Id by sku params

func (*GetItemIDBySkuParams) WithStoreID 

func (o *GetItemIDBySkuParams) WithStoreID(storeID *string) *GetItemIDBySkuParams

WithStoreID adds the storeID to the get item Id by sku params

func (*GetItemIDBySkuParams) WithTimeout 

func (o *GetItemIDBySkuParams) WithTimeout(timeout time.Duration) *GetItemIDBySkuParams

WithTimeout adds the timeout to the get item Id by sku params

func (*GetItemIDBySkuParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetItemIDBySkuReader 

type GetItemIDBySkuReader struct {
	// contains filtered or unexported fields
}

GetItemIDBySkuReader is a Reader for the GetItemIDBySku structure.

func (*GetItemIDBySkuReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetItemNotFound 

type GetItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

GetItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewGetItemNotFound 

func NewGetItemNotFound() *GetItemNotFound

NewGetItemNotFound creates a GetItemNotFound with default headers values

func (*GetItemNotFound) Error 

func (o *GetItemNotFound) Error() string

func (*GetItemNotFound) GetPayload 

func (o *GetItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type GetItemOK 

type GetItemOK struct {
	Payload *platformclientmodels.FullItemInfo
}

GetItemOK handles this case with default header values. 

successful operation

func NewGetItemOK 

func NewGetItemOK() *GetItemOK

NewGetItemOK creates a GetItemOK with default headers values

func (*GetItemOK) Error 

func (o *GetItemOK) Error() string

func (*GetItemOK) GetPayload 

func (o *GetItemOK) GetPayload() *platformclientmodels.FullItemInfo

type GetItemParams 

type GetItemParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*ItemID*/
	ItemID string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetItemParams contains all the parameters to send to the API endpoint for the get item operation typically these are written to a http.Request

func NewGetItemParams 

func NewGetItemParams() *GetItemParams

NewGetItemParams creates a new GetItemParams object with the default values initialized.

func NewGetItemParamsWithContext 

func NewGetItemParamsWithContext(ctx context.Context) *GetItemParams

NewGetItemParamsWithContext creates a new GetItemParams object with the default values initialized, and the ability to set a context for a request

func NewGetItemParamsWithHTTPClient 

func NewGetItemParamsWithHTTPClient(client *http.Client) *GetItemParams

NewGetItemParamsWithHTTPClient creates a new GetItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetItemParamsWithTimeout 

func NewGetItemParamsWithTimeout(timeout time.Duration) *GetItemParams

NewGetItemParamsWithTimeout creates a new GetItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetItemParams) SetActiveOnly 

func (o *GetItemParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the get item params

func (*GetItemParams) SetContext 

func (o *GetItemParams) SetContext(ctx context.Context)

SetContext adds the context to the get item params

func (*GetItemParams) SetHTTPClient 

func (o *GetItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get item params

func (*GetItemParams) SetItemID 

func (o *GetItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the get item params

func (*GetItemParams) SetNamespace 

func (o *GetItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get item params

func (*GetItemParams) SetStoreID 

func (o *GetItemParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the get item params

func (*GetItemParams) SetTimeout 

func (o *GetItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get item params

func (*GetItemParams) WithActiveOnly 

func (o *GetItemParams) WithActiveOnly(activeOnly *bool) *GetItemParams

WithActiveOnly adds the activeOnly to the get item params

func (*GetItemParams) WithContext 

func (o *GetItemParams) WithContext(ctx context.Context) *GetItemParams

WithContext adds the context to the get item params

func (*GetItemParams) WithHTTPClient 

func (o *GetItemParams) WithHTTPClient(client *http.Client) *GetItemParams

WithHTTPClient adds the HTTPClient to the get item params

func (*GetItemParams) WithItemID 

func (o *GetItemParams) WithItemID(itemID string) *GetItemParams

WithItemID adds the itemID to the get item params

func (*GetItemParams) WithNamespace 

func (o *GetItemParams) WithNamespace(namespace string) *GetItemParams

WithNamespace adds the namespace to the get item params

func (*GetItemParams) WithStoreID 

func (o *GetItemParams) WithStoreID(storeID *string) *GetItemParams

WithStoreID adds the storeID to the get item params

func (*GetItemParams) WithTimeout 

func (o *GetItemParams) WithTimeout(timeout time.Duration) *GetItemParams

WithTimeout adds the timeout to the get item params

func (*GetItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetItemReader 

type GetItemReader struct {
	// contains filtered or unexported fields
}

GetItemReader is a Reader for the GetItem structure.

func (*GetItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetLocaleItemBySkuNotFound 

type GetLocaleItemBySkuNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

GetLocaleItemBySkuNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30343</td><td>Item of sku [{sku}] does not exist</td></tr></table>

func NewGetLocaleItemBySkuNotFound 

func NewGetLocaleItemBySkuNotFound() *GetLocaleItemBySkuNotFound

NewGetLocaleItemBySkuNotFound creates a GetLocaleItemBySkuNotFound with default headers values

func (*GetLocaleItemBySkuNotFound) Error 

func (o *GetLocaleItemBySkuNotFound) Error() string

func (*GetLocaleItemBySkuNotFound) GetPayload 

func (o *GetLocaleItemBySkuNotFound) GetPayload() *platformclientmodels.ErrorEntity

type GetLocaleItemBySkuOK 

type GetLocaleItemBySkuOK struct {
	Payload *platformclientmodels.PopulatedItemInfo
}

GetLocaleItemBySkuOK handles this case with default header values. 

successful operation

func NewGetLocaleItemBySkuOK 

func NewGetLocaleItemBySkuOK() *GetLocaleItemBySkuOK

NewGetLocaleItemBySkuOK creates a GetLocaleItemBySkuOK with default headers values

func (*GetLocaleItemBySkuOK) Error 

func (o *GetLocaleItemBySkuOK) Error() string

func (*GetLocaleItemBySkuOK) GetPayload 

func (o *GetLocaleItemBySkuOK) GetPayload() *platformclientmodels.PopulatedItemInfo

type GetLocaleItemBySkuParams 

type GetLocaleItemBySkuParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*Language*/
	Language *string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*PopulateBundle
	  whether populate bundled items if it's a bundle

	*/
	PopulateBundle *bool
	/*Region*/
	Region *string
	/*Sku*/
	Sku string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetLocaleItemBySkuParams contains all the parameters to send to the API endpoint for the get locale item by sku operation typically these are written to a http.Request

func NewGetLocaleItemBySkuParams 

func NewGetLocaleItemBySkuParams() *GetLocaleItemBySkuParams

NewGetLocaleItemBySkuParams creates a new GetLocaleItemBySkuParams object with the default values initialized.

func NewGetLocaleItemBySkuParamsWithContext 

func NewGetLocaleItemBySkuParamsWithContext(ctx context.Context) *GetLocaleItemBySkuParams

NewGetLocaleItemBySkuParamsWithContext creates a new GetLocaleItemBySkuParams object with the default values initialized, and the ability to set a context for a request

func NewGetLocaleItemBySkuParamsWithHTTPClient 

func NewGetLocaleItemBySkuParamsWithHTTPClient(client *http.Client) *GetLocaleItemBySkuParams

NewGetLocaleItemBySkuParamsWithHTTPClient creates a new GetLocaleItemBySkuParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetLocaleItemBySkuParamsWithTimeout 

func NewGetLocaleItemBySkuParamsWithTimeout(timeout time.Duration) *GetLocaleItemBySkuParams

NewGetLocaleItemBySkuParamsWithTimeout creates a new GetLocaleItemBySkuParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetLocaleItemBySkuParams) SetActiveOnly 

func (o *GetLocaleItemBySkuParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetContext 

func (o *GetLocaleItemBySkuParams) SetContext(ctx context.Context)

SetContext adds the context to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetHTTPClient 

func (o *GetLocaleItemBySkuParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetLanguage 

func (o *GetLocaleItemBySkuParams) SetLanguage(language *string)

SetLanguage adds the language to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetNamespace 

func (o *GetLocaleItemBySkuParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetPopulateBundle 

func (o *GetLocaleItemBySkuParams) SetPopulateBundle(populateBundle *bool)

SetPopulateBundle adds the populateBundle to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetRegion 

func (o *GetLocaleItemBySkuParams) SetRegion(region *string)

SetRegion adds the region to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetSku 

func (o *GetLocaleItemBySkuParams) SetSku(sku string)

SetSku adds the sku to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetStoreID 

func (o *GetLocaleItemBySkuParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the get locale item by sku params

func (*GetLocaleItemBySkuParams) SetTimeout 

func (o *GetLocaleItemBySkuParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithActiveOnly 

func (o *GetLocaleItemBySkuParams) WithActiveOnly(activeOnly *bool) *GetLocaleItemBySkuParams

WithActiveOnly adds the activeOnly to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithContext 

func (o *GetLocaleItemBySkuParams) WithContext(ctx context.Context) *GetLocaleItemBySkuParams

WithContext adds the context to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithHTTPClient 

func (o *GetLocaleItemBySkuParams) WithHTTPClient(client *http.Client) *GetLocaleItemBySkuParams

WithHTTPClient adds the HTTPClient to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithLanguage 

func (o *GetLocaleItemBySkuParams) WithLanguage(language *string) *GetLocaleItemBySkuParams

WithLanguage adds the language to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithNamespace 

func (o *GetLocaleItemBySkuParams) WithNamespace(namespace string) *GetLocaleItemBySkuParams

WithNamespace adds the namespace to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithPopulateBundle 

func (o *GetLocaleItemBySkuParams) WithPopulateBundle(populateBundle *bool) *GetLocaleItemBySkuParams

WithPopulateBundle adds the populateBundle to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithRegion 

func (o *GetLocaleItemBySkuParams) WithRegion(region *string) *GetLocaleItemBySkuParams

WithRegion adds the region to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithSku 

func (o *GetLocaleItemBySkuParams) WithSku(sku string) *GetLocaleItemBySkuParams

WithSku adds the sku to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithStoreID 

func (o *GetLocaleItemBySkuParams) WithStoreID(storeID *string) *GetLocaleItemBySkuParams

WithStoreID adds the storeID to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WithTimeout 

func (o *GetLocaleItemBySkuParams) WithTimeout(timeout time.Duration) *GetLocaleItemBySkuParams

WithTimeout adds the timeout to the get locale item by sku params

func (*GetLocaleItemBySkuParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetLocaleItemBySkuReader 

type GetLocaleItemBySkuReader struct {
	// contains filtered or unexported fields
}

GetLocaleItemBySkuReader is a Reader for the GetLocaleItemBySku structure.

func (*GetLocaleItemBySkuReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type GetLocaleItemNotFound 

type GetLocaleItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

GetLocaleItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewGetLocaleItemNotFound 

func NewGetLocaleItemNotFound() *GetLocaleItemNotFound

NewGetLocaleItemNotFound creates a GetLocaleItemNotFound with default headers values

func (*GetLocaleItemNotFound) Error 

func (o *GetLocaleItemNotFound) Error() string

func (*GetLocaleItemNotFound) GetPayload 

func (o *GetLocaleItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type GetLocaleItemOK 

type GetLocaleItemOK struct {
	Payload *platformclientmodels.PopulatedItemInfo
}

GetLocaleItemOK handles this case with default header values. 

successful operation

func NewGetLocaleItemOK 

func NewGetLocaleItemOK() *GetLocaleItemOK

NewGetLocaleItemOK creates a GetLocaleItemOK with default headers values

func (*GetLocaleItemOK) Error 

func (o *GetLocaleItemOK) Error() string

func (*GetLocaleItemOK) GetPayload 

func (o *GetLocaleItemOK) GetPayload() *platformclientmodels.PopulatedItemInfo

type GetLocaleItemParams 

type GetLocaleItemParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*ItemID*/
	ItemID string
	/*Language*/
	Language *string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*PopulateBundle
	  whether populate bundled items if it's a bundle

	*/
	PopulateBundle *bool
	/*Region*/
	Region *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

GetLocaleItemParams contains all the parameters to send to the API endpoint for the get locale item operation typically these are written to a http.Request

func NewGetLocaleItemParams 

func NewGetLocaleItemParams() *GetLocaleItemParams

NewGetLocaleItemParams creates a new GetLocaleItemParams object with the default values initialized.

func NewGetLocaleItemParamsWithContext 

func NewGetLocaleItemParamsWithContext(ctx context.Context) *GetLocaleItemParams

NewGetLocaleItemParamsWithContext creates a new GetLocaleItemParams object with the default values initialized, and the ability to set a context for a request

func NewGetLocaleItemParamsWithHTTPClient 

func NewGetLocaleItemParamsWithHTTPClient(client *http.Client) *GetLocaleItemParams

NewGetLocaleItemParamsWithHTTPClient creates a new GetLocaleItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewGetLocaleItemParamsWithTimeout 

func NewGetLocaleItemParamsWithTimeout(timeout time.Duration) *GetLocaleItemParams

NewGetLocaleItemParamsWithTimeout creates a new GetLocaleItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*GetLocaleItemParams) SetActiveOnly 

func (o *GetLocaleItemParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the get locale item params

func (*GetLocaleItemParams) SetContext 

func (o *GetLocaleItemParams) SetContext(ctx context.Context)

SetContext adds the context to the get locale item params

func (*GetLocaleItemParams) SetHTTPClient 

func (o *GetLocaleItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the get locale item params

func (*GetLocaleItemParams) SetItemID 

func (o *GetLocaleItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the get locale item params

func (*GetLocaleItemParams) SetLanguage 

func (o *GetLocaleItemParams) SetLanguage(language *string)

SetLanguage adds the language to the get locale item params

func (*GetLocaleItemParams) SetNamespace 

func (o *GetLocaleItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the get locale item params

func (*GetLocaleItemParams) SetPopulateBundle 

func (o *GetLocaleItemParams) SetPopulateBundle(populateBundle *bool)

SetPopulateBundle adds the populateBundle to the get locale item params

func (*GetLocaleItemParams) SetRegion 

func (o *GetLocaleItemParams) SetRegion(region *string)

SetRegion adds the region to the get locale item params

func (*GetLocaleItemParams) SetStoreID 

func (o *GetLocaleItemParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the get locale item params

func (*GetLocaleItemParams) SetTimeout 

func (o *GetLocaleItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the get locale item params

func (*GetLocaleItemParams) WithActiveOnly 

func (o *GetLocaleItemParams) WithActiveOnly(activeOnly *bool) *GetLocaleItemParams

WithActiveOnly adds the activeOnly to the get locale item params

func (*GetLocaleItemParams) WithContext 

func (o *GetLocaleItemParams) WithContext(ctx context.Context) *GetLocaleItemParams

WithContext adds the context to the get locale item params

func (*GetLocaleItemParams) WithHTTPClient 

func (o *GetLocaleItemParams) WithHTTPClient(client *http.Client) *GetLocaleItemParams

WithHTTPClient adds the HTTPClient to the get locale item params

func (*GetLocaleItemParams) WithItemID 

func (o *GetLocaleItemParams) WithItemID(itemID string) *GetLocaleItemParams

WithItemID adds the itemID to the get locale item params

func (*GetLocaleItemParams) WithLanguage 

func (o *GetLocaleItemParams) WithLanguage(language *string) *GetLocaleItemParams

WithLanguage adds the language to the get locale item params

func (*GetLocaleItemParams) WithNamespace 

func (o *GetLocaleItemParams) WithNamespace(namespace string) *GetLocaleItemParams

WithNamespace adds the namespace to the get locale item params

func (*GetLocaleItemParams) WithPopulateBundle 

func (o *GetLocaleItemParams) WithPopulateBundle(populateBundle *bool) *GetLocaleItemParams

WithPopulateBundle adds the populateBundle to the get locale item params

func (*GetLocaleItemParams) WithRegion 

func (o *GetLocaleItemParams) WithRegion(region *string) *GetLocaleItemParams

WithRegion adds the region to the get locale item params

func (*GetLocaleItemParams) WithStoreID 

func (o *GetLocaleItemParams) WithStoreID(storeID *string) *GetLocaleItemParams

WithStoreID adds the storeID to the get locale item params

func (*GetLocaleItemParams) WithTimeout 

func (o *GetLocaleItemParams) WithTimeout(timeout time.Duration) *GetLocaleItemParams

WithTimeout adds the timeout to the get locale item params

func (*GetLocaleItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type GetLocaleItemReader 

type GetLocaleItemReader struct {
	// contains filtered or unexported fields
}

GetLocaleItemReader is a Reader for the GetLocaleItem structure.

func (*GetLocaleItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type ListBasicItemsByFeaturesOK 

type ListBasicItemsByFeaturesOK struct {
	Payload []*platformclientmodels.BasicItem
}

ListBasicItemsByFeaturesOK handles this case with default header values. 

successful operation

func NewListBasicItemsByFeaturesOK 

func NewListBasicItemsByFeaturesOK() *ListBasicItemsByFeaturesOK

NewListBasicItemsByFeaturesOK creates a ListBasicItemsByFeaturesOK with default headers values

func (*ListBasicItemsByFeaturesOK) Error 

func (o *ListBasicItemsByFeaturesOK) Error() string

func (*ListBasicItemsByFeaturesOK) GetPayload 

func (o *ListBasicItemsByFeaturesOK) GetPayload() []*platformclientmodels.BasicItem

type ListBasicItemsByFeaturesParams 

type ListBasicItemsByFeaturesParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*Features
	  features

	*/
	Features []string
	/*Namespace*/
	Namespace string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

ListBasicItemsByFeaturesParams contains all the parameters to send to the API endpoint for the list basic items by features operation typically these are written to a http.Request

func NewListBasicItemsByFeaturesParams 

func NewListBasicItemsByFeaturesParams() *ListBasicItemsByFeaturesParams

NewListBasicItemsByFeaturesParams creates a new ListBasicItemsByFeaturesParams object with the default values initialized.

func NewListBasicItemsByFeaturesParamsWithContext 

func NewListBasicItemsByFeaturesParamsWithContext(ctx context.Context) *ListBasicItemsByFeaturesParams

NewListBasicItemsByFeaturesParamsWithContext creates a new ListBasicItemsByFeaturesParams object with the default values initialized, and the ability to set a context for a request

func NewListBasicItemsByFeaturesParamsWithHTTPClient 

func NewListBasicItemsByFeaturesParamsWithHTTPClient(client *http.Client) *ListBasicItemsByFeaturesParams

NewListBasicItemsByFeaturesParamsWithHTTPClient creates a new ListBasicItemsByFeaturesParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewListBasicItemsByFeaturesParamsWithTimeout 

func NewListBasicItemsByFeaturesParamsWithTimeout(timeout time.Duration) *ListBasicItemsByFeaturesParams

NewListBasicItemsByFeaturesParamsWithTimeout creates a new ListBasicItemsByFeaturesParams object with the default values initialized, and the ability to set a timeout on a request

func (*ListBasicItemsByFeaturesParams) SetActiveOnly 

func (o *ListBasicItemsByFeaturesParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) SetContext 

func (o *ListBasicItemsByFeaturesParams) SetContext(ctx context.Context)

SetContext adds the context to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) SetFeatures 

func (o *ListBasicItemsByFeaturesParams) SetFeatures(features []string)

SetFeatures adds the features to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) SetHTTPClient 

func (o *ListBasicItemsByFeaturesParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) SetNamespace 

func (o *ListBasicItemsByFeaturesParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) SetTimeout 

func (o *ListBasicItemsByFeaturesParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) WithActiveOnly 

func (o *ListBasicItemsByFeaturesParams) WithActiveOnly(activeOnly *bool) *ListBasicItemsByFeaturesParams

WithActiveOnly adds the activeOnly to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) WithContext 

func (o *ListBasicItemsByFeaturesParams) WithContext(ctx context.Context) *ListBasicItemsByFeaturesParams

WithContext adds the context to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) WithFeatures 

func (o *ListBasicItemsByFeaturesParams) WithFeatures(features []string) *ListBasicItemsByFeaturesParams

WithFeatures adds the features to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) WithHTTPClient 

func (o *ListBasicItemsByFeaturesParams) WithHTTPClient(client *http.Client) *ListBasicItemsByFeaturesParams

WithHTTPClient adds the HTTPClient to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) WithNamespace 

func (o *ListBasicItemsByFeaturesParams) WithNamespace(namespace string) *ListBasicItemsByFeaturesParams

WithNamespace adds the namespace to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) WithTimeout 

func (o *ListBasicItemsByFeaturesParams) WithTimeout(timeout time.Duration) *ListBasicItemsByFeaturesParams

WithTimeout adds the timeout to the list basic items by features params

func (*ListBasicItemsByFeaturesParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type ListBasicItemsByFeaturesReader 

type ListBasicItemsByFeaturesReader struct {
	// contains filtered or unexported fields
}

ListBasicItemsByFeaturesReader is a Reader for the ListBasicItemsByFeatures structure.

func (*ListBasicItemsByFeaturesReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicBulkGetItemsOK 

type PublicBulkGetItemsOK struct {
	Payload []*platformclientmodels.ItemInfo
}

PublicBulkGetItemsOK handles this case with default header values. 

successful operation

func NewPublicBulkGetItemsOK 

func NewPublicBulkGetItemsOK() *PublicBulkGetItemsOK

NewPublicBulkGetItemsOK creates a PublicBulkGetItemsOK with default headers values

func (*PublicBulkGetItemsOK) Error 

func (o *PublicBulkGetItemsOK) Error() string

func (*PublicBulkGetItemsOK) GetPayload 

func (o *PublicBulkGetItemsOK) GetPayload() []*platformclientmodels.ItemInfo

type PublicBulkGetItemsParams 

type PublicBulkGetItemsParams struct {

	/*ItemIds
	  commas separated item ids

	*/
	ItemIds string
	/*Language*/
	Language *string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*Region*/
	Region *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicBulkGetItemsParams contains all the parameters to send to the API endpoint for the public bulk get items operation typically these are written to a http.Request

func NewPublicBulkGetItemsParams 

func NewPublicBulkGetItemsParams() *PublicBulkGetItemsParams

NewPublicBulkGetItemsParams creates a new PublicBulkGetItemsParams object with the default values initialized.

func NewPublicBulkGetItemsParamsWithContext 

func NewPublicBulkGetItemsParamsWithContext(ctx context.Context) *PublicBulkGetItemsParams

NewPublicBulkGetItemsParamsWithContext creates a new PublicBulkGetItemsParams object with the default values initialized, and the ability to set a context for a request

func NewPublicBulkGetItemsParamsWithHTTPClient 

func NewPublicBulkGetItemsParamsWithHTTPClient(client *http.Client) *PublicBulkGetItemsParams

NewPublicBulkGetItemsParamsWithHTTPClient creates a new PublicBulkGetItemsParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicBulkGetItemsParamsWithTimeout 

func NewPublicBulkGetItemsParamsWithTimeout(timeout time.Duration) *PublicBulkGetItemsParams

NewPublicBulkGetItemsParamsWithTimeout creates a new PublicBulkGetItemsParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicBulkGetItemsParams) SetContext 

func (o *PublicBulkGetItemsParams) SetContext(ctx context.Context)

SetContext adds the context to the public bulk get items params

func (*PublicBulkGetItemsParams) SetHTTPClient 

func (o *PublicBulkGetItemsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public bulk get items params

func (*PublicBulkGetItemsParams) SetItemIds 

func (o *PublicBulkGetItemsParams) SetItemIds(itemIds string)

SetItemIds adds the itemIds to the public bulk get items params

func (*PublicBulkGetItemsParams) SetLanguage 

func (o *PublicBulkGetItemsParams) SetLanguage(language *string)

SetLanguage adds the language to the public bulk get items params

func (*PublicBulkGetItemsParams) SetNamespace 

func (o *PublicBulkGetItemsParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public bulk get items params

func (*PublicBulkGetItemsParams) SetRegion 

func (o *PublicBulkGetItemsParams) SetRegion(region *string)

SetRegion adds the region to the public bulk get items params

func (*PublicBulkGetItemsParams) SetStoreID 

func (o *PublicBulkGetItemsParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the public bulk get items params

func (*PublicBulkGetItemsParams) SetTimeout 

func (o *PublicBulkGetItemsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public bulk get items params

func (*PublicBulkGetItemsParams) WithContext 

func (o *PublicBulkGetItemsParams) WithContext(ctx context.Context) *PublicBulkGetItemsParams

WithContext adds the context to the public bulk get items params

func (*PublicBulkGetItemsParams) WithHTTPClient 

func (o *PublicBulkGetItemsParams) WithHTTPClient(client *http.Client) *PublicBulkGetItemsParams

WithHTTPClient adds the HTTPClient to the public bulk get items params

func (*PublicBulkGetItemsParams) WithItemIds 

func (o *PublicBulkGetItemsParams) WithItemIds(itemIds string) *PublicBulkGetItemsParams

WithItemIds adds the itemIds to the public bulk get items params

func (*PublicBulkGetItemsParams) WithLanguage 

func (o *PublicBulkGetItemsParams) WithLanguage(language *string) *PublicBulkGetItemsParams

WithLanguage adds the language to the public bulk get items params

func (*PublicBulkGetItemsParams) WithNamespace 

func (o *PublicBulkGetItemsParams) WithNamespace(namespace string) *PublicBulkGetItemsParams

WithNamespace adds the namespace to the public bulk get items params

func (*PublicBulkGetItemsParams) WithRegion 

func (o *PublicBulkGetItemsParams) WithRegion(region *string) *PublicBulkGetItemsParams

WithRegion adds the region to the public bulk get items params

func (*PublicBulkGetItemsParams) WithStoreID 

func (o *PublicBulkGetItemsParams) WithStoreID(storeID *string) *PublicBulkGetItemsParams

WithStoreID adds the storeID to the public bulk get items params

func (*PublicBulkGetItemsParams) WithTimeout 

func (o *PublicBulkGetItemsParams) WithTimeout(timeout time.Duration) *PublicBulkGetItemsParams

WithTimeout adds the timeout to the public bulk get items params

func (*PublicBulkGetItemsParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicBulkGetItemsReader 

type PublicBulkGetItemsReader struct {
	// contains filtered or unexported fields
}

PublicBulkGetItemsReader is a Reader for the PublicBulkGetItems structure.

func (*PublicBulkGetItemsReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicGetAppNotFound 

type PublicGetAppNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

PublicGetAppNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewPublicGetAppNotFound 

func NewPublicGetAppNotFound() *PublicGetAppNotFound

NewPublicGetAppNotFound creates a PublicGetAppNotFound with default headers values

func (*PublicGetAppNotFound) Error 

func (o *PublicGetAppNotFound) Error() string

func (*PublicGetAppNotFound) GetPayload 

func (o *PublicGetAppNotFound) GetPayload() *platformclientmodels.ErrorEntity

type PublicGetAppOK 

type PublicGetAppOK struct {
	Payload *platformclientmodels.AppInfo
}

PublicGetAppOK handles this case with default header values. 

successful operation

func NewPublicGetAppOK 

func NewPublicGetAppOK() *PublicGetAppOK

NewPublicGetAppOK creates a PublicGetAppOK with default headers values

func (*PublicGetAppOK) Error 

func (o *PublicGetAppOK) Error() string

func (*PublicGetAppOK) GetPayload 

func (o *PublicGetAppOK) GetPayload() *platformclientmodels.AppInfo

type PublicGetAppParams 

type PublicGetAppParams struct {

	/*ItemID*/
	ItemID string
	/*Language*/
	Language *string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*Region*/
	Region *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicGetAppParams contains all the parameters to send to the API endpoint for the public get app operation typically these are written to a http.Request

func NewPublicGetAppParams 

func NewPublicGetAppParams() *PublicGetAppParams

NewPublicGetAppParams creates a new PublicGetAppParams object with the default values initialized.

func NewPublicGetAppParamsWithContext 

func NewPublicGetAppParamsWithContext(ctx context.Context) *PublicGetAppParams

NewPublicGetAppParamsWithContext creates a new PublicGetAppParams object with the default values initialized, and the ability to set a context for a request

func NewPublicGetAppParamsWithHTTPClient 

func NewPublicGetAppParamsWithHTTPClient(client *http.Client) *PublicGetAppParams

NewPublicGetAppParamsWithHTTPClient creates a new PublicGetAppParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicGetAppParamsWithTimeout 

func NewPublicGetAppParamsWithTimeout(timeout time.Duration) *PublicGetAppParams

NewPublicGetAppParamsWithTimeout creates a new PublicGetAppParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicGetAppParams) SetContext 

func (o *PublicGetAppParams) SetContext(ctx context.Context)

SetContext adds the context to the public get app params

func (*PublicGetAppParams) SetHTTPClient 

func (o *PublicGetAppParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public get app params

func (*PublicGetAppParams) SetItemID 

func (o *PublicGetAppParams) SetItemID(itemID string)

SetItemID adds the itemId to the public get app params

func (*PublicGetAppParams) SetLanguage 

func (o *PublicGetAppParams) SetLanguage(language *string)

SetLanguage adds the language to the public get app params

func (*PublicGetAppParams) SetNamespace 

func (o *PublicGetAppParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public get app params

func (*PublicGetAppParams) SetRegion 

func (o *PublicGetAppParams) SetRegion(region *string)

SetRegion adds the region to the public get app params

func (*PublicGetAppParams) SetStoreID 

func (o *PublicGetAppParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the public get app params

func (*PublicGetAppParams) SetTimeout 

func (o *PublicGetAppParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public get app params

func (*PublicGetAppParams) WithContext 

func (o *PublicGetAppParams) WithContext(ctx context.Context) *PublicGetAppParams

WithContext adds the context to the public get app params

func (*PublicGetAppParams) WithHTTPClient 

func (o *PublicGetAppParams) WithHTTPClient(client *http.Client) *PublicGetAppParams

WithHTTPClient adds the HTTPClient to the public get app params

func (*PublicGetAppParams) WithItemID 

func (o *PublicGetAppParams) WithItemID(itemID string) *PublicGetAppParams

WithItemID adds the itemID to the public get app params

func (*PublicGetAppParams) WithLanguage 

func (o *PublicGetAppParams) WithLanguage(language *string) *PublicGetAppParams

WithLanguage adds the language to the public get app params

func (*PublicGetAppParams) WithNamespace 

func (o *PublicGetAppParams) WithNamespace(namespace string) *PublicGetAppParams

WithNamespace adds the namespace to the public get app params

func (*PublicGetAppParams) WithRegion 

func (o *PublicGetAppParams) WithRegion(region *string) *PublicGetAppParams

WithRegion adds the region to the public get app params

func (*PublicGetAppParams) WithStoreID 

func (o *PublicGetAppParams) WithStoreID(storeID *string) *PublicGetAppParams

WithStoreID adds the storeID to the public get app params

func (*PublicGetAppParams) WithTimeout 

func (o *PublicGetAppParams) WithTimeout(timeout time.Duration) *PublicGetAppParams

WithTimeout adds the timeout to the public get app params

func (*PublicGetAppParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicGetAppReader 

type PublicGetAppReader struct {
	// contains filtered or unexported fields
}

PublicGetAppReader is a Reader for the PublicGetApp structure.

func (*PublicGetAppReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicGetItemByAppIDNotFound 

type PublicGetItemByAppIDNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

PublicGetItemByAppIDNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30342</td><td>Item of appId [{appId}] does not exist</td></tr></table>

func NewPublicGetItemByAppIDNotFound 

func NewPublicGetItemByAppIDNotFound() *PublicGetItemByAppIDNotFound

NewPublicGetItemByAppIDNotFound creates a PublicGetItemByAppIDNotFound with default headers values

func (*PublicGetItemByAppIDNotFound) Error 

func (o *PublicGetItemByAppIDNotFound) Error() string

func (*PublicGetItemByAppIDNotFound) GetPayload 

func (o *PublicGetItemByAppIDNotFound) GetPayload() *platformclientmodels.ErrorEntity

type PublicGetItemByAppIDOK 

type PublicGetItemByAppIDOK struct {
	Payload *platformclientmodels.ItemInfo
}

PublicGetItemByAppIDOK handles this case with default header values. 

successful operation

func NewPublicGetItemByAppIDOK 

func NewPublicGetItemByAppIDOK() *PublicGetItemByAppIDOK

NewPublicGetItemByAppIDOK creates a PublicGetItemByAppIDOK with default headers values

func (*PublicGetItemByAppIDOK) Error 

func (o *PublicGetItemByAppIDOK) Error() string

func (*PublicGetItemByAppIDOK) GetPayload 

func (o *PublicGetItemByAppIDOK) GetPayload() *platformclientmodels.ItemInfo

type PublicGetItemByAppIDParams 

type PublicGetItemByAppIDParams struct {

	/*AppID*/
	AppID string
	/*Language*/
	Language *string
	/*Namespace*/
	Namespace string
	/*Region*/
	Region *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicGetItemByAppIDParams contains all the parameters to send to the API endpoint for the public get item by app Id operation typically these are written to a http.Request

func NewPublicGetItemByAppIDParams 

func NewPublicGetItemByAppIDParams() *PublicGetItemByAppIDParams

NewPublicGetItemByAppIDParams creates a new PublicGetItemByAppIDParams object with the default values initialized.

func NewPublicGetItemByAppIDParamsWithContext 

func NewPublicGetItemByAppIDParamsWithContext(ctx context.Context) *PublicGetItemByAppIDParams

NewPublicGetItemByAppIDParamsWithContext creates a new PublicGetItemByAppIDParams object with the default values initialized, and the ability to set a context for a request

func NewPublicGetItemByAppIDParamsWithHTTPClient 

func NewPublicGetItemByAppIDParamsWithHTTPClient(client *http.Client) *PublicGetItemByAppIDParams

NewPublicGetItemByAppIDParamsWithHTTPClient creates a new PublicGetItemByAppIDParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicGetItemByAppIDParamsWithTimeout 

func NewPublicGetItemByAppIDParamsWithTimeout(timeout time.Duration) *PublicGetItemByAppIDParams

NewPublicGetItemByAppIDParamsWithTimeout creates a new PublicGetItemByAppIDParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicGetItemByAppIDParams) SetAppID 

func (o *PublicGetItemByAppIDParams) SetAppID(appID string)

SetAppID adds the appId to the public get item by app Id params

func (*PublicGetItemByAppIDParams) SetContext 

func (o *PublicGetItemByAppIDParams) SetContext(ctx context.Context)

SetContext adds the context to the public get item by app Id params

func (*PublicGetItemByAppIDParams) SetHTTPClient 

func (o *PublicGetItemByAppIDParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public get item by app Id params

func (*PublicGetItemByAppIDParams) SetLanguage 

func (o *PublicGetItemByAppIDParams) SetLanguage(language *string)

SetLanguage adds the language to the public get item by app Id params

func (*PublicGetItemByAppIDParams) SetNamespace 

func (o *PublicGetItemByAppIDParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public get item by app Id params

func (*PublicGetItemByAppIDParams) SetRegion 

func (o *PublicGetItemByAppIDParams) SetRegion(region *string)

SetRegion adds the region to the public get item by app Id params

func (*PublicGetItemByAppIDParams) SetStoreID 

func (o *PublicGetItemByAppIDParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the public get item by app Id params

func (*PublicGetItemByAppIDParams) SetTimeout 

func (o *PublicGetItemByAppIDParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithAppID 

func (o *PublicGetItemByAppIDParams) WithAppID(appID string) *PublicGetItemByAppIDParams

WithAppID adds the appID to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithContext 

func (o *PublicGetItemByAppIDParams) WithContext(ctx context.Context) *PublicGetItemByAppIDParams

WithContext adds the context to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithHTTPClient 

func (o *PublicGetItemByAppIDParams) WithHTTPClient(client *http.Client) *PublicGetItemByAppIDParams

WithHTTPClient adds the HTTPClient to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithLanguage 

func (o *PublicGetItemByAppIDParams) WithLanguage(language *string) *PublicGetItemByAppIDParams

WithLanguage adds the language to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithNamespace 

func (o *PublicGetItemByAppIDParams) WithNamespace(namespace string) *PublicGetItemByAppIDParams

WithNamespace adds the namespace to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithRegion 

func (o *PublicGetItemByAppIDParams) WithRegion(region *string) *PublicGetItemByAppIDParams

WithRegion adds the region to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithStoreID 

func (o *PublicGetItemByAppIDParams) WithStoreID(storeID *string) *PublicGetItemByAppIDParams

WithStoreID adds the storeID to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WithTimeout 

func (o *PublicGetItemByAppIDParams) WithTimeout(timeout time.Duration) *PublicGetItemByAppIDParams

WithTimeout adds the timeout to the public get item by app Id params

func (*PublicGetItemByAppIDParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicGetItemByAppIDReader 

type PublicGetItemByAppIDReader struct {
	// contains filtered or unexported fields
}

PublicGetItemByAppIDReader is a Reader for the PublicGetItemByAppID structure.

func (*PublicGetItemByAppIDReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicGetItemBySkuNotFound 

type PublicGetItemBySkuNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

PublicGetItemBySkuNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30343</td><td>Item of sku [{sku}] does not exist</td></tr></table>

func NewPublicGetItemBySkuNotFound 

func NewPublicGetItemBySkuNotFound() *PublicGetItemBySkuNotFound

NewPublicGetItemBySkuNotFound creates a PublicGetItemBySkuNotFound with default headers values

func (*PublicGetItemBySkuNotFound) Error 

func (o *PublicGetItemBySkuNotFound) Error() string

func (*PublicGetItemBySkuNotFound) GetPayload 

func (o *PublicGetItemBySkuNotFound) GetPayload() *platformclientmodels.ErrorEntity

type PublicGetItemBySkuOK 

type PublicGetItemBySkuOK struct {
	Payload *platformclientmodels.ItemInfo
}

PublicGetItemBySkuOK handles this case with default header values. 

successful operation

func NewPublicGetItemBySkuOK 

func NewPublicGetItemBySkuOK() *PublicGetItemBySkuOK

NewPublicGetItemBySkuOK creates a PublicGetItemBySkuOK with default headers values

func (*PublicGetItemBySkuOK) Error 

func (o *PublicGetItemBySkuOK) Error() string

func (*PublicGetItemBySkuOK) GetPayload 

func (o *PublicGetItemBySkuOK) GetPayload() *platformclientmodels.ItemInfo

type PublicGetItemBySkuParams 

type PublicGetItemBySkuParams struct {

	/*Language*/
	Language *string
	/*Namespace*/
	Namespace string
	/*Region*/
	Region *string
	/*Sku*/
	Sku string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicGetItemBySkuParams contains all the parameters to send to the API endpoint for the public get item by sku operation typically these are written to a http.Request

func NewPublicGetItemBySkuParams 

func NewPublicGetItemBySkuParams() *PublicGetItemBySkuParams

NewPublicGetItemBySkuParams creates a new PublicGetItemBySkuParams object with the default values initialized.

func NewPublicGetItemBySkuParamsWithContext 

func NewPublicGetItemBySkuParamsWithContext(ctx context.Context) *PublicGetItemBySkuParams

NewPublicGetItemBySkuParamsWithContext creates a new PublicGetItemBySkuParams object with the default values initialized, and the ability to set a context for a request

func NewPublicGetItemBySkuParamsWithHTTPClient 

func NewPublicGetItemBySkuParamsWithHTTPClient(client *http.Client) *PublicGetItemBySkuParams

NewPublicGetItemBySkuParamsWithHTTPClient creates a new PublicGetItemBySkuParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicGetItemBySkuParamsWithTimeout 

func NewPublicGetItemBySkuParamsWithTimeout(timeout time.Duration) *PublicGetItemBySkuParams

NewPublicGetItemBySkuParamsWithTimeout creates a new PublicGetItemBySkuParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicGetItemBySkuParams) SetContext 

func (o *PublicGetItemBySkuParams) SetContext(ctx context.Context)

SetContext adds the context to the public get item by sku params

func (*PublicGetItemBySkuParams) SetHTTPClient 

func (o *PublicGetItemBySkuParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public get item by sku params

func (*PublicGetItemBySkuParams) SetLanguage 

func (o *PublicGetItemBySkuParams) SetLanguage(language *string)

SetLanguage adds the language to the public get item by sku params

func (*PublicGetItemBySkuParams) SetNamespace 

func (o *PublicGetItemBySkuParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public get item by sku params

func (*PublicGetItemBySkuParams) SetRegion 

func (o *PublicGetItemBySkuParams) SetRegion(region *string)

SetRegion adds the region to the public get item by sku params

func (*PublicGetItemBySkuParams) SetSku 

func (o *PublicGetItemBySkuParams) SetSku(sku string)

SetSku adds the sku to the public get item by sku params

func (*PublicGetItemBySkuParams) SetStoreID 

func (o *PublicGetItemBySkuParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the public get item by sku params

func (*PublicGetItemBySkuParams) SetTimeout 

func (o *PublicGetItemBySkuParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public get item by sku params

func (*PublicGetItemBySkuParams) WithContext 

func (o *PublicGetItemBySkuParams) WithContext(ctx context.Context) *PublicGetItemBySkuParams

WithContext adds the context to the public get item by sku params

func (*PublicGetItemBySkuParams) WithHTTPClient 

func (o *PublicGetItemBySkuParams) WithHTTPClient(client *http.Client) *PublicGetItemBySkuParams

WithHTTPClient adds the HTTPClient to the public get item by sku params

func (*PublicGetItemBySkuParams) WithLanguage 

func (o *PublicGetItemBySkuParams) WithLanguage(language *string) *PublicGetItemBySkuParams

WithLanguage adds the language to the public get item by sku params

func (*PublicGetItemBySkuParams) WithNamespace 

func (o *PublicGetItemBySkuParams) WithNamespace(namespace string) *PublicGetItemBySkuParams

WithNamespace adds the namespace to the public get item by sku params

func (*PublicGetItemBySkuParams) WithRegion 

func (o *PublicGetItemBySkuParams) WithRegion(region *string) *PublicGetItemBySkuParams

WithRegion adds the region to the public get item by sku params

func (*PublicGetItemBySkuParams) WithSku 

func (o *PublicGetItemBySkuParams) WithSku(sku string) *PublicGetItemBySkuParams

WithSku adds the sku to the public get item by sku params

func (*PublicGetItemBySkuParams) WithStoreID 

func (o *PublicGetItemBySkuParams) WithStoreID(storeID *string) *PublicGetItemBySkuParams

WithStoreID adds the storeID to the public get item by sku params

func (*PublicGetItemBySkuParams) WithTimeout 

func (o *PublicGetItemBySkuParams) WithTimeout(timeout time.Duration) *PublicGetItemBySkuParams

WithTimeout adds the timeout to the public get item by sku params

func (*PublicGetItemBySkuParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicGetItemBySkuReader 

type PublicGetItemBySkuReader struct {
	// contains filtered or unexported fields
}

PublicGetItemBySkuReader is a Reader for the PublicGetItemBySku structure.

func (*PublicGetItemBySkuReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicGetItemDynamicDataNotFound 

type PublicGetItemDynamicDataNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

PublicGetItemDynamicDataNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewPublicGetItemDynamicDataNotFound 

func NewPublicGetItemDynamicDataNotFound() *PublicGetItemDynamicDataNotFound

NewPublicGetItemDynamicDataNotFound creates a PublicGetItemDynamicDataNotFound with default headers values

func (*PublicGetItemDynamicDataNotFound) Error 

func (o *PublicGetItemDynamicDataNotFound) Error() string

func (*PublicGetItemDynamicDataNotFound) GetPayload 

func (o *PublicGetItemDynamicDataNotFound) GetPayload() *platformclientmodels.ErrorEntity

type PublicGetItemDynamicDataOK 

type PublicGetItemDynamicDataOK struct {
	Payload *platformclientmodels.ItemDynamicDataInfo
}

PublicGetItemDynamicDataOK handles this case with default header values. 

successful operation

func NewPublicGetItemDynamicDataOK 

func NewPublicGetItemDynamicDataOK() *PublicGetItemDynamicDataOK

NewPublicGetItemDynamicDataOK creates a PublicGetItemDynamicDataOK with default headers values

func (*PublicGetItemDynamicDataOK) Error 

func (o *PublicGetItemDynamicDataOK) Error() string

func (*PublicGetItemDynamicDataOK) GetPayload 

func (o *PublicGetItemDynamicDataOK) GetPayload() *platformclientmodels.ItemDynamicDataInfo

type PublicGetItemDynamicDataParams 

type PublicGetItemDynamicDataParams struct {

	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicGetItemDynamicDataParams contains all the parameters to send to the API endpoint for the public get item dynamic data operation typically these are written to a http.Request

func NewPublicGetItemDynamicDataParams 

func NewPublicGetItemDynamicDataParams() *PublicGetItemDynamicDataParams

NewPublicGetItemDynamicDataParams creates a new PublicGetItemDynamicDataParams object with the default values initialized.

func NewPublicGetItemDynamicDataParamsWithContext 

func NewPublicGetItemDynamicDataParamsWithContext(ctx context.Context) *PublicGetItemDynamicDataParams

NewPublicGetItemDynamicDataParamsWithContext creates a new PublicGetItemDynamicDataParams object with the default values initialized, and the ability to set a context for a request

func NewPublicGetItemDynamicDataParamsWithHTTPClient 

func NewPublicGetItemDynamicDataParamsWithHTTPClient(client *http.Client) *PublicGetItemDynamicDataParams

NewPublicGetItemDynamicDataParamsWithHTTPClient creates a new PublicGetItemDynamicDataParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicGetItemDynamicDataParamsWithTimeout 

func NewPublicGetItemDynamicDataParamsWithTimeout(timeout time.Duration) *PublicGetItemDynamicDataParams

NewPublicGetItemDynamicDataParamsWithTimeout creates a new PublicGetItemDynamicDataParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicGetItemDynamicDataParams) SetContext 

func (o *PublicGetItemDynamicDataParams) SetContext(ctx context.Context)

SetContext adds the context to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) SetHTTPClient 

func (o *PublicGetItemDynamicDataParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) SetItemID 

func (o *PublicGetItemDynamicDataParams) SetItemID(itemID string)

SetItemID adds the itemId to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) SetNamespace 

func (o *PublicGetItemDynamicDataParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) SetTimeout 

func (o *PublicGetItemDynamicDataParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) WithContext 

func (o *PublicGetItemDynamicDataParams) WithContext(ctx context.Context) *PublicGetItemDynamicDataParams

WithContext adds the context to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) WithHTTPClient 

func (o *PublicGetItemDynamicDataParams) WithHTTPClient(client *http.Client) *PublicGetItemDynamicDataParams

WithHTTPClient adds the HTTPClient to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) WithItemID 

func (o *PublicGetItemDynamicDataParams) WithItemID(itemID string) *PublicGetItemDynamicDataParams

WithItemID adds the itemID to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) WithNamespace 

func (o *PublicGetItemDynamicDataParams) WithNamespace(namespace string) *PublicGetItemDynamicDataParams

WithNamespace adds the namespace to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) WithTimeout 

func (o *PublicGetItemDynamicDataParams) WithTimeout(timeout time.Duration) *PublicGetItemDynamicDataParams

WithTimeout adds the timeout to the public get item dynamic data params

func (*PublicGetItemDynamicDataParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicGetItemDynamicDataReader 

type PublicGetItemDynamicDataReader struct {
	// contains filtered or unexported fields
}

PublicGetItemDynamicDataReader is a Reader for the PublicGetItemDynamicData structure.

func (*PublicGetItemDynamicDataReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicGetItemNotFound 

type PublicGetItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

PublicGetItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewPublicGetItemNotFound 

func NewPublicGetItemNotFound() *PublicGetItemNotFound

NewPublicGetItemNotFound creates a PublicGetItemNotFound with default headers values

func (*PublicGetItemNotFound) Error 

func (o *PublicGetItemNotFound) Error() string

func (*PublicGetItemNotFound) GetPayload 

func (o *PublicGetItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type PublicGetItemOK 

type PublicGetItemOK struct {
	Payload *platformclientmodels.PopulatedItemInfo
}

PublicGetItemOK handles this case with default header values. 

successful operation

func NewPublicGetItemOK 

func NewPublicGetItemOK() *PublicGetItemOK

NewPublicGetItemOK creates a PublicGetItemOK with default headers values

func (*PublicGetItemOK) Error 

func (o *PublicGetItemOK) Error() string

func (*PublicGetItemOK) GetPayload 

func (o *PublicGetItemOK) GetPayload() *platformclientmodels.PopulatedItemInfo

type PublicGetItemParams 

type PublicGetItemParams struct {

	/*ItemID*/
	ItemID string
	/*Language*/
	Language *string
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*PopulateBundle
	  whether populate bundled items if it's a bundle

	*/
	PopulateBundle *bool
	/*Region*/
	Region *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicGetItemParams contains all the parameters to send to the API endpoint for the public get item operation typically these are written to a http.Request

func NewPublicGetItemParams 

func NewPublicGetItemParams() *PublicGetItemParams

NewPublicGetItemParams creates a new PublicGetItemParams object with the default values initialized.

func NewPublicGetItemParamsWithContext 

func NewPublicGetItemParamsWithContext(ctx context.Context) *PublicGetItemParams

NewPublicGetItemParamsWithContext creates a new PublicGetItemParams object with the default values initialized, and the ability to set a context for a request

func NewPublicGetItemParamsWithHTTPClient 

func NewPublicGetItemParamsWithHTTPClient(client *http.Client) *PublicGetItemParams

NewPublicGetItemParamsWithHTTPClient creates a new PublicGetItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicGetItemParamsWithTimeout 

func NewPublicGetItemParamsWithTimeout(timeout time.Duration) *PublicGetItemParams

NewPublicGetItemParamsWithTimeout creates a new PublicGetItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicGetItemParams) SetContext 

func (o *PublicGetItemParams) SetContext(ctx context.Context)

SetContext adds the context to the public get item params

func (*PublicGetItemParams) SetHTTPClient 

func (o *PublicGetItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public get item params

func (*PublicGetItemParams) SetItemID 

func (o *PublicGetItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the public get item params

func (*PublicGetItemParams) SetLanguage 

func (o *PublicGetItemParams) SetLanguage(language *string)

SetLanguage adds the language to the public get item params

func (*PublicGetItemParams) SetNamespace 

func (o *PublicGetItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public get item params

func (*PublicGetItemParams) SetPopulateBundle 

func (o *PublicGetItemParams) SetPopulateBundle(populateBundle *bool)

SetPopulateBundle adds the populateBundle to the public get item params

func (*PublicGetItemParams) SetRegion 

func (o *PublicGetItemParams) SetRegion(region *string)

SetRegion adds the region to the public get item params

func (*PublicGetItemParams) SetStoreID 

func (o *PublicGetItemParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the public get item params

func (*PublicGetItemParams) SetTimeout 

func (o *PublicGetItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public get item params

func (*PublicGetItemParams) WithContext 

func (o *PublicGetItemParams) WithContext(ctx context.Context) *PublicGetItemParams

WithContext adds the context to the public get item params

func (*PublicGetItemParams) WithHTTPClient 

func (o *PublicGetItemParams) WithHTTPClient(client *http.Client) *PublicGetItemParams

WithHTTPClient adds the HTTPClient to the public get item params

func (*PublicGetItemParams) WithItemID 

func (o *PublicGetItemParams) WithItemID(itemID string) *PublicGetItemParams

WithItemID adds the itemID to the public get item params

func (*PublicGetItemParams) WithLanguage 

func (o *PublicGetItemParams) WithLanguage(language *string) *PublicGetItemParams

WithLanguage adds the language to the public get item params

func (*PublicGetItemParams) WithNamespace 

func (o *PublicGetItemParams) WithNamespace(namespace string) *PublicGetItemParams

WithNamespace adds the namespace to the public get item params

func (*PublicGetItemParams) WithPopulateBundle 

func (o *PublicGetItemParams) WithPopulateBundle(populateBundle *bool) *PublicGetItemParams

WithPopulateBundle adds the populateBundle to the public get item params

func (*PublicGetItemParams) WithRegion 

func (o *PublicGetItemParams) WithRegion(region *string) *PublicGetItemParams

WithRegion adds the region to the public get item params

func (*PublicGetItemParams) WithStoreID 

func (o *PublicGetItemParams) WithStoreID(storeID *string) *PublicGetItemParams

WithStoreID adds the storeID to the public get item params

func (*PublicGetItemParams) WithTimeout 

func (o *PublicGetItemParams) WithTimeout(timeout time.Duration) *PublicGetItemParams

WithTimeout adds the timeout to the public get item params

func (*PublicGetItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicGetItemReader 

type PublicGetItemReader struct {
	// contains filtered or unexported fields
}

PublicGetItemReader is a Reader for the PublicGetItem structure.

func (*PublicGetItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicQueryItemsNotFound 

type PublicQueryItemsNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

PublicQueryItemsNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30141</td><td>Store [{storeId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewPublicQueryItemsNotFound 

func NewPublicQueryItemsNotFound() *PublicQueryItemsNotFound

NewPublicQueryItemsNotFound creates a PublicQueryItemsNotFound with default headers values

func (*PublicQueryItemsNotFound) Error 

func (o *PublicQueryItemsNotFound) Error() string

func (*PublicQueryItemsNotFound) GetPayload 

func (o *PublicQueryItemsNotFound) GetPayload() *platformclientmodels.ErrorEntity

type PublicQueryItemsOK 

type PublicQueryItemsOK struct {
	Payload *platformclientmodels.ItemPagingSlicedResult
}

PublicQueryItemsOK handles this case with default header values. 

successful operation

func NewPublicQueryItemsOK 

func NewPublicQueryItemsOK() *PublicQueryItemsOK

NewPublicQueryItemsOK creates a PublicQueryItemsOK with default headers values

func (*PublicQueryItemsOK) Error 

func (o *PublicQueryItemsOK) Error() string

func (*PublicQueryItemsOK) GetPayload 

func (o *PublicQueryItemsOK) GetPayload() *platformclientmodels.ItemPagingSlicedResult

type PublicQueryItemsParams 

type PublicQueryItemsParams struct {

	/*AppType*/
	AppType *string
	/*BaseAppID*/
	BaseAppID *string
	/*CategoryPath
	  category path

	*/
	CategoryPath *string
	/*Features
	  features, separate multiple value by commas parameter

	*/
	Features *string
	/*ItemType*/
	ItemType *string
	/*Language*/
	Language *string
	/*Limit
	  limit

	*/
	Limit *int32
	/*Namespace*/
	Namespace string
	/*Offset
	  offset

	*/
	Offset *int32
	/*Region*/
	Region *string
	/*SortBy
	  default is name:asc,displayOrder:asc, allow values: [name, name:asc, name:desc, createdAt, createdAt:asc, createdAt:desc, updatedAt, updatedAt:asc, updatedAt:desc, displayOrder, displayOrder:asc, displayOrder:desc],and support sort group, eg: sortBy=name:asc,createdAt:desc. Make sure to always use more than one sort if the first sort is not an unique value for example, if you wish to sort by displayOrder, make sure to include other sort such as name or createdAt after the first sort, eg: displayOrder:asc,name:asc

	*/
	SortBy *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string
	/*Tags
	  tags, separate multiple value by commas parameter

	*/
	Tags *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicQueryItemsParams contains all the parameters to send to the API endpoint for the public query items operation typically these are written to a http.Request

func NewPublicQueryItemsParams 

func NewPublicQueryItemsParams() *PublicQueryItemsParams

NewPublicQueryItemsParams creates a new PublicQueryItemsParams object with the default values initialized.

func NewPublicQueryItemsParamsWithContext 

func NewPublicQueryItemsParamsWithContext(ctx context.Context) *PublicQueryItemsParams

NewPublicQueryItemsParamsWithContext creates a new PublicQueryItemsParams object with the default values initialized, and the ability to set a context for a request

func NewPublicQueryItemsParamsWithHTTPClient 

func NewPublicQueryItemsParamsWithHTTPClient(client *http.Client) *PublicQueryItemsParams

NewPublicQueryItemsParamsWithHTTPClient creates a new PublicQueryItemsParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicQueryItemsParamsWithTimeout 

func NewPublicQueryItemsParamsWithTimeout(timeout time.Duration) *PublicQueryItemsParams

NewPublicQueryItemsParamsWithTimeout creates a new PublicQueryItemsParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicQueryItemsParams) SetAppType 

func (o *PublicQueryItemsParams) SetAppType(appType *string)

SetAppType adds the appType to the public query items params

func (*PublicQueryItemsParams) SetBaseAppID 

func (o *PublicQueryItemsParams) SetBaseAppID(baseAppID *string)

SetBaseAppID adds the baseAppId to the public query items params

func (*PublicQueryItemsParams) SetCategoryPath 

func (o *PublicQueryItemsParams) SetCategoryPath(categoryPath *string)

SetCategoryPath adds the categoryPath to the public query items params

func (*PublicQueryItemsParams) SetContext 

func (o *PublicQueryItemsParams) SetContext(ctx context.Context)

SetContext adds the context to the public query items params

func (*PublicQueryItemsParams) SetFeatures 

func (o *PublicQueryItemsParams) SetFeatures(features *string)

SetFeatures adds the features to the public query items params

func (*PublicQueryItemsParams) SetHTTPClient 

func (o *PublicQueryItemsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public query items params

func (*PublicQueryItemsParams) SetItemType 

func (o *PublicQueryItemsParams) SetItemType(itemType *string)

SetItemType adds the itemType to the public query items params

func (*PublicQueryItemsParams) SetLanguage 

func (o *PublicQueryItemsParams) SetLanguage(language *string)

SetLanguage adds the language to the public query items params

func (*PublicQueryItemsParams) SetLimit 

func (o *PublicQueryItemsParams) SetLimit(limit *int32)

SetLimit adds the limit to the public query items params

func (*PublicQueryItemsParams) SetNamespace 

func (o *PublicQueryItemsParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public query items params

func (*PublicQueryItemsParams) SetOffset 

func (o *PublicQueryItemsParams) SetOffset(offset *int32)

SetOffset adds the offset to the public query items params

func (*PublicQueryItemsParams) SetRegion 

func (o *PublicQueryItemsParams) SetRegion(region *string)

SetRegion adds the region to the public query items params

func (*PublicQueryItemsParams) SetSortBy 

func (o *PublicQueryItemsParams) SetSortBy(sortBy *string)

SetSortBy adds the sortBy to the public query items params

func (*PublicQueryItemsParams) SetStoreID 

func (o *PublicQueryItemsParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the public query items params

func (*PublicQueryItemsParams) SetTags 

func (o *PublicQueryItemsParams) SetTags(tags *string)

SetTags adds the tags to the public query items params

func (*PublicQueryItemsParams) SetTimeout 

func (o *PublicQueryItemsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public query items params

func (*PublicQueryItemsParams) WithAppType 

func (o *PublicQueryItemsParams) WithAppType(appType *string) *PublicQueryItemsParams

WithAppType adds the appType to the public query items params

func (*PublicQueryItemsParams) WithBaseAppID 

func (o *PublicQueryItemsParams) WithBaseAppID(baseAppID *string) *PublicQueryItemsParams

WithBaseAppID adds the baseAppID to the public query items params

func (*PublicQueryItemsParams) WithCategoryPath 

func (o *PublicQueryItemsParams) WithCategoryPath(categoryPath *string) *PublicQueryItemsParams

WithCategoryPath adds the categoryPath to the public query items params

func (*PublicQueryItemsParams) WithContext 

func (o *PublicQueryItemsParams) WithContext(ctx context.Context) *PublicQueryItemsParams

WithContext adds the context to the public query items params

func (*PublicQueryItemsParams) WithFeatures 

func (o *PublicQueryItemsParams) WithFeatures(features *string) *PublicQueryItemsParams

WithFeatures adds the features to the public query items params

func (*PublicQueryItemsParams) WithHTTPClient 

func (o *PublicQueryItemsParams) WithHTTPClient(client *http.Client) *PublicQueryItemsParams

WithHTTPClient adds the HTTPClient to the public query items params

func (*PublicQueryItemsParams) WithItemType 

func (o *PublicQueryItemsParams) WithItemType(itemType *string) *PublicQueryItemsParams

WithItemType adds the itemType to the public query items params

func (*PublicQueryItemsParams) WithLanguage 

func (o *PublicQueryItemsParams) WithLanguage(language *string) *PublicQueryItemsParams

WithLanguage adds the language to the public query items params

func (*PublicQueryItemsParams) WithLimit 

func (o *PublicQueryItemsParams) WithLimit(limit *int32) *PublicQueryItemsParams

WithLimit adds the limit to the public query items params

func (*PublicQueryItemsParams) WithNamespace 

func (o *PublicQueryItemsParams) WithNamespace(namespace string) *PublicQueryItemsParams

WithNamespace adds the namespace to the public query items params

func (*PublicQueryItemsParams) WithOffset 

func (o *PublicQueryItemsParams) WithOffset(offset *int32) *PublicQueryItemsParams

WithOffset adds the offset to the public query items params

func (*PublicQueryItemsParams) WithRegion 

func (o *PublicQueryItemsParams) WithRegion(region *string) *PublicQueryItemsParams

WithRegion adds the region to the public query items params

func (*PublicQueryItemsParams) WithSortBy 

func (o *PublicQueryItemsParams) WithSortBy(sortBy *string) *PublicQueryItemsParams

WithSortBy adds the sortBy to the public query items params

func (*PublicQueryItemsParams) WithStoreID 

func (o *PublicQueryItemsParams) WithStoreID(storeID *string) *PublicQueryItemsParams

WithStoreID adds the storeID to the public query items params

func (*PublicQueryItemsParams) WithTags 

func (o *PublicQueryItemsParams) WithTags(tags *string) *PublicQueryItemsParams

WithTags adds the tags to the public query items params

func (*PublicQueryItemsParams) WithTimeout 

func (o *PublicQueryItemsParams) WithTimeout(timeout time.Duration) *PublicQueryItemsParams

WithTimeout adds the timeout to the public query items params

func (*PublicQueryItemsParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicQueryItemsReader 

type PublicQueryItemsReader struct {
	// contains filtered or unexported fields
}

PublicQueryItemsReader is a Reader for the PublicQueryItems structure.

func (*PublicQueryItemsReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type PublicQueryItemsUnprocessableEntity 

type PublicQueryItemsUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

PublicQueryItemsUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewPublicQueryItemsUnprocessableEntity 

func NewPublicQueryItemsUnprocessableEntity() *PublicQueryItemsUnprocessableEntity

NewPublicQueryItemsUnprocessableEntity creates a PublicQueryItemsUnprocessableEntity with default headers values

func (*PublicQueryItemsUnprocessableEntity) Error 

func (o *PublicQueryItemsUnprocessableEntity) Error() string

func (*PublicQueryItemsUnprocessableEntity) GetPayload 

func (o *PublicQueryItemsUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

type PublicSearchItemsOK 

type PublicSearchItemsOK struct {
	Payload *platformclientmodels.ItemPagingSlicedResult
}

PublicSearchItemsOK handles this case with default header values. 

successful operation

func NewPublicSearchItemsOK 

func NewPublicSearchItemsOK() *PublicSearchItemsOK

NewPublicSearchItemsOK creates a PublicSearchItemsOK with default headers values

func (*PublicSearchItemsOK) Error 

func (o *PublicSearchItemsOK) Error() string

func (*PublicSearchItemsOK) GetPayload 

func (o *PublicSearchItemsOK) GetPayload() *platformclientmodels.ItemPagingSlicedResult

type PublicSearchItemsParams 

type PublicSearchItemsParams struct {

	/*Keyword*/
	Keyword string
	/*Language*/
	Language string
	/*Limit
	  limit

	*/
	Limit *int32
	/*Namespace*/
	Namespace string
	/*Offset
	  offset

	*/
	Offset *int32
	/*Region*/
	Region *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

PublicSearchItemsParams contains all the parameters to send to the API endpoint for the public search items operation typically these are written to a http.Request

func NewPublicSearchItemsParams 

func NewPublicSearchItemsParams() *PublicSearchItemsParams

NewPublicSearchItemsParams creates a new PublicSearchItemsParams object with the default values initialized.

func NewPublicSearchItemsParamsWithContext 

func NewPublicSearchItemsParamsWithContext(ctx context.Context) *PublicSearchItemsParams

NewPublicSearchItemsParamsWithContext creates a new PublicSearchItemsParams object with the default values initialized, and the ability to set a context for a request

func NewPublicSearchItemsParamsWithHTTPClient 

func NewPublicSearchItemsParamsWithHTTPClient(client *http.Client) *PublicSearchItemsParams

NewPublicSearchItemsParamsWithHTTPClient creates a new PublicSearchItemsParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewPublicSearchItemsParamsWithTimeout 

func NewPublicSearchItemsParamsWithTimeout(timeout time.Duration) *PublicSearchItemsParams

NewPublicSearchItemsParamsWithTimeout creates a new PublicSearchItemsParams object with the default values initialized, and the ability to set a timeout on a request

func (*PublicSearchItemsParams) SetContext 

func (o *PublicSearchItemsParams) SetContext(ctx context.Context)

SetContext adds the context to the public search items params

func (*PublicSearchItemsParams) SetHTTPClient 

func (o *PublicSearchItemsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the public search items params

func (*PublicSearchItemsParams) SetKeyword 

func (o *PublicSearchItemsParams) SetKeyword(keyword string)

SetKeyword adds the keyword to the public search items params

func (*PublicSearchItemsParams) SetLanguage 

func (o *PublicSearchItemsParams) SetLanguage(language string)

SetLanguage adds the language to the public search items params

func (*PublicSearchItemsParams) SetLimit 

func (o *PublicSearchItemsParams) SetLimit(limit *int32)

SetLimit adds the limit to the public search items params

func (*PublicSearchItemsParams) SetNamespace 

func (o *PublicSearchItemsParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the public search items params

func (*PublicSearchItemsParams) SetOffset 

func (o *PublicSearchItemsParams) SetOffset(offset *int32)

SetOffset adds the offset to the public search items params

func (*PublicSearchItemsParams) SetRegion 

func (o *PublicSearchItemsParams) SetRegion(region *string)

SetRegion adds the region to the public search items params

func (*PublicSearchItemsParams) SetStoreID 

func (o *PublicSearchItemsParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the public search items params

func (*PublicSearchItemsParams) SetTimeout 

func (o *PublicSearchItemsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the public search items params

func (*PublicSearchItemsParams) WithContext 

func (o *PublicSearchItemsParams) WithContext(ctx context.Context) *PublicSearchItemsParams

WithContext adds the context to the public search items params

func (*PublicSearchItemsParams) WithHTTPClient 

func (o *PublicSearchItemsParams) WithHTTPClient(client *http.Client) *PublicSearchItemsParams

WithHTTPClient adds the HTTPClient to the public search items params

func (*PublicSearchItemsParams) WithKeyword 

func (o *PublicSearchItemsParams) WithKeyword(keyword string) *PublicSearchItemsParams

WithKeyword adds the keyword to the public search items params

func (*PublicSearchItemsParams) WithLanguage 

func (o *PublicSearchItemsParams) WithLanguage(language string) *PublicSearchItemsParams

WithLanguage adds the language to the public search items params

func (*PublicSearchItemsParams) WithLimit 

func (o *PublicSearchItemsParams) WithLimit(limit *int32) *PublicSearchItemsParams

WithLimit adds the limit to the public search items params

func (*PublicSearchItemsParams) WithNamespace 

func (o *PublicSearchItemsParams) WithNamespace(namespace string) *PublicSearchItemsParams

WithNamespace adds the namespace to the public search items params

func (*PublicSearchItemsParams) WithOffset 

func (o *PublicSearchItemsParams) WithOffset(offset *int32) *PublicSearchItemsParams

WithOffset adds the offset to the public search items params

func (*PublicSearchItemsParams) WithRegion 

func (o *PublicSearchItemsParams) WithRegion(region *string) *PublicSearchItemsParams

WithRegion adds the region to the public search items params

func (*PublicSearchItemsParams) WithStoreID 

func (o *PublicSearchItemsParams) WithStoreID(storeID *string) *PublicSearchItemsParams

WithStoreID adds the storeID to the public search items params

func (*PublicSearchItemsParams) WithTimeout 

func (o *PublicSearchItemsParams) WithTimeout(timeout time.Duration) *PublicSearchItemsParams

WithTimeout adds the timeout to the public search items params

func (*PublicSearchItemsParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type PublicSearchItemsReader 

type PublicSearchItemsReader struct {
	// contains filtered or unexported fields
}

PublicSearchItemsReader is a Reader for the PublicSearchItems structure.

func (*PublicSearchItemsReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type QueryItemsNotFound 

type QueryItemsNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

QueryItemsNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30141</td><td>Store [{storeId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewQueryItemsNotFound 

func NewQueryItemsNotFound() *QueryItemsNotFound

NewQueryItemsNotFound creates a QueryItemsNotFound with default headers values

func (*QueryItemsNotFound) Error 

func (o *QueryItemsNotFound) Error() string

func (*QueryItemsNotFound) GetPayload 

func (o *QueryItemsNotFound) GetPayload() *platformclientmodels.ErrorEntity

type QueryItemsOK 

type QueryItemsOK struct {
	Payload *platformclientmodels.FullItemPagingSlicedResult
}

QueryItemsOK handles this case with default header values. 

successful operation

func NewQueryItemsOK 

func NewQueryItemsOK() *QueryItemsOK

NewQueryItemsOK creates a QueryItemsOK with default headers values

func (*QueryItemsOK) Error 

func (o *QueryItemsOK) Error() string

func (*QueryItemsOK) GetPayload 

func (o *QueryItemsOK) GetPayload() *platformclientmodels.FullItemPagingSlicedResult

type QueryItemsParams 

type QueryItemsParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*AppType*/
	AppType *string
	/*AvailableDate
	  allowed format: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z , filter date include(purchaseAt, expireAt)

	*/
	AvailableDate *string
	/*BaseAppID*/
	BaseAppID *string
	/*CategoryPath
	  category path

	*/
	CategoryPath *string
	/*Features
	  features, separate multiple value by commas parameter

	*/
	Features *string
	/*ItemType*/
	ItemType *string
	/*Limit
	  limit

	*/
	Limit *int32
	/*Namespace*/
	Namespace string
	/*Offset
	  offset

	*/
	Offset *int32
	/*Region
	  exist in region

	*/
	Region *string
	/*SortBy
	  default is name:asc,displayOrder:asc, allow values: [name, name:asc, name:desc, createdAt, createdAt:asc, createdAt:desc, updatedAt, updatedAt:asc, updatedAt:desc, displayOrder, displayOrder:asc, displayOrder:desc],and support sort group, eg: sortBy=name:asc,createdAt:desc. Make sure to always use more than one sort if the first sort is not an unique valuefor example, if you wish to sort by displayOrder, make sure to include other sort such as name or createdAt after the first sort, eg: displayOrder:asc,name:asc

	*/
	SortBy *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string
	/*Tags
	  tags, separate multiple value by commas parameter

	*/
	Tags *string
	/*TargetNamespace
	  targetNamespace

	*/
	TargetNamespace *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

QueryItemsParams contains all the parameters to send to the API endpoint for the query items operation typically these are written to a http.Request

func NewQueryItemsParams 

func NewQueryItemsParams() *QueryItemsParams

NewQueryItemsParams creates a new QueryItemsParams object with the default values initialized.

func NewQueryItemsParamsWithContext 

func NewQueryItemsParamsWithContext(ctx context.Context) *QueryItemsParams

NewQueryItemsParamsWithContext creates a new QueryItemsParams object with the default values initialized, and the ability to set a context for a request

func NewQueryItemsParamsWithHTTPClient 

func NewQueryItemsParamsWithHTTPClient(client *http.Client) *QueryItemsParams

NewQueryItemsParamsWithHTTPClient creates a new QueryItemsParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewQueryItemsParamsWithTimeout 

func NewQueryItemsParamsWithTimeout(timeout time.Duration) *QueryItemsParams

NewQueryItemsParamsWithTimeout creates a new QueryItemsParams object with the default values initialized, and the ability to set a timeout on a request

func (*QueryItemsParams) SetActiveOnly 

func (o *QueryItemsParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the query items params

func (*QueryItemsParams) SetAppType 

func (o *QueryItemsParams) SetAppType(appType *string)

SetAppType adds the appType to the query items params

func (*QueryItemsParams) SetAvailableDate 

func (o *QueryItemsParams) SetAvailableDate(availableDate *string)

SetAvailableDate adds the availableDate to the query items params

func (*QueryItemsParams) SetBaseAppID 

func (o *QueryItemsParams) SetBaseAppID(baseAppID *string)

SetBaseAppID adds the baseAppId to the query items params

func (*QueryItemsParams) SetCategoryPath 

func (o *QueryItemsParams) SetCategoryPath(categoryPath *string)

SetCategoryPath adds the categoryPath to the query items params

func (*QueryItemsParams) SetContext 

func (o *QueryItemsParams) SetContext(ctx context.Context)

SetContext adds the context to the query items params

func (*QueryItemsParams) SetFeatures 

func (o *QueryItemsParams) SetFeatures(features *string)

SetFeatures adds the features to the query items params

func (*QueryItemsParams) SetHTTPClient 

func (o *QueryItemsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the query items params

func (*QueryItemsParams) SetItemType 

func (o *QueryItemsParams) SetItemType(itemType *string)

SetItemType adds the itemType to the query items params

func (*QueryItemsParams) SetLimit 

func (o *QueryItemsParams) SetLimit(limit *int32)

SetLimit adds the limit to the query items params

func (*QueryItemsParams) SetNamespace 

func (o *QueryItemsParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the query items params

func (*QueryItemsParams) SetOffset 

func (o *QueryItemsParams) SetOffset(offset *int32)

SetOffset adds the offset to the query items params

func (*QueryItemsParams) SetRegion 

func (o *QueryItemsParams) SetRegion(region *string)

SetRegion adds the region to the query items params

func (*QueryItemsParams) SetSortBy 

func (o *QueryItemsParams) SetSortBy(sortBy *string)

SetSortBy adds the sortBy to the query items params

func (*QueryItemsParams) SetStoreID 

func (o *QueryItemsParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the query items params

func (*QueryItemsParams) SetTags 

func (o *QueryItemsParams) SetTags(tags *string)

SetTags adds the tags to the query items params

func (*QueryItemsParams) SetTargetNamespace 

func (o *QueryItemsParams) SetTargetNamespace(targetNamespace *string)

SetTargetNamespace adds the targetNamespace to the query items params

func (*QueryItemsParams) SetTimeout 

func (o *QueryItemsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the query items params

func (*QueryItemsParams) WithActiveOnly 

func (o *QueryItemsParams) WithActiveOnly(activeOnly *bool) *QueryItemsParams

WithActiveOnly adds the activeOnly to the query items params

func (*QueryItemsParams) WithAppType 

func (o *QueryItemsParams) WithAppType(appType *string) *QueryItemsParams

WithAppType adds the appType to the query items params

func (*QueryItemsParams) WithAvailableDate 

func (o *QueryItemsParams) WithAvailableDate(availableDate *string) *QueryItemsParams

WithAvailableDate adds the availableDate to the query items params

func (*QueryItemsParams) WithBaseAppID 

func (o *QueryItemsParams) WithBaseAppID(baseAppID *string) *QueryItemsParams

WithBaseAppID adds the baseAppID to the query items params

func (*QueryItemsParams) WithCategoryPath 

func (o *QueryItemsParams) WithCategoryPath(categoryPath *string) *QueryItemsParams

WithCategoryPath adds the categoryPath to the query items params

func (*QueryItemsParams) WithContext 

func (o *QueryItemsParams) WithContext(ctx context.Context) *QueryItemsParams

WithContext adds the context to the query items params

func (*QueryItemsParams) WithFeatures 

func (o *QueryItemsParams) WithFeatures(features *string) *QueryItemsParams

WithFeatures adds the features to the query items params

func (*QueryItemsParams) WithHTTPClient 

func (o *QueryItemsParams) WithHTTPClient(client *http.Client) *QueryItemsParams

WithHTTPClient adds the HTTPClient to the query items params

func (*QueryItemsParams) WithItemType 

func (o *QueryItemsParams) WithItemType(itemType *string) *QueryItemsParams

WithItemType adds the itemType to the query items params

func (*QueryItemsParams) WithLimit 

func (o *QueryItemsParams) WithLimit(limit *int32) *QueryItemsParams

WithLimit adds the limit to the query items params

func (*QueryItemsParams) WithNamespace 

func (o *QueryItemsParams) WithNamespace(namespace string) *QueryItemsParams

WithNamespace adds the namespace to the query items params

func (*QueryItemsParams) WithOffset 

func (o *QueryItemsParams) WithOffset(offset *int32) *QueryItemsParams

WithOffset adds the offset to the query items params

func (*QueryItemsParams) WithRegion 

func (o *QueryItemsParams) WithRegion(region *string) *QueryItemsParams

WithRegion adds the region to the query items params

func (*QueryItemsParams) WithSortBy 

func (o *QueryItemsParams) WithSortBy(sortBy *string) *QueryItemsParams

WithSortBy adds the sortBy to the query items params

func (*QueryItemsParams) WithStoreID 

func (o *QueryItemsParams) WithStoreID(storeID *string) *QueryItemsParams

WithStoreID adds the storeID to the query items params

func (*QueryItemsParams) WithTags 

func (o *QueryItemsParams) WithTags(tags *string) *QueryItemsParams

WithTags adds the tags to the query items params

func (*QueryItemsParams) WithTargetNamespace 

func (o *QueryItemsParams) WithTargetNamespace(targetNamespace *string) *QueryItemsParams

WithTargetNamespace adds the targetNamespace to the query items params

func (*QueryItemsParams) WithTimeout 

func (o *QueryItemsParams) WithTimeout(timeout time.Duration) *QueryItemsParams

WithTimeout adds the timeout to the query items params

func (*QueryItemsParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type QueryItemsReader 

type QueryItemsReader struct {
	// contains filtered or unexported fields
}

QueryItemsReader is a Reader for the QueryItems structure.

func (*QueryItemsReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type QueryItemsUnprocessableEntity 

type QueryItemsUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

QueryItemsUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewQueryItemsUnprocessableEntity 

func NewQueryItemsUnprocessableEntity() *QueryItemsUnprocessableEntity

NewQueryItemsUnprocessableEntity creates a QueryItemsUnprocessableEntity with default headers values

func (*QueryItemsUnprocessableEntity) Error 

func (o *QueryItemsUnprocessableEntity) Error() string

func (*QueryItemsUnprocessableEntity) GetPayload 

func (o *QueryItemsUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

type QueryUncategorizedItemsNotFound 

type QueryUncategorizedItemsNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

QueryUncategorizedItemsNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30141</td><td>Store [{storeId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewQueryUncategorizedItemsNotFound 

func NewQueryUncategorizedItemsNotFound() *QueryUncategorizedItemsNotFound

NewQueryUncategorizedItemsNotFound creates a QueryUncategorizedItemsNotFound with default headers values

func (*QueryUncategorizedItemsNotFound) Error 

func (o *QueryUncategorizedItemsNotFound) Error() string

func (*QueryUncategorizedItemsNotFound) GetPayload 

func (o *QueryUncategorizedItemsNotFound) GetPayload() *platformclientmodels.ErrorEntity

type QueryUncategorizedItemsOK 

type QueryUncategorizedItemsOK struct {
	Payload *platformclientmodels.FullItemPagingSlicedResult
}

QueryUncategorizedItemsOK handles this case with default header values. 

successful operation

func NewQueryUncategorizedItemsOK 

func NewQueryUncategorizedItemsOK() *QueryUncategorizedItemsOK

NewQueryUncategorizedItemsOK creates a QueryUncategorizedItemsOK with default headers values

func (*QueryUncategorizedItemsOK) Error 

func (o *QueryUncategorizedItemsOK) Error() string

func (*QueryUncategorizedItemsOK) GetPayload 

func (o *QueryUncategorizedItemsOK) GetPayload() *platformclientmodels.FullItemPagingSlicedResult

type QueryUncategorizedItemsParams 

type QueryUncategorizedItemsParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*Limit
	  limit

	*/
	Limit *int32
	/*Namespace*/
	Namespace string
	/*Offset
	  offset

	*/
	Offset *int32
	/*SortBy
	  default is name:asc, allow values: [name, name:asc, name:desc, createdAt, createdAt:asc, createdAt:desc, updatedAt, updatedAt:asc, updatedAt:desc, displayOrder, displayOrder:asc, displayOrder:desc],and support sort group, eg: sortBy=name:asc,createdAt:desc Make sure to always use more than one sort if the first sort is not an unique valuefor example, if you wish to sort by displayOrder, make sure to include other sort such as name or createdAt after the first sort, eg: displayOrder:asc,name:asc

	*/
	SortBy *string
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

QueryUncategorizedItemsParams contains all the parameters to send to the API endpoint for the query uncategorized items operation typically these are written to a http.Request

func NewQueryUncategorizedItemsParams 

func NewQueryUncategorizedItemsParams() *QueryUncategorizedItemsParams

NewQueryUncategorizedItemsParams creates a new QueryUncategorizedItemsParams object with the default values initialized.

func NewQueryUncategorizedItemsParamsWithContext 

func NewQueryUncategorizedItemsParamsWithContext(ctx context.Context) *QueryUncategorizedItemsParams

NewQueryUncategorizedItemsParamsWithContext creates a new QueryUncategorizedItemsParams object with the default values initialized, and the ability to set a context for a request

func NewQueryUncategorizedItemsParamsWithHTTPClient 

func NewQueryUncategorizedItemsParamsWithHTTPClient(client *http.Client) *QueryUncategorizedItemsParams

NewQueryUncategorizedItemsParamsWithHTTPClient creates a new QueryUncategorizedItemsParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewQueryUncategorizedItemsParamsWithTimeout 

func NewQueryUncategorizedItemsParamsWithTimeout(timeout time.Duration) *QueryUncategorizedItemsParams

NewQueryUncategorizedItemsParamsWithTimeout creates a new QueryUncategorizedItemsParams object with the default values initialized, and the ability to set a timeout on a request

func (*QueryUncategorizedItemsParams) SetActiveOnly 

func (o *QueryUncategorizedItemsParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetContext 

func (o *QueryUncategorizedItemsParams) SetContext(ctx context.Context)

SetContext adds the context to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetHTTPClient 

func (o *QueryUncategorizedItemsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetLimit 

func (o *QueryUncategorizedItemsParams) SetLimit(limit *int32)

SetLimit adds the limit to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetNamespace 

func (o *QueryUncategorizedItemsParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetOffset 

func (o *QueryUncategorizedItemsParams) SetOffset(offset *int32)

SetOffset adds the offset to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetSortBy 

func (o *QueryUncategorizedItemsParams) SetSortBy(sortBy *string)

SetSortBy adds the sortBy to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetStoreID 

func (o *QueryUncategorizedItemsParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the query uncategorized items params

func (*QueryUncategorizedItemsParams) SetTimeout 

func (o *QueryUncategorizedItemsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithActiveOnly 

func (o *QueryUncategorizedItemsParams) WithActiveOnly(activeOnly *bool) *QueryUncategorizedItemsParams

WithActiveOnly adds the activeOnly to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithContext 

func (o *QueryUncategorizedItemsParams) WithContext(ctx context.Context) *QueryUncategorizedItemsParams

WithContext adds the context to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithHTTPClient 

func (o *QueryUncategorizedItemsParams) WithHTTPClient(client *http.Client) *QueryUncategorizedItemsParams

WithHTTPClient adds the HTTPClient to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithLimit 

func (o *QueryUncategorizedItemsParams) WithLimit(limit *int32) *QueryUncategorizedItemsParams

WithLimit adds the limit to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithNamespace 

func (o *QueryUncategorizedItemsParams) WithNamespace(namespace string) *QueryUncategorizedItemsParams

WithNamespace adds the namespace to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithOffset 

func (o *QueryUncategorizedItemsParams) WithOffset(offset *int32) *QueryUncategorizedItemsParams

WithOffset adds the offset to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithSortBy 

func (o *QueryUncategorizedItemsParams) WithSortBy(sortBy *string) *QueryUncategorizedItemsParams

WithSortBy adds the sortBy to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithStoreID 

func (o *QueryUncategorizedItemsParams) WithStoreID(storeID *string) *QueryUncategorizedItemsParams

WithStoreID adds the storeID to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WithTimeout 

func (o *QueryUncategorizedItemsParams) WithTimeout(timeout time.Duration) *QueryUncategorizedItemsParams

WithTimeout adds the timeout to the query uncategorized items params

func (*QueryUncategorizedItemsParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type QueryUncategorizedItemsReader 

type QueryUncategorizedItemsReader struct {
	// contains filtered or unexported fields
}

QueryUncategorizedItemsReader is a Reader for the QueryUncategorizedItems structure.

func (*QueryUncategorizedItemsReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type QueryUncategorizedItemsUnprocessableEntity 

type QueryUncategorizedItemsUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

QueryUncategorizedItemsUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewQueryUncategorizedItemsUnprocessableEntity 

func NewQueryUncategorizedItemsUnprocessableEntity() *QueryUncategorizedItemsUnprocessableEntity

NewQueryUncategorizedItemsUnprocessableEntity creates a QueryUncategorizedItemsUnprocessableEntity with default headers values

func (*QueryUncategorizedItemsUnprocessableEntity) Error 

func (o *QueryUncategorizedItemsUnprocessableEntity) Error() string

func (*QueryUncategorizedItemsUnprocessableEntity) GetPayload 

func (o *QueryUncategorizedItemsUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

type ReturnItemNoContent 

type ReturnItemNoContent struct {
}

ReturnItemNoContent handles this case with default header values. 

Return item successfully

func NewReturnItemNoContent 

func NewReturnItemNoContent() *ReturnItemNoContent

NewReturnItemNoContent creates a ReturnItemNoContent with default headers values

func (*ReturnItemNoContent) Error 

func (o *ReturnItemNoContent) Error() string

type ReturnItemNotFound 

type ReturnItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

ReturnItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewReturnItemNotFound 

func NewReturnItemNotFound() *ReturnItemNotFound

NewReturnItemNotFound creates a ReturnItemNotFound with default headers values

func (*ReturnItemNotFound) Error 

func (o *ReturnItemNotFound) Error() string

func (*ReturnItemNotFound) GetPayload 

func (o *ReturnItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type ReturnItemParams 

type ReturnItemParams struct {

	/*Body*/
	Body *platformclientmodels.ItemReturnRequest
	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

ReturnItemParams contains all the parameters to send to the API endpoint for the return item operation typically these are written to a http.Request

func NewReturnItemParams 

func NewReturnItemParams() *ReturnItemParams

NewReturnItemParams creates a new ReturnItemParams object with the default values initialized.

func NewReturnItemParamsWithContext 

func NewReturnItemParamsWithContext(ctx context.Context) *ReturnItemParams

NewReturnItemParamsWithContext creates a new ReturnItemParams object with the default values initialized, and the ability to set a context for a request

func NewReturnItemParamsWithHTTPClient 

func NewReturnItemParamsWithHTTPClient(client *http.Client) *ReturnItemParams

NewReturnItemParamsWithHTTPClient creates a new ReturnItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewReturnItemParamsWithTimeout 

func NewReturnItemParamsWithTimeout(timeout time.Duration) *ReturnItemParams

NewReturnItemParamsWithTimeout creates a new ReturnItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*ReturnItemParams) SetBody 

func (o *ReturnItemParams) SetBody(body *platformclientmodels.ItemReturnRequest)

SetBody adds the body to the return item params

func (*ReturnItemParams) SetContext 

func (o *ReturnItemParams) SetContext(ctx context.Context)

SetContext adds the context to the return item params

func (*ReturnItemParams) SetHTTPClient 

func (o *ReturnItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the return item params

func (*ReturnItemParams) SetItemID 

func (o *ReturnItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the return item params

func (*ReturnItemParams) SetNamespace 

func (o *ReturnItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the return item params

func (*ReturnItemParams) SetTimeout 

func (o *ReturnItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the return item params

func (*ReturnItemParams) WithBody 

func (o *ReturnItemParams) WithBody(body *platformclientmodels.ItemReturnRequest) *ReturnItemParams

WithBody adds the body to the return item params

func (*ReturnItemParams) WithContext 

func (o *ReturnItemParams) WithContext(ctx context.Context) *ReturnItemParams

WithContext adds the context to the return item params

func (*ReturnItemParams) WithHTTPClient 

func (o *ReturnItemParams) WithHTTPClient(client *http.Client) *ReturnItemParams

WithHTTPClient adds the HTTPClient to the return item params

func (*ReturnItemParams) WithItemID 

func (o *ReturnItemParams) WithItemID(itemID string) *ReturnItemParams

WithItemID adds the itemID to the return item params

func (*ReturnItemParams) WithNamespace 

func (o *ReturnItemParams) WithNamespace(namespace string) *ReturnItemParams

WithNamespace adds the namespace to the return item params

func (*ReturnItemParams) WithTimeout 

func (o *ReturnItemParams) WithTimeout(timeout time.Duration) *ReturnItemParams

WithTimeout adds the timeout to the return item params

func (*ReturnItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type ReturnItemReader 

type ReturnItemReader struct {
	// contains filtered or unexported fields
}

ReturnItemReader is a Reader for the ReturnItem structure.

func (*ReturnItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type ReturnItemUnprocessableEntity 

type ReturnItemUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

ReturnItemUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewReturnItemUnprocessableEntity 

func NewReturnItemUnprocessableEntity() *ReturnItemUnprocessableEntity

NewReturnItemUnprocessableEntity creates a ReturnItemUnprocessableEntity with default headers values

func (*ReturnItemUnprocessableEntity) Error 

func (o *ReturnItemUnprocessableEntity) Error() string

func (*ReturnItemUnprocessableEntity) GetPayload 

func (o *ReturnItemUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

type SearchItemsOK 

type SearchItemsOK struct {
	Payload *platformclientmodels.FullItemPagingSlicedResult
}

SearchItemsOK handles this case with default header values. 

successful operation

func NewSearchItemsOK 

func NewSearchItemsOK() *SearchItemsOK

NewSearchItemsOK creates a SearchItemsOK with default headers values

func (*SearchItemsOK) Error 

func (o *SearchItemsOK) Error() string

func (*SearchItemsOK) GetPayload 

func (o *SearchItemsOK) GetPayload() *platformclientmodels.FullItemPagingSlicedResult

type SearchItemsParams 

type SearchItemsParams struct {

	/*ActiveOnly*/
	ActiveOnly *bool
	/*Keyword*/
	Keyword string
	/*Language*/
	Language string
	/*Limit
	  limit

	*/
	Limit *int32
	/*Namespace*/
	Namespace string
	/*Offset
	  offset

	*/
	Offset *int32
	/*StoreID
	  default is published store id

	*/
	StoreID *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

SearchItemsParams contains all the parameters to send to the API endpoint for the search items operation typically these are written to a http.Request

func NewSearchItemsParams 

func NewSearchItemsParams() *SearchItemsParams

NewSearchItemsParams creates a new SearchItemsParams object with the default values initialized.

func NewSearchItemsParamsWithContext 

func NewSearchItemsParamsWithContext(ctx context.Context) *SearchItemsParams

NewSearchItemsParamsWithContext creates a new SearchItemsParams object with the default values initialized, and the ability to set a context for a request

func NewSearchItemsParamsWithHTTPClient 

func NewSearchItemsParamsWithHTTPClient(client *http.Client) *SearchItemsParams

NewSearchItemsParamsWithHTTPClient creates a new SearchItemsParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewSearchItemsParamsWithTimeout 

func NewSearchItemsParamsWithTimeout(timeout time.Duration) *SearchItemsParams

NewSearchItemsParamsWithTimeout creates a new SearchItemsParams object with the default values initialized, and the ability to set a timeout on a request

func (*SearchItemsParams) SetActiveOnly 

func (o *SearchItemsParams) SetActiveOnly(activeOnly *bool)

SetActiveOnly adds the activeOnly to the search items params

func (*SearchItemsParams) SetContext 

func (o *SearchItemsParams) SetContext(ctx context.Context)

SetContext adds the context to the search items params

func (*SearchItemsParams) SetHTTPClient 

func (o *SearchItemsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the search items params

func (*SearchItemsParams) SetKeyword 

func (o *SearchItemsParams) SetKeyword(keyword string)

SetKeyword adds the keyword to the search items params

func (*SearchItemsParams) SetLanguage 

func (o *SearchItemsParams) SetLanguage(language string)

SetLanguage adds the language to the search items params

func (*SearchItemsParams) SetLimit 

func (o *SearchItemsParams) SetLimit(limit *int32)

SetLimit adds the limit to the search items params

func (*SearchItemsParams) SetNamespace 

func (o *SearchItemsParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the search items params

func (*SearchItemsParams) SetOffset 

func (o *SearchItemsParams) SetOffset(offset *int32)

SetOffset adds the offset to the search items params

func (*SearchItemsParams) SetStoreID 

func (o *SearchItemsParams) SetStoreID(storeID *string)

SetStoreID adds the storeId to the search items params

func (*SearchItemsParams) SetTimeout 

func (o *SearchItemsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the search items params

func (*SearchItemsParams) WithActiveOnly 

func (o *SearchItemsParams) WithActiveOnly(activeOnly *bool) *SearchItemsParams

WithActiveOnly adds the activeOnly to the search items params

func (*SearchItemsParams) WithContext 

func (o *SearchItemsParams) WithContext(ctx context.Context) *SearchItemsParams

WithContext adds the context to the search items params

func (*SearchItemsParams) WithHTTPClient 

func (o *SearchItemsParams) WithHTTPClient(client *http.Client) *SearchItemsParams

WithHTTPClient adds the HTTPClient to the search items params

func (*SearchItemsParams) WithKeyword 

func (o *SearchItemsParams) WithKeyword(keyword string) *SearchItemsParams

WithKeyword adds the keyword to the search items params

func (*SearchItemsParams) WithLanguage 

func (o *SearchItemsParams) WithLanguage(language string) *SearchItemsParams

WithLanguage adds the language to the search items params

func (*SearchItemsParams) WithLimit 

func (o *SearchItemsParams) WithLimit(limit *int32) *SearchItemsParams

WithLimit adds the limit to the search items params

func (*SearchItemsParams) WithNamespace 

func (o *SearchItemsParams) WithNamespace(namespace string) *SearchItemsParams

WithNamespace adds the namespace to the search items params

func (*SearchItemsParams) WithOffset 

func (o *SearchItemsParams) WithOffset(offset *int32) *SearchItemsParams

WithOffset adds the offset to the search items params

func (*SearchItemsParams) WithStoreID 

func (o *SearchItemsParams) WithStoreID(storeID *string) *SearchItemsParams

WithStoreID adds the storeID to the search items params

func (*SearchItemsParams) WithTimeout 

func (o *SearchItemsParams) WithTimeout(timeout time.Duration) *SearchItemsParams

WithTimeout adds the timeout to the search items params

func (*SearchItemsParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type SearchItemsReader 

type SearchItemsReader struct {
	// contains filtered or unexported fields
}

SearchItemsReader is a Reader for the SearchItems structure.

func (*SearchItemsReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type SyncInGameItemBadRequest 

type SyncInGameItemBadRequest struct {
	Payload *platformclientmodels.ErrorEntity
}

SyncInGameItemBadRequest handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30021</td><td>Default language [{language}] required</td></tr><tr><td>30022</td><td>Default region [{region}] is required</td></tr><tr><td>30324</td><td>Invalid namespace [{namespace}]</td></tr></table>

func NewSyncInGameItemBadRequest 

func NewSyncInGameItemBadRequest() *SyncInGameItemBadRequest

NewSyncInGameItemBadRequest creates a SyncInGameItemBadRequest with default headers values

func (*SyncInGameItemBadRequest) Error 

func (o *SyncInGameItemBadRequest) Error() string

func (*SyncInGameItemBadRequest) GetPayload 

func (o *SyncInGameItemBadRequest) GetPayload() *platformclientmodels.ErrorEntity

type SyncInGameItemConflict 

type SyncInGameItemConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

SyncInGameItemConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr><tr><td>30373</td><td>ItemType [{itemType}] is not allowed in namespace [{namespace}]</td></tr></table>

func NewSyncInGameItemConflict 

func NewSyncInGameItemConflict() *SyncInGameItemConflict

NewSyncInGameItemConflict creates a SyncInGameItemConflict with default headers values

func (*SyncInGameItemConflict) Error 

func (o *SyncInGameItemConflict) Error() string

func (*SyncInGameItemConflict) GetPayload 

func (o *SyncInGameItemConflict) GetPayload() *platformclientmodels.ErrorEntity

type SyncInGameItemNotFound 

type SyncInGameItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

SyncInGameItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30241</td><td>Category [{categoryPath}] does not exist in namespace [{namespace}]</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr><tr><td>30141</td><td>Store [{storeId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewSyncInGameItemNotFound 

func NewSyncInGameItemNotFound() *SyncInGameItemNotFound

NewSyncInGameItemNotFound creates a SyncInGameItemNotFound with default headers values

func (*SyncInGameItemNotFound) Error 

func (o *SyncInGameItemNotFound) Error() string

func (*SyncInGameItemNotFound) GetPayload 

func (o *SyncInGameItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type SyncInGameItemOK 

type SyncInGameItemOK struct {
	Payload *platformclientmodels.FullItemInfo
}

SyncInGameItemOK handles this case with default header values. 

successful operation

func NewSyncInGameItemOK 

func NewSyncInGameItemOK() *SyncInGameItemOK

NewSyncInGameItemOK creates a SyncInGameItemOK with default headers values

func (*SyncInGameItemOK) Error 

func (o *SyncInGameItemOK) Error() string

func (*SyncInGameItemOK) GetPayload 

func (o *SyncInGameItemOK) GetPayload() *platformclientmodels.FullItemInfo

type SyncInGameItemParams 

type SyncInGameItemParams struct {

	/*Body*/
	Body *platformclientmodels.InGameItemSync
	/*Namespace
	  Namespace

	*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

SyncInGameItemParams contains all the parameters to send to the API endpoint for the sync in game item operation typically these are written to a http.Request

func NewSyncInGameItemParams 

func NewSyncInGameItemParams() *SyncInGameItemParams

NewSyncInGameItemParams creates a new SyncInGameItemParams object with the default values initialized.

func NewSyncInGameItemParamsWithContext 

func NewSyncInGameItemParamsWithContext(ctx context.Context) *SyncInGameItemParams

NewSyncInGameItemParamsWithContext creates a new SyncInGameItemParams object with the default values initialized, and the ability to set a context for a request

func NewSyncInGameItemParamsWithHTTPClient 

func NewSyncInGameItemParamsWithHTTPClient(client *http.Client) *SyncInGameItemParams

NewSyncInGameItemParamsWithHTTPClient creates a new SyncInGameItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewSyncInGameItemParamsWithTimeout 

func NewSyncInGameItemParamsWithTimeout(timeout time.Duration) *SyncInGameItemParams

NewSyncInGameItemParamsWithTimeout creates a new SyncInGameItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*SyncInGameItemParams) SetBody 

func (o *SyncInGameItemParams) SetBody(body *platformclientmodels.InGameItemSync)

SetBody adds the body to the sync in game item params

func (*SyncInGameItemParams) SetContext 

func (o *SyncInGameItemParams) SetContext(ctx context.Context)

SetContext adds the context to the sync in game item params

func (*SyncInGameItemParams) SetHTTPClient 

func (o *SyncInGameItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the sync in game item params

func (*SyncInGameItemParams) SetNamespace 

func (o *SyncInGameItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the sync in game item params

func (*SyncInGameItemParams) SetStoreID 

func (o *SyncInGameItemParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the sync in game item params

func (*SyncInGameItemParams) SetTimeout 

func (o *SyncInGameItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the sync in game item params

func (*SyncInGameItemParams) WithBody 

func (o *SyncInGameItemParams) WithBody(body *platformclientmodels.InGameItemSync) *SyncInGameItemParams

WithBody adds the body to the sync in game item params

func (*SyncInGameItemParams) WithContext 

func (o *SyncInGameItemParams) WithContext(ctx context.Context) *SyncInGameItemParams

WithContext adds the context to the sync in game item params

func (*SyncInGameItemParams) WithHTTPClient 

func (o *SyncInGameItemParams) WithHTTPClient(client *http.Client) *SyncInGameItemParams

WithHTTPClient adds the HTTPClient to the sync in game item params

func (*SyncInGameItemParams) WithNamespace 

func (o *SyncInGameItemParams) WithNamespace(namespace string) *SyncInGameItemParams

WithNamespace adds the namespace to the sync in game item params

func (*SyncInGameItemParams) WithStoreID 

func (o *SyncInGameItemParams) WithStoreID(storeID string) *SyncInGameItemParams

WithStoreID adds the storeID to the sync in game item params

func (*SyncInGameItemParams) WithTimeout 

func (o *SyncInGameItemParams) WithTimeout(timeout time.Duration) *SyncInGameItemParams

WithTimeout adds the timeout to the sync in game item params

func (*SyncInGameItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type SyncInGameItemReader 

type SyncInGameItemReader struct {
	// contains filtered or unexported fields
}

SyncInGameItemReader is a Reader for the SyncInGameItem structure.

func (*SyncInGameItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type SyncInGameItemUnprocessableEntity 

type SyncInGameItemUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

SyncInGameItemUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewSyncInGameItemUnprocessableEntity 

func NewSyncInGameItemUnprocessableEntity() *SyncInGameItemUnprocessableEntity

NewSyncInGameItemUnprocessableEntity creates a SyncInGameItemUnprocessableEntity with default headers values

func (*SyncInGameItemUnprocessableEntity) Error 

func (o *SyncInGameItemUnprocessableEntity) Error() string

func (*SyncInGameItemUnprocessableEntity) GetPayload 

func (o *SyncInGameItemUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

type UpdateAppConflict 

type UpdateAppConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

UpdateAppConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr></table>

func NewUpdateAppConflict 

func NewUpdateAppConflict() *UpdateAppConflict

NewUpdateAppConflict creates a UpdateAppConflict with default headers values

func (*UpdateAppConflict) Error 

func (o *UpdateAppConflict) Error() string

func (*UpdateAppConflict) GetPayload 

func (o *UpdateAppConflict) GetPayload() *platformclientmodels.ErrorEntity

type UpdateAppNotFound 

type UpdateAppNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

UpdateAppNotFound handles this case with default header values. 

<table><tr><tdErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr></table>

func NewUpdateAppNotFound 

func NewUpdateAppNotFound() *UpdateAppNotFound

NewUpdateAppNotFound creates a UpdateAppNotFound with default headers values

func (*UpdateAppNotFound) Error 

func (o *UpdateAppNotFound) Error() string

func (*UpdateAppNotFound) GetPayload 

func (o *UpdateAppNotFound) GetPayload() *platformclientmodels.ErrorEntity

type UpdateAppOK 

type UpdateAppOK struct {
	Payload *platformclientmodels.FullAppInfo
}

UpdateAppOK handles this case with default header values. 

successful operation

func NewUpdateAppOK 

func NewUpdateAppOK() *UpdateAppOK

NewUpdateAppOK creates a UpdateAppOK with default headers values

func (*UpdateAppOK) Error 

func (o *UpdateAppOK) Error() string

func (*UpdateAppOK) GetPayload 

func (o *UpdateAppOK) GetPayload() *platformclientmodels.FullAppInfo

type UpdateAppParams 

type UpdateAppParams struct {

	/*Body*/
	Body *platformclientmodels.AppUpdate
	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

UpdateAppParams contains all the parameters to send to the API endpoint for the update app operation typically these are written to a http.Request

func NewUpdateAppParams 

func NewUpdateAppParams() *UpdateAppParams

NewUpdateAppParams creates a new UpdateAppParams object with the default values initialized.

func NewUpdateAppParamsWithContext 

func NewUpdateAppParamsWithContext(ctx context.Context) *UpdateAppParams

NewUpdateAppParamsWithContext creates a new UpdateAppParams object with the default values initialized, and the ability to set a context for a request

func NewUpdateAppParamsWithHTTPClient 

func NewUpdateAppParamsWithHTTPClient(client *http.Client) *UpdateAppParams

NewUpdateAppParamsWithHTTPClient creates a new UpdateAppParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewUpdateAppParamsWithTimeout 

func NewUpdateAppParamsWithTimeout(timeout time.Duration) *UpdateAppParams

NewUpdateAppParamsWithTimeout creates a new UpdateAppParams object with the default values initialized, and the ability to set a timeout on a request

func (*UpdateAppParams) SetBody 

func (o *UpdateAppParams) SetBody(body *platformclientmodels.AppUpdate)

SetBody adds the body to the update app params

func (*UpdateAppParams) SetContext 

func (o *UpdateAppParams) SetContext(ctx context.Context)

SetContext adds the context to the update app params

func (*UpdateAppParams) SetHTTPClient 

func (o *UpdateAppParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the update app params

func (*UpdateAppParams) SetItemID 

func (o *UpdateAppParams) SetItemID(itemID string)

SetItemID adds the itemId to the update app params

func (*UpdateAppParams) SetNamespace 

func (o *UpdateAppParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the update app params

func (*UpdateAppParams) SetStoreID 

func (o *UpdateAppParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the update app params

func (*UpdateAppParams) SetTimeout 

func (o *UpdateAppParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the update app params

func (*UpdateAppParams) WithBody 

func (o *UpdateAppParams) WithBody(body *platformclientmodels.AppUpdate) *UpdateAppParams

WithBody adds the body to the update app params

func (*UpdateAppParams) WithContext 

func (o *UpdateAppParams) WithContext(ctx context.Context) *UpdateAppParams

WithContext adds the context to the update app params

func (*UpdateAppParams) WithHTTPClient 

func (o *UpdateAppParams) WithHTTPClient(client *http.Client) *UpdateAppParams

WithHTTPClient adds the HTTPClient to the update app params

func (*UpdateAppParams) WithItemID 

func (o *UpdateAppParams) WithItemID(itemID string) *UpdateAppParams

WithItemID adds the itemID to the update app params

func (*UpdateAppParams) WithNamespace 

func (o *UpdateAppParams) WithNamespace(namespace string) *UpdateAppParams

WithNamespace adds the namespace to the update app params

func (*UpdateAppParams) WithStoreID 

func (o *UpdateAppParams) WithStoreID(storeID string) *UpdateAppParams

WithStoreID adds the storeID to the update app params

func (*UpdateAppParams) WithTimeout 

func (o *UpdateAppParams) WithTimeout(timeout time.Duration) *UpdateAppParams

WithTimeout adds the timeout to the update app params

func (*UpdateAppParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type UpdateAppReader 

type UpdateAppReader struct {
	// contains filtered or unexported fields
}

UpdateAppReader is a Reader for the UpdateApp structure.

func (*UpdateAppReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type UpdateAppUnprocessableEntity 

type UpdateAppUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

UpdateAppUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewUpdateAppUnprocessableEntity 

func NewUpdateAppUnprocessableEntity() *UpdateAppUnprocessableEntity

NewUpdateAppUnprocessableEntity creates a UpdateAppUnprocessableEntity with default headers values

func (*UpdateAppUnprocessableEntity) Error 

func (o *UpdateAppUnprocessableEntity) Error() string

func (*UpdateAppUnprocessableEntity) GetPayload 

func (o *UpdateAppUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

type UpdateItemBadRequest 

type UpdateItemBadRequest struct {
	Payload *platformclientmodels.ErrorEntity
}

UpdateItemBadRequest handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30322</td><td>Bundle item [{itemId}] can't be bundled</td></tr><tr><td>30325</td><td>Code item [{itemId}] can't be bundled</td></tr><tr><td>30326</td><td>Subscription item [{itemId}] can't be bundled</td></tr><tr><td>30021</td><td>Default language [{language}] required</td></tr><tr><td>30321</td><td>Invalid item discount amount</td></tr><tr><td>30022</td><td>Default region [{region}] is required</td></tr><tr><td>30323</td><td>Target namespace is required</td></tr><tr><td>30327</td><td>Invalid item trial price</td></tr></table>

func NewUpdateItemBadRequest 

func NewUpdateItemBadRequest() *UpdateItemBadRequest

NewUpdateItemBadRequest creates a UpdateItemBadRequest with default headers values

func (*UpdateItemBadRequest) Error 

func (o *UpdateItemBadRequest) Error() string

func (*UpdateItemBadRequest) GetPayload 

func (o *UpdateItemBadRequest) GetPayload() *platformclientmodels.ErrorEntity

type UpdateItemConflict 

type UpdateItemConflict struct {
	Payload *platformclientmodels.ErrorEntity
}

UpdateItemConflict handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30173</td><td>Published store can't modify content</td></tr><tr><td>30371</td><td>Item maxCount not allow reduce</td></tr><tr><td>30372</td><td>ItemType is not updatable</td></tr></table>

func NewUpdateItemConflict 

func NewUpdateItemConflict() *UpdateItemConflict

NewUpdateItemConflict creates a UpdateItemConflict with default headers values

func (*UpdateItemConflict) Error 

func (o *UpdateItemConflict) Error() string

func (*UpdateItemConflict) GetPayload 

func (o *UpdateItemConflict) GetPayload() *platformclientmodels.ErrorEntity

type UpdateItemNotFound 

type UpdateItemNotFound struct {
	Payload *platformclientmodels.ErrorEntity
}

UpdateItemNotFound handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>30341</td><td>Item [{itemId}] does not exist in namespace [{namespace}]</td></tr><tr><td>30241</td><td>Category [{categoryPath}] does not exist in namespace [{namespace}]</td></tr><tr><td>36141</td><td>Currency [{currencyCode}] does not exist in namespace [{namespace}]</td></tr></table>

func NewUpdateItemNotFound 

func NewUpdateItemNotFound() *UpdateItemNotFound

NewUpdateItemNotFound creates a UpdateItemNotFound with default headers values

func (*UpdateItemNotFound) Error 

func (o *UpdateItemNotFound) Error() string

func (*UpdateItemNotFound) GetPayload 

func (o *UpdateItemNotFound) GetPayload() *platformclientmodels.ErrorEntity

type UpdateItemOK 

type UpdateItemOK struct {
	Payload *platformclientmodels.FullItemInfo
}

UpdateItemOK handles this case with default header values. 

successful operation

func NewUpdateItemOK 

func NewUpdateItemOK() *UpdateItemOK

NewUpdateItemOK creates a UpdateItemOK with default headers values

func (*UpdateItemOK) Error 

func (o *UpdateItemOK) Error() string

func (*UpdateItemOK) GetPayload 

func (o *UpdateItemOK) GetPayload() *platformclientmodels.FullItemInfo

type UpdateItemParams 

type UpdateItemParams struct {

	/*Body*/
	Body *platformclientmodels.ItemUpdate
	/*ItemID*/
	ItemID string
	/*Namespace*/
	Namespace string
	/*StoreID*/
	StoreID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

UpdateItemParams contains all the parameters to send to the API endpoint for the update item operation typically these are written to a http.Request

func NewUpdateItemParams 

func NewUpdateItemParams() *UpdateItemParams

NewUpdateItemParams creates a new UpdateItemParams object with the default values initialized.

func NewUpdateItemParamsWithContext 

func NewUpdateItemParamsWithContext(ctx context.Context) *UpdateItemParams

NewUpdateItemParamsWithContext creates a new UpdateItemParams object with the default values initialized, and the ability to set a context for a request

func NewUpdateItemParamsWithHTTPClient 

func NewUpdateItemParamsWithHTTPClient(client *http.Client) *UpdateItemParams

NewUpdateItemParamsWithHTTPClient creates a new UpdateItemParams object with the default values initialized, and the ability to set a custom HTTPClient for a request

func NewUpdateItemParamsWithTimeout 

func NewUpdateItemParamsWithTimeout(timeout time.Duration) *UpdateItemParams

NewUpdateItemParamsWithTimeout creates a new UpdateItemParams object with the default values initialized, and the ability to set a timeout on a request

func (*UpdateItemParams) SetBody 

func (o *UpdateItemParams) SetBody(body *platformclientmodels.ItemUpdate)

SetBody adds the body to the update item params

func (*UpdateItemParams) SetContext 

func (o *UpdateItemParams) SetContext(ctx context.Context)

SetContext adds the context to the update item params

func (*UpdateItemParams) SetHTTPClient 

func (o *UpdateItemParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the update item params

func (*UpdateItemParams) SetItemID 

func (o *UpdateItemParams) SetItemID(itemID string)

SetItemID adds the itemId to the update item params

func (*UpdateItemParams) SetNamespace 

func (o *UpdateItemParams) SetNamespace(namespace string)

SetNamespace adds the namespace to the update item params

func (*UpdateItemParams) SetStoreID 

func (o *UpdateItemParams) SetStoreID(storeID string)

SetStoreID adds the storeId to the update item params

func (*UpdateItemParams) SetTimeout 

func (o *UpdateItemParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the update item params

func (*UpdateItemParams) WithBody 

func (o *UpdateItemParams) WithBody(body *platformclientmodels.ItemUpdate) *UpdateItemParams

WithBody adds the body to the update item params

func (*UpdateItemParams) WithContext 

func (o *UpdateItemParams) WithContext(ctx context.Context) *UpdateItemParams

WithContext adds the context to the update item params

func (*UpdateItemParams) WithHTTPClient 

func (o *UpdateItemParams) WithHTTPClient(client *http.Client) *UpdateItemParams

WithHTTPClient adds the HTTPClient to the update item params

func (*UpdateItemParams) WithItemID 

func (o *UpdateItemParams) WithItemID(itemID string) *UpdateItemParams

WithItemID adds the itemID to the update item params

func (*UpdateItemParams) WithNamespace 

func (o *UpdateItemParams) WithNamespace(namespace string) *UpdateItemParams

WithNamespace adds the namespace to the update item params

func (*UpdateItemParams) WithStoreID 

func (o *UpdateItemParams) WithStoreID(storeID string) *UpdateItemParams

WithStoreID adds the storeID to the update item params

func (*UpdateItemParams) WithTimeout 

func (o *UpdateItemParams) WithTimeout(timeout time.Duration) *UpdateItemParams

WithTimeout adds the timeout to the update item params

func (*UpdateItemParams) WriteToRequest 

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

WriteToRequest writes these params to a swagger request

type UpdateItemReader 

type UpdateItemReader struct {
	// contains filtered or unexported fields
}

UpdateItemReader is a Reader for the UpdateItem structure.

func (*UpdateItemReader) ReadResponse 

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

ReadResponse reads a server response into the received o.

type UpdateItemUnprocessableEntity 

type UpdateItemUnprocessableEntity struct {
	Payload *platformclientmodels.ValidationErrorEntity
}

UpdateItemUnprocessableEntity handles this case with default header values. 

<table><tr><td>ErrorCode</td><td>ErrorMessage</td></tr><tr><td>20002</td><td>validation error</td></tr></table>

func NewUpdateItemUnprocessableEntity 

func NewUpdateItemUnprocessableEntity() *UpdateItemUnprocessableEntity

NewUpdateItemUnprocessableEntity creates a UpdateItemUnprocessableEntity with default headers values

func (*UpdateItemUnprocessableEntity) Error 

func (o *UpdateItemUnprocessableEntity) Error() string

func (*UpdateItemUnprocessableEntity) GetPayload 

func (o *UpdateItemUnprocessableEntity) GetPayload() *platformclientmodels.ValidationErrorEntity

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.