shopify

type BulkOperationService interface {
	BulkQuery(query string, v interface{}) error

	PostBulkQuery(query string) (null.String, error)
	GetCurrentBulkQuery() (*model.BulkOperation, error)
	GetCurrentBulkQueryResultURL() (string, error)
	WaitForCurrentBulkQuery(interval time.Duration) (*model.BulkOperation, error)
	ShouldGetBulkQueryResultURL(id null.String) (string, error)
	CancelRunningBulkQuery() error
}

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

type Client struct {
	Product      ProductService
	Variant      VariantService
	Inventory    InventoryService
	Collection   CollectionService
	Order        OrderService
	Fulfillment  FulfillmentService
	Location     LocationService
	Metafield    MetafieldService
	PriceList    PriceListService
	StagedUpload StagedUploadService
	File         FileService

	BulkOperation BulkOperationService
	// contains filtered or unexported fields
}

type CollectionService interface {
	ListAll() ([]model.Collection, error)

	Get(id graphql.ID) (*model.Collection, error)

	Create(collection model.CollectionInput) (string, error)
	CreateBulk(collections []model.CollectionInput) error

	Update(collection model.CollectionInput) error
}

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

type File struct {
	Alt        string      `json:"alt"`
	CreatedAt  string      `json:"createdAt"`
	FileStatus string      `json:"fileStatus"`
	FileErrors []FileError `json:"fileErrors"`
}

type FileCreateInput struct {
	OriginalSource string `json:"originalSource"`
	ContentType    string `json:"contentType"`
}

type FileError struct {
	Code    string `json:"code"`
	Details string `json:"details"`
	Message string `json:"message"`
}

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

type FileService interface {
	FileCreate(ctx context.Context, files []FileCreateInput) ([]File, error)
	GetFileStatusByName(ctx context.Context, fileName string) (*FileStatus, error)
}

type FileStatus struct {
	ID     string `json:"id"`
	URL    string `json:"url"`
	Status string `json:"fileStatus"`
}

type FulfillmentService interface {
	Create(input model.FulfillmentV2Input) error
}

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

type GQLClient interface {
	Mutate(ctx context.Context, m interface{}, variables map[string]interface{}) error
	QueryString(ctx context.Context, q string, variables map[string]interface{}, v interface{}) error
}

type InventoryService interface {
	Update(id graphql.ID, input model.InventoryItemUpdateInput) error
	Adjust(locationID graphql.ID, input []model.InventoryAdjustItemInput) error
	ActivateInventory(locationID graphql.ID, id graphql.ID) error
}

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

type ListOptions struct {
	Query   string
	First   int
	Last    int
	After   string
	Before  string
	Reverse bool
}

type LocationService interface {
	Get(id graphql.ID) (*model.Location, error)
}

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

type MetafieldService interface {
	ListAllShopMetafields() ([]model.Metafield, error)
	ListShopMetafieldsByNamespace(namespace string) ([]model.Metafield, error)

	GetShopMetafieldByKey(namespace, key string) (model.Metafield, error)

	Delete(metafield model.MetafieldDeleteInput) error
	DeleteBulk(metafield []model.MetafieldDeleteInput) error
}

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

type OrderService interface {
	Get(id graphql.ID) (*model.Order, error)

	List(opts ListOptions) ([]model.Order, error)
	ListAll() ([]model.Order, error)

	ListAfterCursor(opts ListOptions) ([]model.Order, string, string, error)

	Update(input model.OrderInput) error

	GetFulfillmentOrdersAtLocation(orderID graphql.ID, locationID graphql.ID) ([]model.FulfillmentOrder, error)
}

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

type Parameter struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type PriceList struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	Currency string `json:"currency"`
}

type PriceListBulkQueryClient interface {
	BulkQuery(query string, v interface{}) error
}

type PriceListMutationClient interface {
	Mutate(ctx context.Context, m interface{}, variables map[string]interface{}) error
}

type PriceListPriceInput struct {
	CompareAtPrice model.MoneyInput `json:"compareAtPrice"`
	Price          model.MoneyInput `json:"price"`
	VariantID      string           `json:"variantId"`
}

type PriceListService interface {
	GetPriceLists(ctx context.Context) ([]PriceList, error)
	AddFixedPricesToPriceList(ctx context.Context, priceListID string, prices []PriceListPriceInput) error
}

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

type ProductCreate struct {
	ProductInput model.ProductInput
	MediaInput   []model.CreateMediaInput
}

type ProductService interface {
	List(query string) ([]model.Product, error)
	ListAll() ([]model.Product, error)

	Get(gid graphql.ID) (*model.Product, error)

	Create(product model.ProductInput, media []model.CreateMediaInput) (string, error)
	CreateBulk(products []ProductCreate) error

	Update(product model.ProductInput) error
	UpdateBulk(products []model.ProductInput) error

	Delete(product model.ProductDeleteInput) error
	DeleteBulk(products []model.ProductDeleteInput) error
}

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

type StagedMediaUploadTarget struct {
	URL         string       `json:"url"`
	ResourceURL string       `json:"resourceUrl"`
	Parameters  []*Parameter `json:"parameters"`
}

type StagedUploadInput struct {
	FileName string `json:"filename"`
	MimeType string `json:"mimeType"`
	Resource string `json:"resource"`
}

type StagedUploadMutationClient interface {
	Mutate(ctx context.Context, m interface{}, variables map[string]interface{}) error
}

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

type StagedUploadService interface {
	CreateStagedUpload(ctx context.Context, uploads []StagedUploadInput) ([]StagedMediaUploadTarget, error)
}

type VariantService interface {
	Update(variant model.ProductVariantInput) error
}

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