OperationStatesModel.php

<?php
 
declare(strict_types=1);
namespace Commercetools\Import\Models\Importsummaries;
 
use Commercetools\Base\DateTimeImmutableCollection;
use Commercetools\Base\JsonObject;
use Commercetools\Base\JsonObjectModel;
use Commercetools\Base\MapperFactory;
use stdClass;
 
final class OperationStatesModel extends JsonObjectModel implements OperationStates
{
    protected $processing;
 
    protected $validationFailed;
 
    protected $unresolved;
 
    protected $waitForMasterVariant;
 
    protected $imported;
 
    protected $rejected;
 
    protected $canceled;
 
    protected $partiallyImported;
 
 
    public function __construct(
        ?int $processing = null,
        ?int $validationFailed = null,
        ?int $unresolved = null,
        ?int $waitForMasterVariant = null,
        ?int $imported = null,
        ?int $rejected = null,
        ?int $canceled = null,
        ?int $partiallyImported = null
    ) {
        $this->processing = $processing;
        $this->validationFailed = $validationFailed;
        $this->unresolved = $unresolved;
        $this->waitForMasterVariant = $waitForMasterVariant;
        $this->imported = $imported;
        $this->rejected = $rejected;
        $this->canceled = $canceled;
        $this->partiallyImported = $partiallyImported;
    }
 
    public function getProcessing()
    {
        if (is_null($this->processing)) {
            $data = $this->raw(self::FIELD_PROCESSING);
            if (is_null($data)) {
                return null;
            }
            $this->processing = (int) $data;
        }
 
        return $this->processing;
    }
 
    public function getValidationFailed()
    {
        if (is_null($this->validationFailed)) {
            $data = $this->raw(self::FIELD_VALIDATION_FAILED);
            if (is_null($data)) {
                return null;
            }
            $this->validationFailed = (int) $data;
        }
 
        return $this->validationFailed;
    }
 
    public function getUnresolved()
    {
        if (is_null($this->unresolved)) {
            $data = $this->raw(self::FIELD_UNRESOLVED);
            if (is_null($data)) {
                return null;
            }
            $this->unresolved = (int) $data;
        }
 
        return $this->unresolved;
    }
 
    public function getWaitForMasterVariant()
    {
        if (is_null($this->waitForMasterVariant)) {
            $data = $this->raw(self::FIELD_WAIT_FOR_MASTER_VARIANT);
            if (is_null($data)) {
                return null;
            }
            $this->waitForMasterVariant = (int) $data;
        }
 
        return $this->waitForMasterVariant;
    }
 
    public function getImported()
    {
        if (is_null($this->imported)) {
            $data = $this->raw(self::FIELD_IMPORTED);
            if (is_null($data)) {
                return null;
            }
            $this->imported = (int) $data;
        }
 
        return $this->imported;
    }
 
    public function getRejected()
    {
        if (is_null($this->rejected)) {
            $data = $this->raw(self::FIELD_REJECTED);
            if (is_null($data)) {
                return null;
            }
            $this->rejected = (int) $data;
        }
 
        return $this->rejected;
    }
 
    public function getCanceled()
    {
        if (is_null($this->canceled)) {
            $data = $this->raw(self::FIELD_CANCELED);
            if (is_null($data)) {
                return null;
            }
            $this->canceled = (int) $data;
        }
 
        return $this->canceled;
    }
 
    public function getPartiallyImported()
    {
        if (is_null($this->partiallyImported)) {
            $data = $this->raw(self::FIELD_PARTIALLY_IMPORTED);
            if (is_null($data)) {
                return null;
            }
            $this->partiallyImported = (int) $data;
        }
 
        return $this->partiallyImported;
    }
 
 
    public function setProcessing(?int $processing): void
    {
        $this->processing = $processing;
    }
 
    public function setValidationFailed(?int $validationFailed): void
    {
        $this->validationFailed = $validationFailed;
    }
 
    public function setUnresolved(?int $unresolved): void
    {
        $this->unresolved = $unresolved;
    }
 
    public function setWaitForMasterVariant(?int $waitForMasterVariant): void
    {
        $this->waitForMasterVariant = $waitForMasterVariant;
    }
 
    public function setImported(?int $imported): void
    {
        $this->imported = $imported;
    }
 
    public function setRejected(?int $rejected): void
    {
        $this->rejected = $rejected;
    }
 
    public function setCanceled(?int $canceled): void
    {
        $this->canceled = $canceled;
    }
 
    public function setPartiallyImported(?int $partiallyImported): void
    {
        $this->partiallyImported = $partiallyImported;
    }
}