// @generated — do not edit
import { createDomainError } from "@tailor-platform/erp-kit/core";

export const StockAdjustmentNotFoundError = createDomainError(
  "StockAdjustmentNotFoundError", "INVENTORY_STOCK_ADJUSTMENT_NOT_FOUND",
  (identifier: string) => `Referenced stock adjustment does not exist: ${identifier}`,
);

export const InvalidStatusError = createDomainError(
  "InvalidStatusError", "INVENTORY_INVALID_STATUS",
  (identifier: string) => `Target entity is not in a valid status for this operation: ${identifier}`,
);

export const InventorySupplyPlanNotFoundError = createDomainError(
  "InventorySupplyPlanNotFoundError", "INVENTORY_INVENTORY_SUPPLY_PLAN_NOT_FOUND",
  (identifier: string) => `Referenced supply plan does not exist: ${identifier}`,
);

export const SupplyPlanNotOpenError = createDomainError(
  "SupplyPlanNotOpenError", "INVENTORY_SUPPLY_PLAN_NOT_OPEN",
  (identifier: string) => `Supply plan is not OPEN: ${identifier}`,
);

export const StockReservationNotFoundError = createDomainError(
  "StockReservationNotFoundError", "INVENTORY_STOCK_RESERVATION_NOT_FOUND",
  (identifier: string) => `Referenced stock reservation does not exist: ${identifier}`,
);

export const StockReservationNotOpenError = createDomainError(
  "StockReservationNotOpenError", "INVENTORY_STOCK_RESERVATION_NOT_OPEN",
  (identifier: string) => `Stock reservation is not OPEN: ${identifier}`,
);

export const TransferOrderNotFoundError = createDomainError(
  "TransferOrderNotFoundError", "INVENTORY_TRANSFER_ORDER_NOT_FOUND",
  (identifier: string) => `Transfer order does not exist: ${identifier}`,
);

export const InvalidStateTransitionError = createDomainError(
  "InvalidStateTransitionError", "INVENTORY_INVALID_STATE_TRANSITION",
  (identifier: string) => `Transfer order lifecycle transition is not allowed: ${identifier}`,
);

export const TransferOrderInTransitError = createDomainError(
  "TransferOrderInTransitError", "INVENTORY_TRANSFER_ORDER_IN_TRANSIT",
  (identifier: string) => `One or more lines still have in-transit quantity: ${identifier}`,
);

export const InsufficientStockError = createDomainError(
  "InsufficientStockError", "INVENTORY_INSUFFICIENT_STOCK",
  (identifier: string) => `Available stock cannot cover the requested quantity: ${identifier}`,
);

export const ItemNotFoundError = createDomainError(
  "ItemNotFoundError", "INVENTORY_ITEM_NOT_FOUND",
  (identifier: string) => `Referenced item does not exist: ${identifier}`,
);

export const SupplyPlanUnitMismatchError = createDomainError(
  "SupplyPlanUnitMismatchError", "INVENTORY_SUPPLY_PLAN_UNIT_MISMATCH",
  (identifier: string) => `unitId differs from Item.unitId; caller did not normalize the quantity before inventory handoff: ${identifier}`,
);

export const SiteNotFoundError = createDomainError(
  "SiteNotFoundError", "INVENTORY_SITE_NOT_FOUND",
  (identifier: string) => `Referenced site does not exist: ${identifier}`,
);

export const InvalidSupplyPlanQuantitiesError = createDomainError(
  "InvalidSupplyPlanQuantitiesError", "INVENTORY_INVALID_SUPPLY_PLAN_QUANTITIES",
  (identifier: string) => `Quantity values are invalid for a supply plan: ${identifier}`,
);

export const EmptyAdjustmentLinesError = createDomainError(
  "EmptyAdjustmentLinesError", "INVENTORY_EMPTY_ADJUSTMENT_LINES",
  (identifier: string) => `No adjustment lines were provided: ${identifier}`,
);

export const ReasonCodeRequiredError = createDomainError(
  "ReasonCodeRequiredError", "INVENTORY_REASON_CODE_REQUIRED",
  (identifier: string) => `Reason code was not provided: ${identifier}`,
);

export const ItemNotActiveError = createDomainError(
  "ItemNotActiveError", "INVENTORY_ITEM_NOT_ACTIVE",
  (identifier: string) => `Referenced item is not in ACTIVE status: ${identifier}`,
);

export const StorageLocationNotFoundError = createDomainError(
  "StorageLocationNotFoundError", "INVENTORY_STORAGE_LOCATION_NOT_FOUND",
  (identifier: string) => `Referenced storage location does not exist: ${identifier}`,
);

export const StorageLocationNotActiveError = createDomainError(
  "StorageLocationNotActiveError", "INVENTORY_STORAGE_LOCATION_NOT_ACTIVE",
  (identifier: string) => `Referenced storage location is not in ACTIVE status: ${identifier}`,
);

export const InvalidQuantityError = createDomainError(
  "InvalidQuantityError", "INVENTORY_INVALID_QUANTITY",
  (identifier: string) => `Quantity is zero or negative: ${identifier}`,
);

export const InvalidFromStockCategoryError = createDomainError(
  "InvalidFromStockCategoryError", "INVENTORY_INVALID_FROM_STOCK_CATEGORY",
  (identifier: string) => `fromStockCategory was set on a non-SCRAP line: ${identifier}`,
);

export const InvalidReservationQuantitiesError = createDomainError(
  "InvalidReservationQuantitiesError", "INVENTORY_INVALID_RESERVATION_QUANTITIES",
  (identifier: string) => `Quantity values are invalid for a stock reservation: ${identifier}`,
);

export const InsufficientAvailableStockError = createDomainError(
  "InsufficientAvailableStockError", "INVENTORY_INSUFFICIENT_AVAILABLE_STOCK",
  (identifier: string) => `Available stock is less than the requested quantity: ${identifier}`,
);

export const SiteInactiveError = createDomainError(
  "SiteInactiveError", "INVENTORY_SITE_INACTIVE",
  (identifier: string) => `Referenced site is not in ACTIVE status: ${identifier}`,
);

export const DuplicateLocationNameError = createDomainError(
  "DuplicateLocationNameError", "INVENTORY_DUPLICATE_LOCATION_NAME",
  (identifier: string) => `A location with the same name or code already exists in the site: ${identifier}`,
);

export const EmptyTransferLinesError = createDomainError(
  "EmptyTransferLinesError", "INVENTORY_EMPTY_TRANSFER_LINES",
  (identifier: string) => `No transfer lines were provided: ${identifier}`,
);

export const InvalidTransferLocationsError = createDomainError(
  "InvalidTransferLocationsError", "INVENTORY_INVALID_TRANSFER_LOCATIONS",
  (identifier: string) => `Transfer location or site is invalid: ${identifier}`,
);

export const CrossCompanyTransferNotSupportedError = createDomainError(
  "CrossCompanyTransferNotSupportedError", "INVENTORY_CROSS_COMPANY_TRANSFER_NOT_SUPPORTED",
  (identifier: string) => `Transfer between sites of different companies is not supported: ${identifier}`,
);

export const InvalidArgumentError = createDomainError(
  "InvalidArgumentError", "INVENTORY_INVALID_ARGUMENT",
  (identifier: string) => `Argument is invalid: ${identifier}`,
);

export const CompanyNotFoundError = createDomainError(
  "CompanyNotFoundError", "INVENTORY_COMPANY_NOT_FOUND",
  (identifier: string) => `Referenced company does not exist: ${identifier}`,
);

export const AccountNotFoundError = createDomainError(
  "AccountNotFoundError", "INVENTORY_ACCOUNT_NOT_FOUND",
  (identifier: string) => `Referenced posting account does not exist in the company: ${identifier}`,
);

export const DefaultValuationPolicyAlreadyExistsError = createDomainError(
  "DefaultValuationPolicyAlreadyExistsError", "INVENTORY_DEFAULT_VALUATION_POLICY_ALREADY_EXISTS",
  (identifier: string) => `Another valuation policy in the same company is already marked as the default: ${identifier}`,
);

export const ConsumptionTreatmentNotSupportedError = createDomainError(
  "ConsumptionTreatmentNotSupportedError", "INVENTORY_CONSUMPTION_TREATMENT_NOT_SUPPORTED",
  (identifier: string) => `A consumed slice's ledger entry has no defined treatment mapping: ${identifier}`,
);

export const DefaultValuationPolicyNotFoundError = createDomainError(
  "DefaultValuationPolicyNotFoundError", "INVENTORY_DEFAULT_VALUATION_POLICY_NOT_FOUND",
  (identifier: string) => `No valuation policy is assigned to the item and the movement company has no default policy: ${identifier}`,
);

export const FifoCostNotFoundError = createDomainError(
  "FifoCostNotFoundError", "INVENTORY_FIFO_COST_NOT_FOUND",
  (identifier: string) => `A cost layer has no price row: ${identifier}`,
);

export const AverageCostNotFoundError = createDomainError(
  "AverageCostNotFoundError", "INVENTORY_AVERAGE_COST_NOT_FOUND",
  (identifier: string) => `The item has no moving-average state in the company: ${identifier}`,
);

export const AccountingPeriodNotFoundError = createDomainError(
  "AccountingPeriodNotFoundError", "INVENTORY_ACCOUNTING_PERIOD_NOT_FOUND",
  (identifier: string) => `No accounting period covers the posting date: ${identifier}`,
);

export const JournalEntryCreateFailedError = createDomainError(
  "JournalEntryCreateFailedError", "INVENTORY_JOURNAL_ENTRY_CREATE_FAILED",
  (identifier: string) => `Journal entry creation failed: ${identifier}`,
);

export const JournalEntryPostFailedError = createDomainError(
  "JournalEntryPostFailedError", "INVENTORY_JOURNAL_ENTRY_POST_FAILED",
  (identifier: string) => `Journal entry posting failed: ${identifier}`,
);

export const EmptyMovementLinesError = createDomainError(
  "EmptyMovementLinesError", "INVENTORY_EMPTY_MOVEMENT_LINES",
  (identifier: string) => `No movement lines were provided: ${identifier}`,
);

export const InvalidUnitCostError = createDomainError(
  "InvalidUnitCostError", "INVENTORY_INVALID_UNIT_COST",
  (identifier: string) => `Unit cost is negative: ${identifier}`,
);

export const CostingEventNotSupportedError = createDomainError(
  "CostingEventNotSupportedError", "INVENTORY_COSTING_EVENT_NOT_SUPPORTED",
  (identifier: string) => `No costing treatment is defined for the line's source type and action: ${identifier}`,
);

export const StandardCostNotFoundError = createDomainError(
  "StandardCostNotFoundError", "INVENTORY_STANDARD_COST_NOT_FOUND",
  (identifier: string) => `The item has no published standard cost: ${identifier}`,
);

export const UnitCostRequiredError = createDomainError(
  "UnitCostRequiredError", "INVENTORY_UNIT_COST_REQUIRED",
  (identifier: string) => `An actual-cost (FIFO or AVERAGE) receipt line carries no unit cost: ${identifier}`,
);

export const ItemValuationNotFoundError = createDomainError(
  "ItemValuationNotFoundError", "INVENTORY_ITEM_VALUATION_NOT_FOUND",
  (identifier: string) => `No valuation record exists for the specified item: ${identifier}`,
);

export const StorageLocationNotInactiveError = createDomainError(
  "StorageLocationNotInactiveError", "INVENTORY_STORAGE_LOCATION_NOT_INACTIVE",
  (identifier: string) => `Storage location is not in INACTIVE status: ${identifier}`,
);

export const TransferOrderLineNotFoundError = createDomainError(
  "TransferOrderLineNotFoundError", "INVENTORY_TRANSFER_ORDER_LINE_NOT_FOUND",
  (identifier: string) => `Transfer order line does not exist or does not belong to the order: ${identifier}`,
);

export const ValuationPolicyNotFoundError = createDomainError(
  "ValuationPolicyNotFoundError", "INVENTORY_VALUATION_POLICY_NOT_FOUND",
  (identifier: string) => `Referenced valuation policy does not exist: ${identifier}`,
);

export const ValuationPolicyCompanyMismatchError = createDomainError(
  "ValuationPolicyCompanyMismatchError", "INVENTORY_VALUATION_POLICY_COMPANY_MISMATCH",
  (identifier: string) => `Referenced valuation policy belongs to a different company: ${identifier}`,
);

export const ItemValuationPolicyChangeNotAllowedError = createDomainError(
  "ItemValuationPolicyChangeNotAllowedError", "INVENTORY_ITEM_VALUATION_POLICY_CHANGE_NOT_ALLOWED",
  (identifier: string) => `Valuation policy cannot be changed once the item has inventory ledger history: ${identifier}`,
);

export const StockAdjustmentLineNotFoundError = createDomainError(
  "StockAdjustmentLineNotFoundError", "INVENTORY_STOCK_ADJUSTMENT_LINE_NOT_FOUND",
  (identifier: string) => `Referenced stock adjustment line does not exist on the target adjustment: ${identifier}`,
);

export const NoFilterProvidedError = createDomainError(
  "NoFilterProvidedError", "INVENTORY_NO_FILTER_PROVIDED",
  (identifier: string) => `At least one filter must be specified: ${identifier}`,
);