Struct Serials 

pub struct Serials { /* private fields */ }

Serial number management interface.

Implementations

impl Serials

pub fn create(&self, input: CreateSerialNumber) -> Result<SerialNumber>

Create a serial number.

Example

use stateset_embedded::{Commerce, CreateSerialNumber};
use chrono::Utc;

let commerce = Commerce::new(":memory:")?;

let serial = commerce.serials().create(CreateSerialNumber {
    serial: Some("SN-12345".into()),
    sku: "WIDGET-001".into(),
    lot_number: Some("LOT-2025-001".into()),
    manufactured_at: Some(Utc::now()),
    ..Default::default()
})?;

pub fn create_bulk( &self, input: CreateSerialNumbersBulk, ) -> Result<Vec<SerialNumber>>

Create multiple serial numbers in bulk.

Example

use stateset_embedded::{Commerce, CreateSerialNumbersBulk};

let commerce = Commerce::new(":memory:")?;

// Generate 100 serial numbers with prefix
let serials = commerce.serials().create_bulk(CreateSerialNumbersBulk {
    sku: "WIDGET-001".into(),
    quantity: 100,
    prefix: Some("WGT".into()),
    lot_number: Some("LOT-2025-001".into()),
    ..Default::default()
})?;

println!("Created {} serial numbers", serials.len());

pub fn get(&self, id: Uuid) -> Result<Option<SerialNumber>>

Get a serial by ID.

pub fn get_by_serial(&self, serial: &str) -> Result<Option<SerialNumber>>

Get a serial by its serial number string.

Example

use stateset_embedded::Commerce;

let commerce = Commerce::new(":memory:")?;

if let Some(serial) = commerce.serials().get_by_serial("SN-12345")? {
    println!("Serial {} is currently {}", serial.serial, serial.status);
}

pub fn list(&self, filter: SerialFilter) -> Result<Vec<SerialNumber>>

List serials with optional filtering.

pub fn update( &self, id: Uuid, input: UpdateSerialNumber, ) -> Result<SerialNumber>

Update a serial number.

pub fn delete(&self, id: Uuid) -> Result<()>

Delete a serial (only if never used).

pub fn change_status(&self, input: ChangeSerialStatus) -> Result<SerialNumber>

Change serial status with full tracking.

Example

use stateset_embedded::{Commerce, ChangeSerialStatus, SerialStatus};
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

commerce.serials().change_status(ChangeSerialStatus {
    serial_id: Uuid::new_v4(),
    new_status: SerialStatus::InService,
    reference_type: Some("repair_order".into()),
    reference_id: Some(Uuid::new_v4()),
    notes: Some("Sent for repair".into()),
    ..Default::default()
})?;

pub fn mark_sold( &self, id: Uuid, customer_id: Uuid, order_id: Option<Uuid>, ) -> Result<SerialNumber>

Mark a serial as sold.

pub fn mark_shipped(&self, id: Uuid, shipment_id: Uuid) -> Result<SerialNumber>

Mark a serial as shipped.

pub fn mark_returned(&self, id: Uuid, return_id: Uuid) -> Result<SerialNumber>

Mark a serial as returned.

pub fn activate(&self, id: Uuid) -> Result<SerialNumber>

Activate a serial (e.g., for warranty start).

pub fn quarantine(&self, id: Uuid, reason: &str) -> Result<SerialNumber>

Quarantine a serial.

pub fn release_quarantine(&self, id: Uuid) -> Result<SerialNumber>

Release a serial from quarantine.

pub fn scrap(&self, id: Uuid, reason: &str) -> Result<SerialNumber>

Scrap a serial.

pub fn reserve(&self, input: ReserveSerialNumber) -> Result<SerialReservation>

Reserve a serial for an order or other purpose.

Example

use stateset_embedded::{Commerce, ReserveSerialNumber};
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let reservation = commerce.serials().reserve(ReserveSerialNumber {
    serial_id: Uuid::new_v4(),
    reference_type: "order".into(),
    reference_id: Uuid::new_v4(),
    reserved_by: Some("sales_user".into()),
    expires_in_seconds: Some(3600), // 1 hour
    ..Default::default()
})?;

println!("Reservation created, expires at {:?}", reservation.expires_at);

pub fn release_reservation(&self, reservation_id: Uuid) -> Result<()>

Release a reservation.

pub fn confirm_reservation(&self, reservation_id: Uuid) -> Result<()>

Confirm a reservation (finalize the allocation).

pub fn move_serial(&self, input: MoveSerial) -> Result<SerialNumber>

Move a serial to a new location.

pub fn transfer_ownership( &self, input: TransferSerialOwnership, ) -> Result<SerialNumber>

Transfer ownership of a serial.

Example

use stateset_embedded::{Commerce, TransferSerialOwnership};
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

commerce.serials().transfer_ownership(TransferSerialOwnership {
    serial_id: Uuid::new_v4(),
    new_owner_id: Uuid::new_v4(),
    new_owner_type: "customer".into(),
    notes: Some("Warranty transfer requested".into()),
    ..Default::default()
})?;

pub fn get_history( &self, serial_id: Uuid, filter: SerialHistoryFilter, ) -> Result<Vec<SerialHistory>>

Get serial history.

Example

use stateset_embedded::{Commerce, SerialHistoryFilter};
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let history = commerce.serials().get_history(
    Uuid::new_v4(),
    SerialHistoryFilter {
        limit: Some(50),
        ..Default::default()
    },
)?;

for event in history {
    println!("{}: {} -> {}", event.event_type, event.from_status, event.to_status);
}

pub fn lookup(&self, serial: &str) -> Result<Option<SerialLookupResult>>

Full serial lookup with related data.

Returns the serial along with lot info, warranty status, and recent history.

Example

use stateset_embedded::Commerce;

let commerce = Commerce::new(":memory:")?;

if let Some(result) = commerce.serials().lookup("SN-12345")? {
    println!("Serial: {}", result.serial.serial);
    println!("SKU: {}", result.serial.sku);
    println!("Status: {}", result.serial.status);
    if let Some(warranty) = result.warranty_status {
        println!("Warranty active: {}", warranty.is_active);
    }
}

pub fn validate(&self, serial: &str) -> Result<SerialValidation>

Validate a serial number.

Returns validation info without the full serial data.

pub fn get_available(&self, sku: &str, limit: u32) -> Result<Vec<SerialNumber>>

Get available serials for a SKU.

pub fn get_for_lot(&self, lot_id: Uuid) -> Result<Vec<SerialNumber>>

Get serials for a lot.

pub fn get_for_customer(&self, customer_id: Uuid) -> Result<Vec<SerialNumber>>

Get serials owned by a customer.

pub fn count(&self, filter: SerialFilter) -> Result<u64>

Count serials matching filter.

pub fn create_batch( &self, inputs: Vec<CreateSerialNumber>, ) -> Result<BatchResult<SerialNumber>>

Create multiple serials with partial success handling.

pub fn get_batch(&self, ids: Vec<Uuid>) -> Result<Vec<SerialNumber>>

Get multiple serials by ID.

pub fn get_batch_by_serial( &self, serials: Vec<String>, ) -> Result<Vec<SerialNumber>>

Get multiple serials by serial string.

pub fn is_available(&self, serial: &str) -> Result<bool>

Check if a serial is available for sale.

pub fn can_ship(&self, serial: &str) -> Result<bool>

Check if a serial can be shipped.

Trait Implementations

impl Debug for Serials

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.