itemep

type AddItemAttributeEndpoint struct{}

type AddItemAttributeRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
	// ID of the attribute to assign to the item.
	AttributeID string `path:"attribute_id" validate:"required"`
}

type BulkCreateItemInput struct {
	// SKU for the new item, unique within the account.
	//
	// If an item with this SKU already exists, that item is updated in place (description, category, and product line) instead of a new item being created; this path additionally requires permission to update items, and the result for the row is still reported with status `created`.
	SKU string `json:"sku" validate:"required"`
	// Item description.
	Description field.Optional[string] `json:"description,omitzero"`
	// ID of the category to assign to the item.
	//
	// The category determines the base unit the item's rates are expressed in, so choose one whose unit group matches how the item is counted.
	ItemCategoryID string `json:"item_category_id" validate:"required"`
	// ID of the product line to assign the item's product to.
	//
	// Only applies when `type` is `product`; ignored for materials and parts.
	ProductLineID field.Optional[string] `json:"product_line_id,omitzero"`
}

type BulkCreateItemsEndpoint struct{}

type BulkCreateItemsRequest struct {
	// Items to create.
	Items []BulkCreateItemInput `json:"items" validate:"required"`
	// The item type applied to every item in the request.
	//
	// - `product`: a finished product.
	// - `material`: a raw material or component consumed in production.
	// - `part`: a part used in production.
	Type constants.ItemTypeCode `json:"type" validate:"required"`
}

type BulkReconcileItemInput struct {
	// SKU of the item to reconcile.
	//
	// Items whose SKU does not match an existing item are reported in the response's `skipped_items` rather than failing the request.
	SKU string `json:"sku" validate:"required"`
	// Abbreviation of a unit available to your account (e.g. `kg`).
	//
	// The unit is checked for existence only: the quantity is always recorded in the item's own base unit, so send figures already expressed in that unit. Rows naming an abbreviation that matches no built-in or account-defined unit are reported in the response's `errors`.
	Unit string `json:"unit" validate:"required"`
	// Quantity to apply, interpreted according to the request's `reconcile_type`.
	//
	// A decimal string rather than a number: a quantity that has been through a binary float is not the quantity you sent.
	Quantity string `json:"quantity" validate:"required" format:"decimal"`
}

type BulkReconcileItemsEndpoint struct{}

type BulkReconcileItemsRequest struct {
	// Items to reconcile.
	Data []BulkReconcileItemInput `json:"data" validate:"required"`
	// How each item's quantity is applied to its current quantity.
	//
	// - `addition`: adds the quantity to the item's current quantity.
	// - `force`: sets the item's current quantity to exactly the given quantity.
	ReconcileType constants.ItemReconcileType `json:"reconcile_type" validate:"required"`
}

type ChangeItemCategoryEndpoint struct{}

type ChangeItemCategoryRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
	// ID of the category to move the item to.
	//
	// The category's type has to suit the item: a material can only move to a material category, and a product or part can only move to a product category. Anything else fails validation.
	//
	// The category also has to carry the properties of every attribute the item already has, since the move keeps those attributes. Unlink the offending attributes, or add their properties to the target category, before moving the item.
	CategoryID string `path:"category_id" validate:"required"`
}

type ExportItemsEndpoint struct{}

type ExportItemsRequest struct{}

type GetItemCostsEndpoint struct{}

type GetItemCostsRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
}

type GetItemTrendsEndpoint struct{}

type GetItemTrendsRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
	// The trend metric to fetch.
	//
	// `inventory` returns the item's inventory-level measurements from the last 30 days.
	TrendType constants.ItemTrendType `query:"trend_type" validate:"required"`
}

type ItemSvc interface {
	ListItems(ctx context.Context, req *ListItemsRequest) (*apiresource.List[apiresource.Item], *apierror.APIError)
	GetItem(ctx context.Context, req *RetrieveItemRequest) (*apiresource.Item, *apierror.APIError)
	GetItemInventory(ctx context.Context, req *RetrieveItemInventoryRequest) (*apiresource.ItemInventory, *apierror.APIError)
	GetItemLotDefault(ctx context.Context, req *RetrieveItemLotDefaultRequest) (*apiresource.ItemLotDefault, *apierror.APIError)
	GetItemCosts(ctx context.Context, req *GetItemCostsRequest) (*apiresource.ItemCosts, *apierror.APIError)
	GetItemTrends(ctx context.Context, req *GetItemTrendsRequest) (*apiresource.ItemTrends, *apierror.APIError)
	ExportItems(ctx context.Context, req *ExportItemsRequest) (*httptransport.FileDownload, *apierror.APIError)
	AddItemAttribute(ctx context.Context, req *AddItemAttributeRequest) (*apiresource.Item, *apierror.APIError)
	RemoveItemAttribute(ctx context.Context, req *RemoveItemAttributeRequest) (*apiresource.Item, *apierror.APIError)
	ChangeItemCategory(ctx context.Context, req *ChangeItemCategoryRequest) (*apiresource.Item, *apierror.APIError)
	UpdateItemInventory(ctx context.Context, req *UpdateItemInventoryRequest) (*apiresource.EmptyResource, *apierror.APIError)
	BulkCreateItems(ctx context.Context, req *BulkCreateItemsRequest) (*apiresource.BulkCreateItemsResponse, *apierror.APIError)
	BulkReconcileItems(ctx context.Context, req *BulkReconcileItemsRequest) (*apiresource.BulkReconcileItemsResponse, *apierror.APIError)
}

type ItemSvcConfig struct {
	// CoreClient (required) is the core-service gRPC client.
	CoreClient pb.CoreServiceClient
}

type ListItemsEndpoint struct{}

type ListItemsRequest struct {
	apiresource.PaginationRequest
	// Filter to items of these types (`product`, `material`, `part`).
	Types []string `query:"types"`
	// Filter to items in any of these categories.
	CategoryIDs []string `query:"category_ids"`
	// Filter to items carrying any of these attributes.
	AttributeIDs []string `query:"attribute_ids"`
	// Filter to materials this supplier account supplies to you.
	//
	// Only materials can have suppliers, so combining this with a `types` filter that excludes `material` returns nothing.
	SupplierID *string `query:"supplier_id"`
	// Filter to items created on or after this date.
	StartDate *time.Time `query:"starts_at"`
	// Filter to items created on or before this date.
	EndDate *time.Time `query:"ends_at"`
	// Restricts results based on where the item is produced in its production flow.
	//
	// - `all`: no restriction.
	// - `initial_only`: only items produced by an initial production step, i.e. a step with no upstream steps feeding into it.
	SubassemblyFilter *constants.SubassemblyFilter `query:"subassembly_filter" default:"all"`
	// Filter to items whose product belongs to any of these product lines.
	ProductLineIDs []string `query:"product_line_ids"`
	// Filter to items any of these customers are allowed to order.
	//
	// A customer qualifies when its relationship, its account group, or its price group grants access to the product line the item's product sits in. Items with no product line, including materials and parts, never match.
	CustomerIDs []string `query:"customer_ids"`
}

type RemoveItemAttributeEndpoint struct{}

type RemoveItemAttributeRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
	// ID of the attribute to unassign from the item.
	AttributeID string `path:"attribute_id" validate:"required"`
}

type RetrieveItemEndpoint struct{}

type RetrieveItemInventoryEndpoint struct{}

type RetrieveItemInventoryRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
}

type RetrieveItemLotDefaultEndpoint struct{}

type RetrieveItemLotDefaultRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
}

type RetrieveItemRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
}

type UpdateItemInventoryEndpoint struct{}

type UpdateItemInventoryRequest struct {
	// Item ID.
	ItemID string `path:"id" validate:"required"`
	// The quantity to apply, interpreted according to `operation`.
	//
	// With `adjust` it is added to the current quantity and may be negative; with `reconcile` the current quantity is set to exactly this value. It is recorded in the unit you send it in, and the current quantity a `reconcile` measures against is read in that same unit, so a reconcile to the figure already reported moves no stock.
	Quantity apirequest.QuantityInput `json:"quantity" validate:"required"`
	// How `quantity` is applied.
	//
	// - `adjust`: adds `quantity` to the current quantity.
	// - `reconcile`: sets the current quantity to exactly `quantity`.
	Operation field.Optional[constants.InventoryUpdateOperation] `json:"operation,omitzero"`
	// ID of the customer account that owns the resulting inventory.
	//
	// Use this for stock you hold but do not own, such as customer-supplied material. It only affects quantity being added: your account stays the holder, the customer becomes the owner, and the current quantity a `reconcile` measures against is still your account's. Requires edit access to that customer.
	CustomerID field.Optional[string] `json:"customer_id,omitzero" validate:"omitempty"`
	// ID of the location to record the inventory change against.
	//
	// Must be a location in your account.
	LocationID field.Optional[string] `json:"location_id,omitzero" validate:"omitempty"`
	// Lot number to record the inventory change against.
	//
	// The lot is created for the item if it does not already exist.
	LotNumber field.Optional[string] `json:"lot_number,omitzero" validate:"omitempty,max=255"`
}