<?php 
 
namespace Proxies\__CG__\Application\Sonata\MediaBundle\Entity; 
 
 
/** 
 * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE'S PROXY GENERATOR 
 */ 
class Media extends \Application\Sonata\MediaBundle\Entity\Media implements \Doctrine\ORM\Proxy\Proxy 
{ 
    /** 
     * @var \Closure the callback responsible for loading properties in the proxy object. This callback is called with 
     *      three parameters, being respectively the proxy object to be initialized, the method that triggered the 
     *      initialization process and an array of ordered parameters that were passed to that method. 
     * 
     * @see \Doctrine\Common\Proxy\Proxy::__setInitializer 
     */ 
    public $__initializer__; 
 
    /** 
     * @var \Closure the callback responsible of loading properties that need to be copied in the cloned object 
     * 
     * @see \Doctrine\Common\Proxy\Proxy::__setCloner 
     */ 
    public $__cloner__; 
 
    /** 
     * @var boolean flag indicating if this object was already initialized 
     * 
     * @see \Doctrine\Persistence\Proxy::__isInitialized 
     */ 
    public $__isInitialized__ = false; 
 
    /** 
     * @var array<string, null> properties to be lazy loaded, indexed by property name 
     */ 
    public static $lazyPropertiesNames = array ( 
); 
 
    /** 
     * @var array<string, mixed> default values of properties to be lazy loaded, with keys being the property names 
     * 
     * @see \Doctrine\Common\Proxy\Proxy::__getLazyProperties 
     */ 
    public static $lazyPropertiesDefaults = array ( 
); 
 
 
 
    public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null) 
    { 
 
        $this->__initializer__ = $initializer; 
        $this->__cloner__      = $cloner; 
    } 
 
 
 
 
 
 
 
    /** 
     *  
     * @return array 
     */ 
    public function __sleep() 
    { 
        if ($this->__isInitialized__) { 
            return ['__isInitialized__', 'id', 'name', 'description', 'enabled', 'providerName', 'providerStatus', 'providerReference', 'providerMetadata', 'width', 'height', 'length', 'copyright', 'authorName', 'context', 'cdnStatus', 'cdnIsFlushable', 'cdnFlushIdentifier', 'cdnFlushAt', 'updatedAt', 'createdAt', 'binaryContent', 'previousProviderReference', 'contentType', 'size', 'galleryItems', 'category']; 
        } 
 
        return ['__isInitialized__', 'id', 'name', 'description', 'enabled', 'providerName', 'providerStatus', 'providerReference', 'providerMetadata', 'width', 'height', 'length', 'copyright', 'authorName', 'context', 'cdnStatus', 'cdnIsFlushable', 'cdnFlushIdentifier', 'cdnFlushAt', 'updatedAt', 'createdAt', 'binaryContent', 'previousProviderReference', 'contentType', 'size', 'galleryItems', 'category']; 
    } 
 
    /** 
     *  
     */ 
    public function __wakeup() 
    { 
        if ( ! $this->__isInitialized__) { 
            $this->__initializer__ = function (Media $proxy) { 
                $proxy->__setInitializer(null); 
                $proxy->__setCloner(null); 
 
                $existingProperties = get_object_vars($proxy); 
 
                foreach ($proxy::$lazyPropertiesDefaults as $property => $defaultValue) { 
                    if ( ! array_key_exists($property, $existingProperties)) { 
                        $proxy->$property = $defaultValue; 
                    } 
                } 
            }; 
 
        } 
    } 
 
    /** 
     *  
     */ 
    public function __clone() 
    { 
        $this->__cloner__ && $this->__cloner__->__invoke($this, '__clone', []); 
    } 
 
    /** 
     * Forces initialization of the proxy 
     */ 
    public function __load(): void 
    { 
        $this->__initializer__ && $this->__initializer__->__invoke($this, '__load', []); 
    } 
 
    /** 
     * {@inheritDoc} 
     * @internal generated method: use only when explicitly handling proxy specific loading logic 
     */ 
    public function __isInitialized(): bool 
    { 
        return $this->__isInitialized__; 
    } 
 
    /** 
     * {@inheritDoc} 
     * @internal generated method: use only when explicitly handling proxy specific loading logic 
     */ 
    public function __setInitialized($initialized): void 
    { 
        $this->__isInitialized__ = $initialized; 
    } 
 
    /** 
     * {@inheritDoc} 
     * @internal generated method: use only when explicitly handling proxy specific loading logic 
     */ 
    public function __setInitializer(?\Closure $initializer = null): void 
    { 
        $this->__initializer__ = $initializer; 
    } 
 
    /** 
     * {@inheritDoc} 
     * @internal generated method: use only when explicitly handling proxy specific loading logic 
     */ 
    public function __getInitializer(): ?\Closure 
    { 
        return $this->__initializer__; 
    } 
 
    /** 
     * {@inheritDoc} 
     * @internal generated method: use only when explicitly handling proxy specific loading logic 
     */ 
    public function __setCloner(?\Closure $cloner = null): void 
    { 
        $this->__cloner__ = $cloner; 
    } 
 
    /** 
     * {@inheritDoc} 
     * @internal generated method: use only when explicitly handling proxy specific cloning logic 
     */ 
    public function __getCloner(): ?\Closure 
    { 
        return $this->__cloner__; 
    } 
 
    /** 
     * {@inheritDoc} 
     * @internal generated method: use only when explicitly handling proxy specific loading logic 
     * @deprecated no longer in use - generated code now relies on internal components rather than generated public API 
     * @static 
     */ 
    public function __getLazyProperties(): array 
    { 
        return self::$lazyPropertiesDefaults; 
    } 
 
     
    /** 
     * {@inheritDoc} 
     */ 
    public function getId() 
    { 
        if ($this->__isInitialized__ === false) { 
            return (int)  parent::getId(); 
        } 
 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getId', []); 
 
        return parent::getId(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function prePersist(): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'prePersist', []); 
 
        parent::prePersist(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function preUpdate(): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'preUpdate', []); 
 
        parent::preUpdate(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function __toString(): string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, '__toString', []); 
 
        return parent::__toString(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setName(?string $name): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setName', [$name]); 
 
        parent::setName($name); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getName(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getName', []); 
 
        return parent::getName(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setDescription(?string $description): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setDescription', [$description]); 
 
        parent::setDescription($description); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getDescription(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getDescription', []); 
 
        return parent::getDescription(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setEnabled(bool $enabled): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setEnabled', [$enabled]); 
 
        parent::setEnabled($enabled); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getEnabled(): bool 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getEnabled', []); 
 
        return parent::getEnabled(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setProviderName(?string $providerName): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setProviderName', [$providerName]); 
 
        parent::setProviderName($providerName); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getProviderName(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getProviderName', []); 
 
        return parent::getProviderName(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setProviderStatus(?int $providerStatus): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setProviderStatus', [$providerStatus]); 
 
        parent::setProviderStatus($providerStatus); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getProviderStatus(): ?int 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getProviderStatus', []); 
 
        return parent::getProviderStatus(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setProviderReference(?string $providerReference): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setProviderReference', [$providerReference]); 
 
        parent::setProviderReference($providerReference); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getProviderReference(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getProviderReference', []); 
 
        return parent::getProviderReference(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setProviderMetadata(array $providerMetadata = []): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setProviderMetadata', [$providerMetadata]); 
 
        parent::setProviderMetadata($providerMetadata); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getProviderMetadata(): array 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getProviderMetadata', []); 
 
        return parent::getProviderMetadata(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setWidth(?int $width): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setWidth', [$width]); 
 
        parent::setWidth($width); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getWidth(): ?int 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getWidth', []); 
 
        return parent::getWidth(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setHeight(?int $height): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setHeight', [$height]); 
 
        parent::setHeight($height); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getHeight(): ?int 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getHeight', []); 
 
        return parent::getHeight(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setLength(?float $length): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setLength', [$length]); 
 
        parent::setLength($length); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getLength(): ?float 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getLength', []); 
 
        return parent::getLength(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setCopyright(?string $copyright): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCopyright', [$copyright]); 
 
        parent::setCopyright($copyright); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getCopyright(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getCopyright', []); 
 
        return parent::getCopyright(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setAuthorName(?string $authorName): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setAuthorName', [$authorName]); 
 
        parent::setAuthorName($authorName); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getAuthorName(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getAuthorName', []); 
 
        return parent::getAuthorName(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setContext(?string $context): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setContext', [$context]); 
 
        parent::setContext($context); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getContext(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getContext', []); 
 
        return parent::getContext(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setCdnStatus(?int $cdnStatus): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCdnStatus', [$cdnStatus]); 
 
        parent::setCdnStatus($cdnStatus); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getCdnStatus(): ?int 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getCdnStatus', []); 
 
        return parent::getCdnStatus(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setCdnIsFlushable(bool $cdnIsFlushable): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCdnIsFlushable', [$cdnIsFlushable]); 
 
        parent::setCdnIsFlushable($cdnIsFlushable); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getCdnIsFlushable(): bool 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getCdnIsFlushable', []); 
 
        return parent::getCdnIsFlushable(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setCdnFlushIdentifier(?string $cdnFlushIdentifier): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCdnFlushIdentifier', [$cdnFlushIdentifier]); 
 
        parent::setCdnFlushIdentifier($cdnFlushIdentifier); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getCdnFlushIdentifier(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getCdnFlushIdentifier', []); 
 
        return parent::getCdnFlushIdentifier(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setCdnFlushAt(?\DateTimeInterface $cdnFlushAt): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCdnFlushAt', [$cdnFlushAt]); 
 
        parent::setCdnFlushAt($cdnFlushAt); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getCdnFlushAt(): ?\DateTimeInterface 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getCdnFlushAt', []); 
 
        return parent::getCdnFlushAt(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setUpdatedAt(?\DateTimeInterface $updatedAt): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setUpdatedAt', [$updatedAt]); 
 
        parent::setUpdatedAt($updatedAt); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getUpdatedAt(): ?\DateTimeInterface 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getUpdatedAt', []); 
 
        return parent::getUpdatedAt(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setCreatedAt(?\DateTimeInterface $createdAt): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCreatedAt', [$createdAt]); 
 
        parent::setCreatedAt($createdAt); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getCreatedAt(): ?\DateTimeInterface 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getCreatedAt', []); 
 
        return parent::getCreatedAt(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setContentType(?string $contentType): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setContentType', [$contentType]); 
 
        parent::setContentType($contentType); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getContentType(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getContentType', []); 
 
        return parent::getContentType(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setSize(?int $size): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setSize', [$size]); 
 
        parent::setSize($size); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getSize(): ?int 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getSize', []); 
 
        return parent::getSize(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getCategory(): ?object 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getCategory', []); 
 
        return parent::getCategory(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setCategory(?object $category = NULL): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setCategory', [$category]); 
 
        parent::setCategory($category); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setGalleryItems(iterable $galleryItems): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setGalleryItems', [$galleryItems]); 
 
        parent::setGalleryItems($galleryItems); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getGalleryItems(): \Doctrine\Common\Collections\Collection 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getGalleryItems', []); 
 
        return parent::getGalleryItems(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getBox(): \Imagine\Image\Box 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getBox', []); 
 
        return parent::getBox(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getExtension(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getExtension', []); 
 
        return parent::getExtension(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getPreviousProviderReference(): ?string 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getPreviousProviderReference', []); 
 
        return parent::getPreviousProviderReference(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setBinaryContent(mixed $binaryContent): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setBinaryContent', [$binaryContent]); 
 
        parent::setBinaryContent($binaryContent); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function resetBinaryContent(): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'resetBinaryContent', []); 
 
        parent::resetBinaryContent(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getBinaryContent() 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getBinaryContent', []); 
 
        return parent::getBinaryContent(); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function getMetadataValue(string $name, mixed $default = NULL) 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'getMetadataValue', [$name, $default]); 
 
        return parent::getMetadataValue($name, $default); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function setMetadataValue(string $name, mixed $value): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'setMetadataValue', [$name, $value]); 
 
        parent::setMetadataValue($name, $value); 
    } 
 
    /** 
     * {@inheritDoc} 
     */ 
    public function unsetMetadataValue(string $name): void 
    { 
 
        $this->__initializer__ && $this->__initializer__->__invoke($this, 'unsetMetadataValue', [$name]); 
 
        parent::unsetMetadataValue($name); 
    } 
 
}