convexity-sdk 0.15.0.dev286__tar.gz → 0.15.0.dev289__tar.gz

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: convexity-sdk
-Version: 0.15.0.dev286
+Version: 0.15.0.dev289
 Summary: Convexity Python SDK - programmatic access to the Convexity platform
 Requires-Python: >=3.12
 Requires-Dist: convexity-api-client

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/client.py

@@ -12,6 +12,7 @@ from .config import SDKConfig, resolve_config
 from .http import AsyncTransport, SyncTransport
 
 if TYPE_CHECKING:
+    from .resources.address_book import AddressBook
     from .resources.api_keys import ApiKeys
     from .resources.attributes import Attributes
     from .resources.categories import Categories
@@ -317,6 +318,15 @@ class ConvexityClient:
             self._erp_config = ERPConfig(self._api_client)
         return self._erp_config
 
+    @property
+    def address_book(self) -> AddressBook:
+        """Access ERP address book operations."""
+        if not hasattr(self, "_address_book"):
+            from .resources.address_book import AddressBook
+
+            self._address_book = AddressBook(self._api_client)
+        return self._address_book
+
     @property
     def crm(self) -> CRM:
         """Access CRM customer/account operations."""

convexity_sdk-0.15.0.dev289/convexity_sdk/resources/address_book.py

@@ -0,0 +1,72 @@
+"""Address book resource client."""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import erp_bulk_upsert_address_book_entries as _bulk_upsert_entries
+from convexity_api_client.api.v1 import erp_list_address_book_entries as _list_entries
+from convexity_api_client.models.bulk_upsert_address_book_entries_request import BulkUpsertAddressBookEntriesRequest
+from convexity_api_client.models.bulk_upsert_address_book_entries_response import BulkUpsertAddressBookEntriesResponse
+from convexity_api_client.models.bulk_upsert_address_book_entry_payload import BulkUpsertAddressBookEntryPayload
+from convexity_api_client.models.list_address_book_entries_response import ListAddressBookEntriesResponse
+from convexity_api_client.types import UNSET, Unset
+
+ResponseT = TypeVar("ResponseT")
+
+
+def _expect_response(result: object, response_type: type[ResponseT], action: str) -> ResponseT:
+    if not isinstance(result, response_type):
+        raise ValueError(f"Unexpected response when {action}: {result}")
+    return result
+
+
+def _optional(value: Any | None) -> Any | Unset:
+    return UNSET if value is None else value
+
+
+def _bulk_entry_payload(payload: BulkUpsertAddressBookEntryPayload | dict[str, Any]) -> BulkUpsertAddressBookEntryPayload:
+    return payload if isinstance(payload, BulkUpsertAddressBookEntryPayload) else BulkUpsertAddressBookEntryPayload.from_dict(payload)
+
+
+class AddressBook:
+    """Synchronous sub-client for ERP address book entries."""
+
+    def __init__(self, api_client: AuthenticatedClient | Client) -> None:
+        self._client = api_client
+
+    def list_entries(
+        self,
+        *,
+        project_id: str,
+        owner_type: str,
+        owner_id: str,
+        is_active: bool | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> ListAddressBookEntriesResponse:
+        """List address book entries for an owner."""
+        result = _list_entries.sync(
+            client=self._client,
+            owner_type=owner_type,
+            owner_id=owner_id,
+            is_active=_optional(is_active),
+            limit=limit,
+            offset=offset,
+            project_id=project_id,
+        )
+        if isinstance(result, ListAddressBookEntriesResponse):
+            return result
+        return ListAddressBookEntriesResponse(entries=[], total=0)
+
+    def bulk_upsert_entries(
+        self,
+        *,
+        project_id: str,
+        entries: list[BulkUpsertAddressBookEntryPayload | dict[str, Any]],
+    ) -> BulkUpsertAddressBookEntriesResponse:
+        """Bulk upsert address book entries by owner and label."""
+        body = BulkUpsertAddressBookEntriesRequest(entries=[_bulk_entry_payload(entry) for entry in entries])
+        result = _bulk_upsert_entries.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertAddressBookEntriesResponse, "bulk upserting address book entries")

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/attributes.py

@@ -10,6 +10,9 @@ from typing import Any, TypeVar, cast
 
 from convexity_api_client import AuthenticatedClient, Client
 from convexity_api_client.api.v1 import inventory_add_attribute_line as _add_attribute_line
+from convexity_api_client.api.v1 import inventory_bulk_upsert_attribute_values as _bulk_upsert_attribute_values
+from convexity_api_client.api.v1 import inventory_bulk_upsert_attributes as _bulk_upsert_attributes
+from convexity_api_client.api.v1 import inventory_bulk_upsert_template_attribute_lines as _bulk_upsert_template_attribute_lines
 from convexity_api_client.api.v1 import inventory_create_attribute as _create_attribute
 from convexity_api_client.api.v1 import inventory_create_attribute_value as _create_attribute_value
 from convexity_api_client.api.v1 import inventory_get_attribute as _get_attribute
@@ -19,6 +22,15 @@ from convexity_api_client.api.v1 import inventory_list_attributes as _list_attri
 from convexity_api_client.api.v1 import inventory_remove_attribute_line as _remove_attribute_line
 from convexity_api_client.models.add_attribute_line_request import AddAttributeLineRequest
 from convexity_api_client.models.attribute_with_values_response import AttributeWithValuesResponse
+from convexity_api_client.models.bulk_upsert_item_attribute_payload import BulkUpsertItemAttributePayload
+from convexity_api_client.models.bulk_upsert_item_attribute_value_payload import BulkUpsertItemAttributeValuePayload
+from convexity_api_client.models.bulk_upsert_item_attribute_values_request import BulkUpsertItemAttributeValuesRequest
+from convexity_api_client.models.bulk_upsert_item_attribute_values_response import BulkUpsertItemAttributeValuesResponse
+from convexity_api_client.models.bulk_upsert_item_attributes_request import BulkUpsertItemAttributesRequest
+from convexity_api_client.models.bulk_upsert_item_attributes_response import BulkUpsertItemAttributesResponse
+from convexity_api_client.models.bulk_upsert_template_attribute_line_payload import BulkUpsertTemplateAttributeLinePayload
+from convexity_api_client.models.bulk_upsert_template_attribute_lines_request import BulkUpsertTemplateAttributeLinesRequest
+from convexity_api_client.models.bulk_upsert_template_attribute_lines_response import BulkUpsertTemplateAttributeLinesResponse
 from convexity_api_client.models.create_item_attribute_request import CreateItemAttributeRequest
 from convexity_api_client.models.create_item_attribute_value_request import CreateItemAttributeValueRequest
 from convexity_api_client.models.item_attribute_response import ItemAttributeResponse
@@ -44,6 +56,18 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_attribute_payload(payload: BulkUpsertItemAttributePayload | dict[str, Any]) -> BulkUpsertItemAttributePayload:
+    return payload if isinstance(payload, BulkUpsertItemAttributePayload) else BulkUpsertItemAttributePayload.from_dict(payload)
+
+
+def _bulk_attribute_value_payload(payload: BulkUpsertItemAttributeValuePayload | dict[str, Any]) -> BulkUpsertItemAttributeValuePayload:
+    return payload if isinstance(payload, BulkUpsertItemAttributeValuePayload) else BulkUpsertItemAttributeValuePayload.from_dict(payload)
+
+
+def _bulk_attribute_line_payload(payload: BulkUpsertTemplateAttributeLinePayload | dict[str, Any]) -> BulkUpsertTemplateAttributeLinePayload:
+    return payload if isinstance(payload, BulkUpsertTemplateAttributeLinePayload) else BulkUpsertTemplateAttributeLinePayload.from_dict(payload)
+
+
 class Attributes:
     """Synchronous sub-client for item attribute management."""
 
@@ -111,6 +135,17 @@ class Attributes:
             return result
         return ListItemAttributesResponse(attributes=[], total=0)
 
+    def bulk_upsert_attributes(
+        self,
+        *,
+        project_id: str,
+        attributes: list[BulkUpsertItemAttributePayload | dict[str, Any]],
+    ) -> BulkUpsertItemAttributesResponse:
+        """Bulk upsert item attributes by code."""
+        body = BulkUpsertItemAttributesRequest(attributes=[_bulk_attribute_payload(attribute) for attribute in attributes])
+        result = _bulk_upsert_attributes.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertItemAttributesResponse, "bulk upserting item attributes")
+
     # -- Attribute Values -----------------------------------------------------
 
     def create_attribute_value(
@@ -153,6 +188,17 @@ class Attributes:
             return result
         return ListItemAttributeValuesResponse(values=[], total=0)
 
+    def bulk_upsert_attribute_values(
+        self,
+        *,
+        project_id: str,
+        values: list[BulkUpsertItemAttributeValuePayload | dict[str, Any]],
+    ) -> BulkUpsertItemAttributeValuesResponse:
+        """Bulk upsert item attribute values by attribute and value code."""
+        body = BulkUpsertItemAttributeValuesRequest(values=[_bulk_attribute_value_payload(value) for value in values])
+        result = _bulk_upsert_attribute_values.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertItemAttributeValuesResponse, "bulk upserting item attribute values")
+
     # -- Template Attribute Lines ---------------------------------------------
 
     def add_attribute_line(
@@ -197,3 +243,14 @@ class Attributes:
         if isinstance(result, ListTemplateAttributeLineDetailsResponse):
             return result
         return ListTemplateAttributeLineDetailsResponse(lines=[])
+
+    def bulk_upsert_template_attribute_lines(
+        self,
+        *,
+        project_id: str,
+        lines: list[BulkUpsertTemplateAttributeLinePayload | dict[str, Any]],
+    ) -> BulkUpsertTemplateAttributeLinesResponse:
+        """Bulk upsert template attribute lines and enabled values."""
+        body = BulkUpsertTemplateAttributeLinesRequest(lines=[_bulk_attribute_line_payload(line) for line in lines])
+        result = _bulk_upsert_template_attribute_lines.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertTemplateAttributeLinesResponse, "bulk upserting template attribute lines")

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/cost_lists.py

@@ -11,6 +11,7 @@ from datetime import datetime
 from typing import Any, TypeVar, cast
 
 from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import inventory_bulk_upsert_cost_rules as _bulk_upsert_cost_rules
 from convexity_api_client.api.v1 import inventory_create_cost_list as _create_cost_list
 from convexity_api_client.api.v1 import inventory_create_cost_rule as _create_cost_rule
 from convexity_api_client.api.v1 import inventory_delete_cost_list as _delete_cost_list
@@ -21,6 +22,9 @@ from convexity_api_client.api.v1 import inventory_list_cost_lists as _list_cost_
 from convexity_api_client.api.v1 import inventory_list_cost_rules as _list_cost_rules
 from convexity_api_client.api.v1 import inventory_update_cost_list as _update_cost_list
 from convexity_api_client.api.v1 import inventory_update_cost_rule as _update_cost_rule
+from convexity_api_client.models.bulk_upsert_cost_rule_payload import BulkUpsertCostRulePayload
+from convexity_api_client.models.bulk_upsert_cost_rules_request import BulkUpsertCostRulesRequest
+from convexity_api_client.models.bulk_upsert_cost_rules_response import BulkUpsertCostRulesResponse
 from convexity_api_client.models.cost_list_response import CostListResponse
 from convexity_api_client.models.cost_rule_response import CostRuleResponse
 from convexity_api_client.models.create_cost_list_request import CreateCostListRequest
@@ -45,6 +49,10 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_cost_rule_payload(payload: BulkUpsertCostRulePayload | dict[str, Any]) -> BulkUpsertCostRulePayload:
+    return payload if isinstance(payload, BulkUpsertCostRulePayload) else BulkUpsertCostRulePayload.from_dict(payload)
+
+
 def _to_item_match(value: dict[str, Any] | None) -> ItemMatchInput | Unset:
     if value is None:
         return UNSET
@@ -237,3 +245,14 @@ class CostLists:
     def delete_cost_rule(self, cost_rule_id: str, *, project_id: str) -> CostRuleResponse:
         result = _delete_cost_rule.sync(cost_rule_id, client=self._client, project_id=project_id)
         return _expect_response(result, CostRuleResponse, "deleting cost rule")
+
+    def bulk_upsert_cost_rules(
+        self,
+        *,
+        project_id: str,
+        rules: list[BulkUpsertCostRulePayload | dict[str, Any]],
+    ) -> BulkUpsertCostRulesResponse:
+        """Bulk upsert cost rules by import key."""
+        body = BulkUpsertCostRulesRequest(rules=[_bulk_cost_rule_payload(rule) for rule in rules])
+        result = _bulk_upsert_cost_rules.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertCostRulesResponse, "bulk upserting cost rules")

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/crm.py

@@ -5,11 +5,15 @@ from __future__ import annotations
 from typing import Any, TypeVar, cast
 
 from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import crm_bulk_upsert_customers as _bulk_upsert_customers
 from convexity_api_client.api.v1 import crm_create_customer as _create_customer
 from convexity_api_client.api.v1 import crm_delete_customer as _delete_customer
 from convexity_api_client.api.v1 import crm_get_customer as _get_customer
 from convexity_api_client.api.v1 import crm_list_customers as _list_customers
 from convexity_api_client.api.v1 import crm_update_customer as _update_customer
+from convexity_api_client.models.bulk_upsert_customer_payload import BulkUpsertCustomerPayload
+from convexity_api_client.models.bulk_upsert_customers_request import BulkUpsertCustomersRequest
+from convexity_api_client.models.bulk_upsert_customers_response import BulkUpsertCustomersResponse
 from convexity_api_client.models.create_customer_request import CreateCustomerRequest
 from convexity_api_client.models.customer_response import CustomerResponse
 from convexity_api_client.models.list_customers_response import ListCustomersResponse
@@ -29,6 +33,10 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_customer_payload(payload: BulkUpsertCustomerPayload | dict[str, Any]) -> BulkUpsertCustomerPayload:
+    return payload if isinstance(payload, BulkUpsertCustomerPayload) else BulkUpsertCustomerPayload.from_dict(payload)
+
+
 class CRM:
     """Synchronous sub-client for CRM customer operations."""
 
@@ -66,6 +74,17 @@ class CRM:
         result = _create_customer.sync(client=self._client, body=body, project_id=project_id)
         return _expect_response(result, CustomerResponse, "creating customer")
 
+    def bulk_upsert_customers(
+        self,
+        *,
+        project_id: str,
+        customers: list[BulkUpsertCustomerPayload | dict[str, Any]],
+    ) -> BulkUpsertCustomersResponse:
+        """Bulk upsert CRM customers by code."""
+        body = BulkUpsertCustomersRequest(customers=[_bulk_customer_payload(customer) for customer in customers])
+        result = _bulk_upsert_customers.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertCustomersResponse, "bulk upserting customers")
+
     def list_customers(
         self,
         *,

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/erp_config.py

@@ -5,13 +5,19 @@ from __future__ import annotations
 from typing import Any, TypeVar, cast
 
 from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import erp_config_bulk_upsert_status_mappings as _bulk_upsert_status_mappings
 from convexity_api_client.api.v1 import erp_config_get_module_gate as _get_module_gate
 from convexity_api_client.api.v1 import erp_config_list_module_gates as _list_module_gates
+from convexity_api_client.api.v1 import erp_config_list_status_mappings as _list_status_mappings
 from convexity_api_client.api.v1 import erp_config_upsert_module_gate as _upsert_module_gate
+from convexity_api_client.models.bulk_upsert_status_mappings_request import BulkUpsertStatusMappingsRequest
+from convexity_api_client.models.bulk_upsert_status_mappings_response import BulkUpsertStatusMappingsResponse
 from convexity_api_client.models.erp_module_gate_response import ERPModuleGateResponse
 from convexity_api_client.models.erp_module_key import ERPModuleKey
 from convexity_api_client.models.list_module_gates_response import ListModuleGatesResponse
+from convexity_api_client.models.list_status_mappings_response import ListStatusMappingsResponse
 from convexity_api_client.models.upsert_erp_module_gate_request import UpsertERPModuleGateRequest
+from convexity_api_client.models.upsert_status_mapping_request import UpsertStatusMappingRequest
 from convexity_api_client.types import UNSET, Unset
 
 ResponseT = TypeVar("ResponseT")
@@ -33,6 +39,10 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _status_mapping_payload(payload: UpsertStatusMappingRequest | dict[str, Any]) -> UpsertStatusMappingRequest:
+    return payload if isinstance(payload, UpsertStatusMappingRequest) else UpsertStatusMappingRequest.from_dict(payload)
+
+
 class ERPConfig:
     """Synchronous sub-client for ERP configuration and module gates."""
 
@@ -106,3 +116,36 @@ class ERPConfig:
         normalized_key = _module_key(module_key)
         gates = self.list_module_gates(project_id=project_id, limit=100)
         return any(gate.module_key == normalized_key and gate.is_enabled for gate in gates.gates)
+
+    def list_status_mappings(
+        self,
+        *,
+        project_id: str,
+        source_system: str | None = None,
+        entity_type: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> ListStatusMappingsResponse:
+        """List ERP status mappings for a project."""
+        result = _list_status_mappings.sync(
+            client=self._client,
+            source_system=_optional(source_system),
+            entity_type=_optional(entity_type),
+            limit=limit,
+            offset=offset,
+            project_id=project_id,
+        )
+        if isinstance(result, ListStatusMappingsResponse):
+            return result
+        return ListStatusMappingsResponse(mappings=[], total=0)
+
+    def bulk_upsert_status_mappings(
+        self,
+        *,
+        project_id: str,
+        mappings: list[UpsertStatusMappingRequest | dict[str, Any]],
+    ) -> BulkUpsertStatusMappingsResponse:
+        """Bulk upsert ERP status mappings."""
+        body = BulkUpsertStatusMappingsRequest(mappings=[_status_mapping_payload(mapping) for mapping in mappings])
+        result = _bulk_upsert_status_mappings.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertStatusMappingsResponse, "bulk upserting ERP status mappings")

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/inventory.py

@@ -15,6 +15,7 @@ from convexity_api_client.api.v1 import inventory_bulk_import_items as _bulk_imp
 from convexity_api_client.api.v1 import (
     inventory_bulk_post_stock_transactions as _bulk_post_stock_transactions,
 )
+from convexity_api_client.api.v1 import inventory_bulk_reconcile_stock_balances as _bulk_reconcile_stock_balances
 from convexity_api_client.api.v1 import inventory_deactivate_item as _deactivate_item
 from convexity_api_client.api.v1 import inventory_get_item as _get_item
 from convexity_api_client.api.v1 import (
@@ -38,6 +39,9 @@ from convexity_api_client.models.bulk_import_inventory_item_request import BulkI
 from convexity_api_client.models.bulk_import_inventory_item_response import BulkImportInventoryItemResponse
 from convexity_api_client.models.bulk_post_stock_transactions_request import BulkPostStockTransactionsRequest
 from convexity_api_client.models.bulk_post_stock_transactions_response import BulkPostStockTransactionsResponse
+from convexity_api_client.models.bulk_reconcile_stock_balance_payload import BulkReconcileStockBalancePayload
+from convexity_api_client.models.bulk_reconcile_stock_balances_request import BulkReconcileStockBalancesRequest
+from convexity_api_client.models.bulk_reconcile_stock_balances_response import BulkReconcileStockBalancesResponse
 from convexity_api_client.models.create_inventory_item_request import CreateInventoryItemRequest
 from convexity_api_client.models.inventory_item_response import InventoryItemResponse
 from convexity_api_client.models.list_inventory_items_response import ListInventoryItemsResponse
@@ -70,6 +74,18 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_reconcile_payload(payload: BulkReconcileStockBalancePayload | dict[str, Any]) -> BulkReconcileStockBalancePayload:
+    return payload if isinstance(payload, BulkReconcileStockBalancePayload) else BulkReconcileStockBalancePayload.from_dict(payload)
+
+
+def _response_count(value: int | Unset) -> int:
+    return value if isinstance(value, int) else 0
+
+
+def _response_errors(value: list[str] | Unset) -> list[str]:
+    return [] if isinstance(value, Unset) else value
+
+
 class Inventory:
     """Synchronous sub-client for inventory item and stock operations."""
 
@@ -238,6 +254,41 @@ class Inventory:
             errors=all_errors if all_errors else UNSET,
         )
 
+    def bulk_reconcile_stock_balances(
+        self,
+        *,
+        project_id: str,
+        balances: Sequence[BulkReconcileStockBalancePayload | dict[str, Any]],
+        chunk_size: int = 1000,
+    ) -> BulkReconcileStockBalancesResponse:
+        """Bulk reconcile stock balances to exact target on-hand quantities."""
+        all_balances = [_bulk_reconcile_payload(balance) for balance in balances]
+        if len(all_balances) <= chunk_size:
+            body = BulkReconcileStockBalancesRequest(balances=all_balances)
+            result = _bulk_reconcile_stock_balances.sync(client=self._client, body=body, project_id=project_id)
+            return _expect_response(result, BulkReconcileStockBalancesResponse, "bulk reconciling stock balances")
+
+        total_created = 0
+        total_updated = 0
+        total_skipped = 0
+        all_errors: list[str] = []
+        for i in range(0, len(all_balances), chunk_size):
+            chunk = all_balances[i : i + chunk_size]
+            body = BulkReconcileStockBalancesRequest(balances=chunk)
+            result = _bulk_reconcile_stock_balances.sync(client=self._client, body=body, project_id=project_id)
+            response = _expect_response(result, BulkReconcileStockBalancesResponse, "bulk reconciling stock balances")
+            total_created += _response_count(response.created)
+            total_updated += _response_count(response.updated)
+            total_skipped += _response_count(response.skipped)
+            all_errors.extend(_response_errors(response.errors))
+
+        return BulkReconcileStockBalancesResponse(
+            created=total_created,
+            updated=total_updated,
+            skipped=total_skipped,
+            errors=all_errors,
+        )
+
     def adjust_stock(
         self,
         *,

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/pricing.py

@@ -11,6 +11,7 @@ from datetime import datetime
 from typing import Any, TypeVar, cast
 
 from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import inventory_bulk_upsert_price_rules as _bulk_upsert_price_rules
 from convexity_api_client.api.v1 import inventory_create_price_list as _create_price_list
 from convexity_api_client.api.v1 import inventory_create_price_rule as _create_price_rule
 from convexity_api_client.api.v1 import inventory_delete_price_list as _delete_price_list
@@ -22,6 +23,9 @@ from convexity_api_client.api.v1 import inventory_list_price_rules as _list_pric
 from convexity_api_client.api.v1 import inventory_resolve_price as _resolve_price
 from convexity_api_client.api.v1 import inventory_update_price_list as _update_price_list
 from convexity_api_client.api.v1 import inventory_update_price_rule as _update_price_rule
+from convexity_api_client.models.bulk_upsert_price_rule_payload import BulkUpsertPriceRulePayload
+from convexity_api_client.models.bulk_upsert_price_rules_request import BulkUpsertPriceRulesRequest
+from convexity_api_client.models.bulk_upsert_price_rules_response import BulkUpsertPriceRulesResponse
 from convexity_api_client.models.create_price_list_request import CreatePriceListRequest
 from convexity_api_client.models.create_price_rule_request import CreatePriceRuleRequest
 from convexity_api_client.models.item_match_input import ItemMatchInput
@@ -55,6 +59,10 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_price_rule_payload(payload: BulkUpsertPriceRulePayload | dict[str, Any]) -> BulkUpsertPriceRulePayload:
+    return payload if isinstance(payload, BulkUpsertPriceRulePayload) else BulkUpsertPriceRulePayload.from_dict(payload)
+
+
 def _to_item_match(value: dict[str, Any] | None) -> ItemMatchInput | Unset:
     if value is None:
         return UNSET
@@ -258,6 +266,17 @@ class Pricing:
         result = _delete_price_rule.sync(price_rule_id, client=self._client, project_id=project_id)
         return _expect_response(result, PriceRuleResponse, "deleting price rule")
 
+    def bulk_upsert_price_rules(
+        self,
+        *,
+        project_id: str,
+        rules: list[BulkUpsertPriceRulePayload | dict[str, Any]],
+    ) -> BulkUpsertPriceRulesResponse:
+        """Bulk upsert price rules by import key."""
+        body = BulkUpsertPriceRulesRequest(rules=[_bulk_price_rule_payload(rule) for rule in rules])
+        result = _bulk_upsert_price_rules.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertPriceRulesResponse, "bulk upserting price rules")
+
     # -- Price resolution ----------------------------------------------------
 
     def resolve_price(

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/purchasing.py

@@ -11,6 +11,7 @@ from convexity_api_client.api.v1 import purchasing_approve_po as _approve_po
 from convexity_api_client.api.v1 import purchasing_batch_delete_pos as _batch_delete_pos
 from convexity_api_client.api.v1 import purchasing_batch_delete_vendors as _batch_delete_vendors
 from convexity_api_client.api.v1 import purchasing_bulk_create_pos as _bulk_create_pos
+from convexity_api_client.api.v1 import purchasing_bulk_upsert_vendors as _bulk_upsert_vendors
 from convexity_api_client.api.v1 import purchasing_cancel_po as _cancel_po
 from convexity_api_client.api.v1 import purchasing_confirm_po as _confirm_po
 from convexity_api_client.api.v1 import purchasing_create_po as _create_po
@@ -30,6 +31,9 @@ from convexity_api_client.models.batch_delete_vendors_request import BatchDelete
 from convexity_api_client.models.batch_delete_vendors_response import BatchDeleteVendorsResponse
 from convexity_api_client.models.bulk_create_purchase_orders_request import BulkCreatePurchaseOrdersRequest
 from convexity_api_client.models.bulk_create_purchase_orders_response import BulkCreatePurchaseOrdersResponse
+from convexity_api_client.models.bulk_upsert_vendor_payload import BulkUpsertVendorPayload
+from convexity_api_client.models.bulk_upsert_vendors_request import BulkUpsertVendorsRequest
+from convexity_api_client.models.bulk_upsert_vendors_response import BulkUpsertVendorsResponse
 from convexity_api_client.models.cancel_purchase_order_request import CancelPurchaseOrderRequest
 from convexity_api_client.models.canonical_status import CanonicalStatus
 from convexity_api_client.models.create_purchase_order_request import CreatePurchaseOrderRequest
@@ -57,6 +61,10 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_vendor_payload(payload: BulkUpsertVendorPayload | dict[str, Any]) -> BulkUpsertVendorPayload:
+    return payload if isinstance(payload, BulkUpsertVendorPayload) else BulkUpsertVendorPayload.from_dict(payload)
+
+
 def _po_status(value: CanonicalStatus | str | None) -> CanonicalStatus | None:
     if value is None or isinstance(value, CanonicalStatus):
         return value
@@ -122,6 +130,17 @@ class Purchasing:
         result = _create_vendor.sync(client=self._client, body=body, project_id=project_id)
         return _expect_response(result, VendorResponse, "creating vendor")
 
+    def bulk_upsert_vendors(
+        self,
+        *,
+        project_id: str,
+        vendors: list[BulkUpsertVendorPayload | dict[str, Any]],
+    ) -> BulkUpsertVendorsResponse:
+        """Bulk upsert vendors by code."""
+        body = BulkUpsertVendorsRequest(vendors=[_bulk_vendor_payload(vendor) for vendor in vendors])
+        result = _bulk_upsert_vendors.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertVendorsResponse, "bulk upserting vendors")
+
     def list_vendors(
         self,
         *,

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/sales.py

@@ -8,6 +8,7 @@ from typing import Any, TypeVar, cast
 
 from convexity_api_client import AuthenticatedClient, Client
 from convexity_api_client.api.v1 import sales_batch_delete_orders as _batch_delete_orders
+from convexity_api_client.api.v1 import sales_bulk_upsert_orders as _bulk_upsert_orders
 from convexity_api_client.api.v1 import sales_cancel_invoice as _cancel_invoice
 from convexity_api_client.api.v1 import sales_create_invoice as _create_invoice
 from convexity_api_client.api.v1 import sales_create_order as _create_order
@@ -22,6 +23,9 @@ from convexity_api_client.api.v1 import sales_resolve_invoice_dispute as _resolv
 from convexity_api_client.api.v1 import sales_update_invoice as _update_invoice
 from convexity_api_client.models.batch_delete_sales_orders_request import BatchDeleteSalesOrdersRequest
 from convexity_api_client.models.batch_delete_sales_orders_response import BatchDeleteSalesOrdersResponse
+from convexity_api_client.models.bulk_upsert_sales_order_payload import BulkUpsertSalesOrderPayload
+from convexity_api_client.models.bulk_upsert_sales_orders_request import BulkUpsertSalesOrdersRequest
+from convexity_api_client.models.bulk_upsert_sales_orders_response import BulkUpsertSalesOrdersResponse
 from convexity_api_client.models.cancel_sales_invoice_request import CancelSalesInvoiceRequest
 from convexity_api_client.models.canonical_status import CanonicalStatus
 from convexity_api_client.models.create_sales_invoice_request import CreateSalesInvoiceRequest
@@ -74,6 +78,10 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_sales_order_payload(payload: BulkUpsertSalesOrderPayload | dict[str, Any]) -> BulkUpsertSalesOrderPayload:
+    return payload if isinstance(payload, BulkUpsertSalesOrderPayload) else BulkUpsertSalesOrderPayload.from_dict(payload)
+
+
 def _invoice_source(value: SalesInvoiceSource | str) -> SalesInvoiceSource:
     if isinstance(value, SalesInvoiceSource):
         return value
@@ -319,6 +327,17 @@ class Sales:
         result = _create_order.sync(client=self._client, body=body, project_id=project_id)
         return _expect_response(result, SalesOrderResponse, "creating sales order")
 
+    def bulk_upsert_orders(
+        self,
+        *,
+        project_id: str,
+        orders: list[BulkUpsertSalesOrderPayload | dict[str, Any]],
+    ) -> BulkUpsertSalesOrdersResponse:
+        """Bulk upsert sales orders by sales order number."""
+        body = BulkUpsertSalesOrdersRequest(orders=[_bulk_sales_order_payload(order) for order in orders])
+        result = _bulk_upsert_orders.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertSalesOrdersResponse, "bulk upserting sales orders")
+
     def list_orders(
         self,
         *,

{convexity_sdk-0.15.0.dev286 → convexity_sdk-0.15.0.dev289}/convexity_sdk/resources/templates.py

@@ -12,6 +12,8 @@ from __future__ import annotations
 from typing import Any, TypeVar, cast
 
 from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import inventory_bulk_upsert_templates as _bulk_upsert_templates
+from convexity_api_client.api.v1 import inventory_bulk_upsert_variants as _bulk_upsert_variants
 from convexity_api_client.api.v1 import inventory_create_template as _create_template
 from convexity_api_client.api.v1 import inventory_create_variant as _create_variant
 from convexity_api_client.api.v1 import inventory_delete_identifier as _delete_identifier
@@ -20,6 +22,12 @@ from convexity_api_client.api.v1 import inventory_list_identifiers as _list_iden
 from convexity_api_client.api.v1 import inventory_list_templates as _list_templates
 from convexity_api_client.api.v1 import inventory_update_template as _update_template
 from convexity_api_client.api.v1 import inventory_upsert_identifier as _upsert_identifier
+from convexity_api_client.models.bulk_upsert_item_template_payload import BulkUpsertItemTemplatePayload
+from convexity_api_client.models.bulk_upsert_item_templates_request import BulkUpsertItemTemplatesRequest
+from convexity_api_client.models.bulk_upsert_item_templates_response import BulkUpsertItemTemplatesResponse
+from convexity_api_client.models.bulk_upsert_item_variant_payload import BulkUpsertItemVariantPayload
+from convexity_api_client.models.bulk_upsert_item_variants_request import BulkUpsertItemVariantsRequest
+from convexity_api_client.models.bulk_upsert_item_variants_response import BulkUpsertItemVariantsResponse
 from convexity_api_client.models.create_item_template_request import CreateItemTemplateRequest
 from convexity_api_client.models.create_item_variant_request import CreateItemVariantRequest
 from convexity_api_client.models.create_item_variant_request_attribute_values import (
@@ -61,6 +69,14 @@ def _optional(value: Any | None) -> Any | Unset:
     return UNSET if value is None else value
 
 
+def _bulk_template_payload(payload: BulkUpsertItemTemplatePayload | dict[str, Any]) -> BulkUpsertItemTemplatePayload:
+    return payload if isinstance(payload, BulkUpsertItemTemplatePayload) else BulkUpsertItemTemplatePayload.from_dict(payload)
+
+
+def _bulk_variant_payload(payload: BulkUpsertItemVariantPayload | dict[str, Any]) -> BulkUpsertItemVariantPayload:
+    return payload if isinstance(payload, BulkUpsertItemVariantPayload) else BulkUpsertItemVariantPayload.from_dict(payload)
+
+
 class Templates:
     """Synchronous sub-client for item templates, variants, and identifiers."""
 
@@ -153,6 +169,17 @@ class Templates:
         result = _update_template.sync(template_id, client=self._client, body=body, project_id=project_id)
         return _expect_response(result, ItemTemplateResponse, "updating item template")
 
+    def bulk_upsert_templates(
+        self,
+        *,
+        project_id: str,
+        templates: list[BulkUpsertItemTemplatePayload | dict[str, Any]],
+    ) -> BulkUpsertItemTemplatesResponse:
+        """Bulk upsert item templates by code."""
+        body = BulkUpsertItemTemplatesRequest(templates=[_bulk_template_payload(template) for template in templates])
+        result = _bulk_upsert_templates.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertItemTemplatesResponse, "bulk upserting item templates")
+
     # -- Variants -------------------------------------------------------------
 
     def create_variant(
@@ -190,6 +217,17 @@ class Templates:
         result = _create_variant.sync(template_id, client=self._client, body=body, project_id=project_id)
         return _expect_response(result, ItemVariantResponse, "creating item variant")
 
+    def bulk_upsert_variants(
+        self,
+        *,
+        project_id: str,
+        variants: list[BulkUpsertItemVariantPayload | dict[str, Any]],
+    ) -> BulkUpsertItemVariantsResponse:
+        """Bulk upsert inventory variants by SKU under their templates."""
+        body = BulkUpsertItemVariantsRequest(variants=[_bulk_variant_payload(variant) for variant in variants])
+        result = _bulk_upsert_variants.sync(client=self._client, body=body, project_id=project_id)
+        return _expect_response(result, BulkUpsertItemVariantsResponse, "bulk upserting item variants")
+
     # -- Identifiers ----------------------------------------------------------
 
     def upsert_identifier(