Code Duplication - nfephp-org/sped-efd - Measure and Improve Code Quality continuously with Scrutinizer


use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class A110 extends Element implements ElementInterface
{
    const REG = 'A110';
    const LEVEL = 3;
    const PARENT = 'A100';

    protected $parameters = [
        'COD_INF' => [
            'type' => 'string',
            'regex' => '^.{0,6}$',
            'required' => false,
            'info' => 'Código da informação complementar do documento fiscal (Campo 02 do Registro 0450)',
            'format' => ''
        ],
        'TXT_COMPL' => [
            'type' => 'string',
            'regex' => '^(.*)$',
            'required' => false,
            'info' => 'Informação Complementar do Documento Fiscal',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class A111 extends Element implements ElementInterface
{
    const REG = 'A111';
    const LEVEL = 4;
    const PARENT = 'A110';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,15}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 
            1 - Justiça Federal; 
            3 – Secretaria da Receita Federal do Brasil 
            9 - Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C010 extends Element implements ElementInterface
{
    const REG = 'C010';
    const LEVEL = 2;
    const PARENT = 'C001';

    protected $parameters = [
        'CNPJ' => [
            'type' => 'string',
            'regex' => '^[0-9]{14}$',
            'required' => false,
            'info' => 'Número de inscrição do estabelecimento no CNPJ.',
            'format' => ''
        ],
        'IND_ESCRI' => [
            'type' => 'string',
            'regex' => '^.{1}$',
            'required' => false,
            'info' => 'Indicador da apuração das contribuições e créditos, na escrituração das 
            operações por NF-e e ECF, no período: 1 – Apuração com base nos registros de consolidação 
            das operações por NF-e (C180 e C190) e por ECF (C490);',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C110 extends Element implements ElementInterface
{
    const REG = 'C110';
    const LEVEL = 4;
    const PARENT = 'C100';

    protected $parameters = [
        'COD_INF' => [
            'type' => 'string',
            'regex' => '^.{0,6}$',
            'required' => false,
            'info' => 'Código da informação complementar do documento fiscal (campo 02 do Registro 0450)',
            'format' => ''
        ],
        'TXT_COMPL' => [
            'type' => 'string',
            'regex' => '^(.*)$',
            'required' => false,
            'info' => 'Descrição complementar do código de referência.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C111 extends Element implements ElementInterface
{
    const REG = 'C111';
    const LEVEL = 4;
    const PARENT = 'C110';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 
            1 - Justiça Federal; 3 – Secretaria da Receita Federal do Brasil 9 – Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C188 extends Element implements ElementInterface
{
    const REG = 'C188';
    const LEVEL = 4;
    const PARENT = 'C180';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 
            1 - Justiça Federal; 3 - Secretaria da Receita Federal do Brasil; 9 – Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C198 extends Element implements ElementInterface
{
    const REG = 'C198';
    const LEVEL = 4;
    const PARENT = 'C190';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|2|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo:',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C489 extends Element implements ElementInterface
{
    const REG = 'C489';
    const LEVEL = 4;
    const PARENT = 'C400';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 1 - Justiça Federal; 
            3 – Secretaria da Receita Federal do Brasil 9 - Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C499 extends Element implements ElementInterface
{
    const REG = 'C499';
    const LEVEL = 4;
    const PARENT = 'C400';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 
            1 - Justiça Federal; 3 – Secretaria da Receita Federal do Brasil 9 - Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C509 extends Element implements ElementInterface
{
    const REG = 'C509';
    const LEVEL = 4;
    const PARENT = 'C500';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 
            1 - Justiça Federal; 3 – Secretaria da Receita Federal do Brasil 9 – Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C609 extends Element implements ElementInterface
{
    const REG = 'C609';
    const LEVEL = 4;
    const PARENT = 'C600';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 
            1 - Justiça Federal; 3 – Secretaria da Receita Federal do Brasil 9 – Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C830 extends Element implements ElementInterface
{
    const REG = 'C830';
    const LEVEL = 4;
    const PARENT = 'C800';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo: 
            1 - Justiça Federal; 3 – Secretaria da Receita Federal do Brasil 9 - Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C890 extends Element implements ElementInterface
{
    const REG = 'C890';
    const LEVEL = 4;
    const PARENT = 'C800';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo:
             1 - Justiça Federal; 3 – Secretaria da Receita Federal do Brasil 9 - Outros.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\Element;
use NFePHP\EFD\Common\ElementInterface;

class D111 extends Element implements ElementInterface
{
    const REG = 'D111';
    const LEVEL = 4;
    const PARENT = 'D100';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo ' .
                ' 1 - Justiça Federal ' .
                ' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\Element;
use NFePHP\EFD\Common\ElementInterface;

class D209 extends Element implements ElementInterface
{
    const REG = 'D209';
    const LEVEL = 4;
    const PARENT = 'D200';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo ' .
                ' 1 - Justiça Federal ' .
                ' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\Element;
use NFePHP\EFD\Common\ElementInterface;

class D309 extends Element implements ElementInterface
{
    const REG = 'D309';
    const LEVEL = 4;
    const PARENT = 'D300';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo ' .
                ' 1 - Justiça Federal ' .
                ' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\Element;
use NFePHP\EFD\Common\ElementInterface;

class D359 extends Element implements ElementInterface
{
    const REG = 'D359';
    const LEVEL = 4;
    const PARENT = 'D350';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo ' .
                ' 1 - Justiça Federal ' .
                ' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\Element;
use NFePHP\EFD\Common\ElementInterface;

class D509 extends Element implements ElementInterface
{
    const REG = 'D509';
    const LEVEL = 4;
    const PARENT = 'D500';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo ' .
                ' 1 - Justiça Federal ' .
                ' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\Element;
use NFePHP\EFD\Common\ElementInterface;

class D609 extends Element implements ElementInterface
{
    const REG = 'D609';
    const LEVEL = 4;
    const PARENT = 'D600';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class P199 extends Element implements ElementInterface
{
    const REG = 'P199';
    const LEVEL = 4;
    const PARENT = 'P100';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo ' .
                ' 1 - Justiça Federal ' .
                ' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class Z0400 extends Element implements ElementInterface
{
    const REG = '0400';
    const LEVEL = 3;
    const PARENT = '0100';

    protected $parameters = [
        'COD_NAT' => [
            'type' => 'string',
            'regex' => '^.{0,10}$',
            'required' => false,
            'info' => 'Código da natureza da operação/prestação',
            'format' => ''
        ],
        'DESCR_NAT' => [
            'type' => 'string',
            'regex' => '^(.*)$',
            'required' => false,
            'info' => 'Descrição da natureza da operação/prestação',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class Z0450 extends Element implements ElementInterface
{
    const REG = '0450';
    const LEVEL = 3;
    const PARENT = '0400';

    protected $parameters = [
        'COD_INF' => [
            'type' => 'string',
            'regex' => '^.{0,6}$',
            'required' => false,
            'info' => 'Código da informação complementar do documento fiscal.',
            'format' => ''
        ],
        'TXT' => [
            'type' => 'string',
            'regex' => '^(.*)$',
            'required' => false,
            'info' => 'Texto livre da informação complementar existente no documento fiscal, 
            inclusive espécie de normas legais, poder normativo, número, capitulação, data e 
            demais referências pertinentes com indicação referentes ao tributo.',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class Z1809 extends Element implements ElementInterface
{
    const REG = '1809';
    const LEVEL = 3;
    const PARENT = '1800';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^.{0,20}$',
            'required' => false,
            'info' => 'Identificação do processo ou ato concessório ',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(1|3|9)$',
            'required' => false,
            'info' => 'Indicador da origem do processo ' .
                ' 1 - Justiça Federal ' .
                ' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * DESTINATÁRIO DO DOCUMENTO FISCAL (CÓDIGO 55).
 * @package NFePHP\EFD\Elements\ICMSIPI
 */
class C105 extends Element implements ElementInterface
{
    const REG = 'C105';
    const LEVEL = 3;
    const PARENT = 'C100';

    protected $parameters = [
        'OPER' => [
            'type' => 'string',
            'regex' => '^[0-1]{1}$',
            'required' => true,
            'info' => 'Indicador do tipo de operação',
            'format' => ''
        ],
        'UF' => [
            'type' => 'string',
            'regex' => '^[a-zA-Z]{2}$',
            'required' => true,
            'info' => 'Sigla da UF de destino do ICMS_ST',
            'format' => ''
        ]
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * REGISTRO C110: INFORMAÇÃO COMPLEMENTAR DA NOTA FISCAL (CÓDIGO 01, 1B, 04 e 55).
 * @package NFePHP\EFD\Elements\ICMSIPI
 */
class C110 extends Element implements ElementInterface
{
    const REG = 'C110';
    const LEVEL = 3;
    const PARENT = 'C100';

    protected $parameters = [
        'COD_INF' => [
            'type' => 'string',
            'regex' => '^[A-z0-9]{1,6}$',
            'required' => true,
            'info' => 'Código da informação complementar do documento fiscal',
            'format' => ''
        ],
        'TXT_COMPL' => [
            'type' => 'string',
            'regex' => '^(.*)$',
            'required' => true,
            'info' => 'Descrição complementar do código de referência.',
            'format' => ''
        ]
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * REGISTRO C111: PROCESSO REFERENCIADO
 * @package NFePHP\EFD\Elements\ICMSIPI
 */
class C111 extends Element implements ElementInterface
{
    const REG = 'C111';
    const LEVEL = 4;
    const PARENT = 'C110';

    protected $parameters = [
        'NUM_PROC' => [
            'type' => 'string',
            'regex' => '^[A-z0-9]{1,15}$',
            'required' => true,
            'info' => 'Identificação do processo ou ato concessório',
            'format' => ''
        ],
        'IND_PROC' => [
            'type' => 'string',
            'regex' => '^(0|1|2|3|9)$',
            'required' => true,
            'info' => 'Indicador da origem do processo',
            'format' => ''
        ]
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * Combustíveis (LMC), Ajuste SINIEF 01/92.
 * @package NFePHP\EFD\Elements\ICMSIPI
 */
class C171 extends Element implements ElementInterface
{
    const REG = 'C171';
    const LEVEL = 4;
    const PARENT = 'C171';

    protected $parameters = [
        'NUM_TANQUE' => [
            'type' => 'string',
            'regex' => '^.{1,3}$',
            'required' => true,
            'info' => 'Tanque onde foi armazenado o combustível',
            'format' => ''
        ],
        'QTDE' => [
            'type' => 'numeric',
            'regex' => '\d+(\.\d*)?|\.\d+$',
            'required' => true,
            'info' => 'Quantidade ou volume armazenado',
            'format' => '15v3'
        ],
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * objetivo de agregar informações adicionais ao item, de acordo com tabela a ser publicada pela UF.
 * @package NFePHP\EFD\Elements\ICMSIPI
 */
class C177 extends Element implements ElementInterface
{
    const REG = 'C177';
    const LEVEL = 4;
    const PARENT = 'C170';

    protected $parameters = [
        'COD_SELO_IPI' => [
            'type' => 'string',
            'regex' => '^.{6}$',
            'required' => false,
            'info' => 'Código do selo de controle do IPI, conforme Tabela 4.5.2',
            'format' => ''
        ],
        'QT_SELO_IPI' => [
            'type' => 'numeric',
            'regex' => '^(\d{0,12})$',
            'required' => false,
            'info' => 'Quantidade de selo de controle do IPI aplicada',
            'format' => ''
        ],
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * a IV.
 * @package NFePHP\EFD\Elements\ICMSIPI
 */
class C195 extends Element implements ElementInterface
{
    const REG = 'C195';
    const LEVEL = 3;
    const PARENT = 'C100';

    protected $parameters = [
        'COD_OBS' => [
            'type' => 'string',
            'regex' => '^.{1,6}$',
            'required' => true,
            'info' => 'Código da observação do lançamento fiscal',
            'format' => ''
        ],
        'TXT_COMPL' => [
            'type' => 'string',
            'regex' => '^(.*)$',
            'required' => false,
            'info' => 'Descrição complementar do código de observação.',
            'format' => ''
        ],
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class C410 extends Element implements ElementInterface
{
    const REG = 'C410';
    const LEVEL = 4;
    const PARENT = 'C400';

    protected $parameters = [
        'VL_PIS' => [
            'type' => 'numeric',
            'regex' => '^\d+(\.\d*)?|\.\d+$',
            'required' => false,
            'info' => 'Valor total do PIS',
            'format' => '15v2'
        ],
        'VL_COFINS' => [
            'type' => 'numeric',
            'regex' => '^\d+(\.\d*)?|\.\d+$',
            'required' => false,
            'info' => 'Valor total da COFINS',
            'format' => '15v2'
        ],
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class E100 extends Element implements ElementInterface
{
    const REG = 'E100';
    const LEVEL = 2;
    const PARENT = 'E001';

    protected $parameters = [
        'DT_INI'     => [
            'type'     => 'string',
            'regex'    => '^(0[1-9]|[1-2][0-9]|31(?!(?:0[2469]|11))|30(?!02))(0[1-9]|1[0-2])([12]\d{3})$',
            'required' => true,
            'info'     => 'Data inicial das informações contidas no arquivo.',
            'format'   => ''
        ],
        'DT_FIN'     => [
            'type'     => 'string',
            'regex'    => '^(0[1-9]|[1-2][0-9]|31(?!(?:0[2469]|11))|30(?!02))(0[1-9]|1[0-2])([12]\d{3})$',
            'required' => true,
            'info'     => 'Data final das informações contidas no arquivo.',
            'format'   => ''
        ]
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class G140 extends Element implements ElementInterface
{
    const REG = 'G140';
    const LEVEL = 5;
    const PARENT = 'G100';

    protected $parameters = [
        'NUM_ITEM' => [
            'type' => 'numeric',
            'regex' => '^(\d{1,3})$',
            'required' => true,
            'info' => 'Número sequencial do item no documento fiscal ',
            'format' => ''
        ],
        'COD_ITEM' => [
            'type' => 'string',
            'regex' => '^.{1,60}$',
            'required' => true,
            'info' => 'Código correspondente do bem no documento fiscal (campo 02 do registro 0200) ',
            'format' => ''
        ],

    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * Os períodos informados neste registro deverão abranger todo o período da escrituração,
 * conforme informado no Registro 0000.
 */
class K100 extends Element implements ElementInterface
{
    const REG = 'K100';
    const LEVEL = 2;
    const PARENT = 'K001';

    protected $parameters = [
        'DT_INI' => [
            'type'     => 'string',
            'regex'    => '^(0[1-9]|[1-2][0-9]|31(?!(?:0[2469]|11))|30(?!02))(0[1-9]|1[0-2])([12]\d{3})$',
            'required' => true,
            'info'     => 'Data inicial a que a apuração se refere',
            'format'   => ''
        ],
        'DT_FIN' => [
            'type'     => 'string',
            'regex'    => '^(0[1-9]|[1-2][0-9]|31(?!(?:0[2469]|11))|30(?!02))(0[1-9]|1[0-2])([12]\d{3})$',
            'required' => true,
            'info'     => 'Data final a que a apuração se refere',
            'format'   => ''
        ]
    ];
    
    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * de controle de estoque constante no campo 06 do registro 0200, UNID_INV.
 * Validação do Registro: A chave deste registro é o campo COD_ITEM_DES.
 */
class K215 extends Element implements ElementInterface
{
    const REG = 'K215';
    const LEVEL = 4;
    const PARENT = 'K210';

    protected $parameters = [
        'COD_ITEM_DES' => [
            'type'     => 'string',
            'regex'    => '^.{1,60}$',
            'required' => true,
            'info'     => 'Código do item de destino (campo 02 do Registro 0200)',
            'format'   => ''
        ],
        'QTD_DES' => [
            'type'     => 'numeric',
            'regex'    => '^\d+(\.\d*)?|\.\d+$',
            'required' => true,
            'info'     => 'Quantidade de destino – entrada em estoque',
            'format'   => '15v6'
        ],
    ];
    
    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * NOTA: usada a letra Z no nome da Classe pois os nomes não podem ser exclusivamente
 * numeréricos e também para não confundir os com elementos do bloco B
 */
class Z0400 extends Element implements ElementInterface
{
    const REG = '0400';
    const LEVEL = 0;
    const PARENT = '';
    
    protected $parameters = [
        'COD_NAT' => [
            'type'     => 'string',
            'regex'    => '^.{1,10}$',
            'required' => true,
            'info'     => 'Código da natureza da operação/prestação',
            'format'   => ''
        ],
        'DESCR_NAT' => [
            'type'     => 'string',
            'regex'    => '^.{1,255}$',
            'required' => true,
            'info'     => 'Descrição da natureza da operação/prestação',
            'format'   => ''
        ]
    ];
    
    /**
     * Constructor
     * @param stdClass $std
     */
    public function __construct(stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * NOTA: usada a letra Z no nome da Classe pois os nomes não podem ser exclusivamente
 * numeréricos e também para não confundir os com elementos do bloco B
 */
class Z0450 extends Element implements ElementInterface
{
    const REG = '0450';
    const LEVEL = 0;
    const PARENT = '';
    
    protected $parameters = [
        'COD_INF' => [
            'type'     => 'string',
            'regex'    => '^.{1,6}$',
            'required' => true,
            'info'     => 'Código da informação complementar do documento fiscal.',
            'format'   => ''
        ],
        'TXT' => [
            'type'     => 'string',
            'regex'    => '^.{1,1000}$',
            'required' => true,
            'info'     => 'Texto livre da informação complementar existente no documento fiscal',
            'format'   => ''
        ]
    ];
    
    /**
     * Constructor
     * @param stdClass $std
     */
    public function __construct(stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



 * NOTA: usada a letra Z no nome da Classe pois os nomes não podem ser exclusivamente
 * numeréricos e também para não confundir os com elementos do bloco B
 */
class Z0460 extends Element implements ElementInterface
{
    const REG = '0460';
    const LEVEL = 3;
    const PARENT = '';
    
    protected $parameters = [
        'COD_OBS' => [
            'type'     => 'string',
            'regex'    => '^.{1,6}$',
            'required' => true,
            'info'     => 'Código da Observação do lançamento fiscal',
            'format'   => ''
        ],
        'TXT' => [
            'type'     => 'string',
            'regex'    => '^.{1,255}$',
            'required' => true,
            'info'     => 'Descrição da observação vinculada ao lançamento fiscal',
            'format'   => ''
        ],
    ];
    
    /**
     * Constructor
     * @param stdClass $std
     */
    public function __construct(stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class Z1360 extends Element implements ElementInterface
{
    const REG = '1360';
    const LEVEL = 3;
    const PARENT = '1350';

    protected $parameters = [
        'NUM_LACRE' => [
            'type'     => 'string',
            'regex'    => '^.{1,20}$',
            'required' => true,
            'info'     => 'Número do Lacre associado na Bomba',
            'format'   => ''
        ],
        'DT_APLICACAO' => [
            'type'     => 'integer',
            'regex'    => '^(0[1-9]|[1-2][0-9]|31(?!(?:0[2469]|11))|30(?!02))(0[1-9]|1[0-2])([12]\d{3})$',
            'required' => true,
            'info'     => 'Data de aplicação do Lacre',
            'format'   => ''
        ]
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class Z1710 extends Element implements ElementInterface
{
    const REG = '1710';
    const LEVEL = 3;
    const PARENT = '1700';

    protected $parameters = [
        'NUM_DOC_INI' => [
            'type'     => 'integer',
            'regex'    => '^\d{1,12}$',
            'required' => true,
            'info'     => 'Número do dispositivo autorizado (inutilizado) inicial',
            'format'   => ''
        ],
        'NUM_DOC_FIN' => [
            'type'     => 'integer',
            'regex'    => '^\d{1,12}$',
            'required' => true,
            'info'     => 'Número do dispositivo autorizado (inutilizado) final',
            'format'   => ''
        ]
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class Z1910 extends Element implements ElementInterface
{
    const REG = '1910';
    const LEVEL = 3;
    const PARENT = '1900';

    protected $parameters = [
        'DT_INI' => [
            'type'     => 'integer',
            'regex'    => '^(0[1-9]|[1-2][0-9]|31(?!(?:0[2469]|11))|30(?!02))(0[1-9]|1[0-2])([12]\d{3})$',
            'required' => true,
            'info'     => 'Data inicial da sub-apuração',
            'format'   => ''
        ],
        'DT_FIN' => [
            'type'     => 'integer',
            'regex'    => '^(0[1-9]|[1-2][0-9]|31(?!(?:0[2469]|11))|30(?!02))(0[1-9]|1[0-2])([12]\d{3})$',
            'required' => true,
            'info'     => 'Data final da sub-apuração',
            'format'   => ''
        ]
    ];

    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class K291 extends Element implements ElementInterface
{
    const REG = 'K291';
    const LEVEL = 4;
    const PARENT = 'K290';

    protected $parameters = [
        'COD_ITEM' => [
            'type'     => 'string',
            'regex'    => '^.{1,60}$',
            'required' => true,
            'info'     => 'Código do item produzido (campo 02 do Registro 0200)',
            'format'   => ''
        ],
        'QTD' => [
            'type'     => 'numeric',
            'regex'    => '^\d+(\.\d*)?|\.\d+$',
            'required' => true,
            'info'     => 'Quantidade de produção acabada',
            'format'   => '15v3'
        ]
    ];
    
    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class K292 extends Element implements ElementInterface
{
    const REG = 'K292';
    const LEVEL = 4;
    const PARENT = 'K290';

    protected $parameters = [
        'COD_ITEM' => [
            'type'     => 'string',
            'regex'    => '^.{1,60}$',
            'required' => true,
            'info'     => 'Código do insumo/componente consumido (campo 02 do Registro 0200)',
            'format'   => ''
        ],
        'QTD' => [
            'type'     => 'numeric',
            'regex'    => '^\d+(\.\d*)?|\.\d+$',
            'required' => true,
            'info'     => 'Quantidade consumida',
            'format'   => '15v3'
        ]
    ];
    
    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class K301 extends Element implements ElementInterface
{
    const REG = 'K301';
    const LEVEL = 4;
    const PARENT = 'K300';

    protected $parameters = [
        'COD_ITEM' => [
            'type'     => 'string',
            'regex'    => '^.{1,60}$',
            'required' => true,
            'info'     => 'Código do item produzido (campo 02 do Registro 0200)',
            'format'   => ''
        ],
        'QTD' => [
            'type'     => 'numeric',
            'regex'    => '^\d+(\.\d*)?|\.\d+$',
            'required' => true,
            'info'     => 'Quantidade produzida',
            'format'   => '15v3'
        ]
    ];
    
    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}



use NFePHP\EFD\Common\ElementInterface;
use \stdClass;

class K302 extends Element implements ElementInterface
{
    const REG = 'K302';
    const LEVEL = 4;
    const PARENT = 'K300';

    protected $parameters = [
        'COD_ITEM' => [
            'type'     => 'string',
            'regex'    => '^.{1,60}$',
            'required' => true,
            'info'     => 'Código do insumo (campo 02 do Registro 0200)',
            'format'   => ''
        ],
        'QTD' => [
            'type'     => 'numeric',
            'regex'    => '^\d+(\.\d*)?|\.\d+$',
            'required' => true,
            'info'     => 'Quantidade consumida',
            'format'   => '15v3'
        ]
    ];
    
    /**
     * Constructor
     * @param \stdClass $std
     */
    public function __construct(\stdClass $std)
    {
        parent::__construct(self::REG);
        $this->std = $this->standarize($std);
    }
}


		@@ 9-42 (lines=34) @@
6		use NFePHP\EFD\Common\ElementInterface;
7		use \stdClass;
8
9		class A110 extends Element implements ElementInterface
10		{
11		const REG = 'A110';
12		const LEVEL = 3;
13		const PARENT = 'A100';
14
15		protected $parameters = [
16		'COD_INF' => [
17		'type' => 'string',
18		'regex' => '^.{0,6}$',
19		'required' => false,
20		'info' => 'Código da informação complementar do documento fiscal (Campo 02 do Registro 0450)',
21		'format' => ''
22		],
23		'TXT_COMPL' => [
24		'type' => 'string',
25		'regex' => '^(.*)$',
26		'required' => false,
27		'info' => 'Informação Complementar do Documento Fiscal',
28		'format' => ''
29		],
30
31		];
32
33		/**
34		* Constructor
35		* @param \stdClass $std
36		*/
37		public function __construct(\stdClass $std)
38		{
39		parent::__construct(self::REG);
40		$this->std = $this->standarize($std);
41		}
42		}
43

		@@ 9-45 (lines=37) @@
6		use NFePHP\EFD\Common\ElementInterface;
7		use \stdClass;
8
9		class A111 extends Element implements ElementInterface
10		{
11		const REG = 'A111';
12		const LEVEL = 4;
13		const PARENT = 'A110';
14
15		protected $parameters = [
16		'NUM_PROC' => [
17		'type' => 'string',
18		'regex' => '^.{0,15}$',
19		'required' => false,
20		'info' => 'Identificação do processo ou ato concessório',
21		'format' => ''
22		],
23		'IND_PROC' => [
24		'type' => 'string',
25		'regex' => '^(1\|3\|9)$',
26		'required' => false,
27		'info' => 'Indicador da origem do processo:
28		1 - Justiça Federal;
29		3 – Secretaria da Receita Federal do Brasil
30		9 - Outros.',
31		'format' => ''
32		],
33
34		];
35
36		/**
37		* Constructor
38		* @param \stdClass $std
39		*/
40		public function __construct(\stdClass $std)
41		{
42		parent::__construct(self::REG);
43		$this->std = $this->standarize($std);
44		}
45		}
46

		@@ 9-44 (lines=36) @@
6		use NFePHP\EFD\Common\ElementInterface;
7		use \stdClass;
8
9		class C010 extends Element implements ElementInterface
10		{
11		const REG = 'C010';
12		const LEVEL = 2;
13		const PARENT = 'C001';
14
15		protected $parameters = [
16		'CNPJ' => [
17		'type' => 'string',
18		'regex' => '^[0-9]{14}$',
19		'required' => false,
20		'info' => 'Número de inscrição do estabelecimento no CNPJ.',
21		'format' => ''
22		],
23		'IND_ESCRI' => [
24		'type' => 'string',
25		'regex' => '^.{1}$',
26		'required' => false,
27		'info' => 'Indicador da apuração das contribuições e créditos, na escrituração das
28		operações por NF-e e ECF, no período: 1 – Apuração com base nos registros de consolidação
29		das operações por NF-e (C180 e C190) e por ECF (C490);',
30		'format' => ''
31		],
32
33		];
34
35		/**
36		* Constructor
37		* @param \stdClass $std
38		*/
39		public function __construct(\stdClass $std)
40		{
41		parent::__construct(self::REG);
42		$this->std = $this->standarize($std);
43		}
44		}
45

		@@ 9-43 (lines=35) @@
6		use NFePHP\EFD\Common\ElementInterface;
7		use \stdClass;
8
9		class C111 extends Element implements ElementInterface
10		{
11		const REG = 'C111';
12		const LEVEL = 4;
13		const PARENT = 'C110';
14
15		protected $parameters = [
16		'NUM_PROC' => [
17		'type' => 'string',
18		'regex' => '^.{0,20}$',
19		'required' => false,
20		'info' => 'Identificação do processo ou ato concessório',
21		'format' => ''
22		],
23		'IND_PROC' => [
24		'type' => 'string',
25		'regex' => '^(1\|3\|9)$',
26		'required' => false,
27		'info' => 'Indicador da origem do processo:
28		1 - Justiça Federal; 3 – Secretaria da Receita Federal do Brasil 9 – Outros.',
29		'format' => ''
30		],
31
32		];
33
34		/**
35		* Constructor
36		* @param \stdClass $std
37		*/
38		public function __construct(\stdClass $std)
39		{
40		parent::__construct(self::REG);
41		$this->std = $this->standarize($std);
42		}
43		}
44

		@@ 8-43 (lines=36) @@
5		use NFePHP\EFD\Common\Element;
6		use NFePHP\EFD\Common\ElementInterface;
7
8		class D111 extends Element implements ElementInterface
9		{
10		const REG = 'D111';
11		const LEVEL = 4;
12		const PARENT = 'D100';
13
14		protected $parameters = [
15		'NUM_PROC' => [
16		'type' => 'string',
17		'regex' => '^.{0,20}$',
18		'required' => false,
19		'info' => 'Identificação do processo ou ato concessório ',
20		'format' => ''
21		],
22		'IND_PROC' => [
23		'type' => 'string',
24		'regex' => '^(1\|3\|9)$',
25		'required' => false,
26		'info' => 'Indicador da origem do processo ' .
27		' 1 - Justiça Federal ' .
28		' 3 – Secretaria da Receita Federal do Brasil 9 – Outros. ',
29		'format' => ''
30		],
31
32		];
33
34		/**
35		* Constructor
36		* @param \stdClass $std
37		*/
38		public function __construct(\stdClass $std)
39		{
40		parent::__construct(self::REG);
41		$this->std = $this->standarize($std);
42		}
43		}
44

		@@ 8-41 (lines=34) @@
5		use NFePHP\EFD\Common\Element;
6		use NFePHP\EFD\Common\ElementInterface;
7
8		class D609 extends Element implements ElementInterface
9		{
10		const REG = 'D609';
11		const LEVEL = 4;
12		const PARENT = 'D600';
13
14		protected $parameters = [
15		'NUM_PROC' => [
16		'type' => 'string',
17		'regex' => '^.{0,20}$',
18		'required' => false,
19		'info' => 'Identificação do processo ou ato concessório ',
20		'format' => ''
21		],
22		'IND_PROC' => [
23		'type' => 'string',
24		'regex' => '^(1\|3\|9)$',
25		'required' => false,
26		'info' => 'Indicador da origem do processo',
27		'format' => ''
28		],
29
30		];
31
32		/**
33		* Constructor
34		* @param \stdClass $std
35		*/
36		public function __construct(\stdClass $std)
37		{
38		parent::__construct(self::REG);
39		$this->std = $this->standarize($std);
40		}
41		}
42

		@@ 14-46 (lines=33) @@
11		* DESTINATÁRIO DO DOCUMENTO FISCAL (CÓDIGO 55).
12		* @package NFePHP\EFD\Elements\ICMSIPI
13		*/
14		class C105 extends Element implements ElementInterface
15		{
16		const REG = 'C105';
17		const LEVEL = 3;
18		const PARENT = 'C100';
19
20		protected $parameters = [
21		'OPER' => [
22		'type' => 'string',
23		'regex' => '^[0-1]{1}$',
24		'required' => true,
25		'info' => 'Indicador do tipo de operação',
26		'format' => ''
27		],
28		'UF' => [
29		'type' => 'string',
30		'regex' => '^[a-zA-Z]{2}$',
31		'required' => true,
32		'info' => 'Sigla da UF de destino do ICMS_ST',
33		'format' => ''
34		]
35		];
36
37		/**
38		* Constructor
39		* @param \stdClass $std
40		*/
41		public function __construct(\stdClass $std)
42		{
43		parent::__construct(self::REG);
44		$this->std = $this->standarize($std);
45		}
46		}
47

		@@ 13-45 (lines=33) @@
10		* REGISTRO C110: INFORMAÇÃO COMPLEMENTAR DA NOTA FISCAL (CÓDIGO 01, 1B, 04 e 55).
11		* @package NFePHP\EFD\Elements\ICMSIPI
12		*/
13		class C110 extends Element implements ElementInterface
14		{
15		const REG = 'C110';
16		const LEVEL = 3;
17		const PARENT = 'C100';
18
19		protected $parameters = [
20		'COD_INF' => [
21		'type' => 'string',
22		'regex' => '^[A-z0-9]{1,6}$',
23		'required' => true,
24		'info' => 'Código da informação complementar do documento fiscal',
25		'format' => ''
26		],
27		'TXT_COMPL' => [
28		'type' => 'string',
29		'regex' => '^(.*)$',
30		'required' => true,
31		'info' => 'Descrição complementar do código de referência.',
32		'format' => ''
33		]
34		];
35
36		/**
37		* Constructor
38		* @param \stdClass $std
39		*/
40		public function __construct(\stdClass $std)
41		{
42		parent::__construct(self::REG);
43		$this->std = $this->standarize($std);
44		}
45		}
46

		@@ 13-45 (lines=33) @@
10		* REGISTRO C111: PROCESSO REFERENCIADO
11		* @package NFePHP\EFD\Elements\ICMSIPI
12		*/
13		class C111 extends Element implements ElementInterface
14		{
15		const REG = 'C111';
16		const LEVEL = 4;
17		const PARENT = 'C110';
18
19		protected $parameters = [
20		'NUM_PROC' => [
21		'type' => 'string',
22		'regex' => '^[A-z0-9]{1,15}$',
23		'required' => true,
24		'info' => 'Identificação do processo ou ato concessório',
25		'format' => ''
26		],
27		'IND_PROC' => [
28		'type' => 'string',
29		'regex' => '^(0\|1\|2\|3\|9)$',
30		'required' => true,
31		'info' => 'Indicador da origem do processo',
32		'format' => ''
33		]
34		];
35
36		/**
37		* Constructor
38		* @param \stdClass $std
39		*/
40		public function __construct(\stdClass $std)
41		{
42		parent::__construct(self::REG);
43		$this->std = $this->standarize($std);
44		}
45		}
46

		@@ 16-48 (lines=33) @@
13		* Combustíveis (LMC), Ajuste SINIEF 01/92.
14		* @package NFePHP\EFD\Elements\ICMSIPI
15		*/
16		class C171 extends Element implements ElementInterface
17		{
18		const REG = 'C171';
19		const LEVEL = 4;
20		const PARENT = 'C171';
21
22		protected $parameters = [
23		'NUM_TANQUE' => [
24		'type' => 'string',
25		'regex' => '^.{1,3}$',
26		'required' => true,
27		'info' => 'Tanque onde foi armazenado o combustível',
28		'format' => ''
29		],
30		'QTDE' => [
31		'type' => 'numeric',
32		'regex' => '\d+(\.\d*)?\|\.\d+$',
33		'required' => true,
34		'info' => 'Quantidade ou volume armazenado',
35		'format' => '15v3'
36		],
37		];
38
39		/**
40		* Constructor
41		* @param \stdClass $std
42		*/
43		public function __construct(\stdClass $std)
44		{
45		parent::__construct(self::REG);
46		$this->std = $this->standarize($std);
47		}
48		}
49

		@@ 17-49 (lines=33) @@
14		* objetivo de agregar informações adicionais ao item, de acordo com tabela a ser publicada pela UF.
15		* @package NFePHP\EFD\Elements\ICMSIPI
16		*/
17		class C177 extends Element implements ElementInterface
18		{
19		const REG = 'C177';
20		const LEVEL = 4;
21		const PARENT = 'C170';
22
23		protected $parameters = [
24		'COD_SELO_IPI' => [
25		'type' => 'string',
26		'regex' => '^.{6}$',
27		'required' => false,
28		'info' => 'Código do selo de controle do IPI, conforme Tabela 4.5.2',
29		'format' => ''
30		],
31		'QT_SELO_IPI' => [
32		'type' => 'numeric',
33		'regex' => '^(\d{0,12})$',
34		'required' => false,
35		'info' => 'Quantidade de selo de controle do IPI aplicada',
36		'format' => ''
37		],
38		];
39
40		/**
41		* Constructor
42		* @param \stdClass $std
43		*/
44		public function __construct(\stdClass $std)
45		{
46		parent::__construct(self::REG);
47		$this->std = $this->standarize($std);
48		}
49		}
50

		@@ 20-52 (lines=33) @@
17		* a IV.
18		* @package NFePHP\EFD\Elements\ICMSIPI
19		*/
20		class C195 extends Element implements ElementInterface
21		{
22		const REG = 'C195';
23		const LEVEL = 3;
24		const PARENT = 'C100';
25
26		protected $parameters = [
27		'COD_OBS' => [
28		'type' => 'string',
29		'regex' => '^.{1,6}$',
30		'required' => true,
31		'info' => 'Código da observação do lançamento fiscal',
32		'format' => ''
33		],
34		'TXT_COMPL' => [
35		'type' => 'string',
36		'regex' => '^(.*)$',
37		'required' => false,
38		'info' => 'Descrição complementar do código de observação.',
39		'format' => ''
40		],
41		];
42
43		/**
44		* Constructor
45		* @param \stdClass $std
46		*/
47		public function __construct(\stdClass $std)
48		{
49		parent::__construct(self::REG);
50		$this->std = $this->standarize($std);
51		}
52		}
53

		@@ 9-41 (lines=33) @@
6		use NFePHP\EFD\Common\ElementInterface;
7		use \stdClass;
8
9		class C410 extends Element implements ElementInterface
10		{
11		const REG = 'C410';
12		const LEVEL = 4;
13		const PARENT = 'C400';
14
15		protected $parameters = [
16		'VL_PIS' => [
17		'type' => 'numeric',
18		'regex' => '^\d+(\.\d*)?\|\.\d+$',
19		'required' => false,
20		'info' => 'Valor total do PIS',
21		'format' => '15v2'
22		],
23		'VL_COFINS' => [
24		'type' => 'numeric',
25		'regex' => '^\d+(\.\d*)?\|\.\d+$',
26		'required' => false,
27		'info' => 'Valor total da COFINS',
28		'format' => '15v2'
29		],
30		];
31
32		/**
33		* Constructor
34		* @param \stdClass $std
35		*/
36		public function __construct(\stdClass $std)
37		{
38		parent::__construct(self::REG);
39		$this->std = $this->standarize($std);
40		}
41		}
42

		@@ 18-50 (lines=33) @@
15		* Os períodos informados neste registro deverão abranger todo o período da escrituração,
16		* conforme informado no Registro 0000.
17		*/
18		class K100 extends Element implements ElementInterface
19		{
20		const REG = 'K100';
21		const LEVEL = 2;
22		const PARENT = 'K001';
23
24		protected $parameters = [
25		'DT_INI' => [
26		'type' => 'string',
27		'regex' => '^(0[1-9]\|[1-2][0-9]\|31(?!(?:0[2469]\|11))\|30(?!02))(0[1-9]\|1[0-2])([12]\d{3})$',
28		'required' => true,
29		'info' => 'Data inicial a que a apuração se refere',
30		'format' => ''
31		],
32		'DT_FIN' => [
33		'type' => 'string',
34		'regex' => '^(0[1-9]\|[1-2][0-9]\|31(?!(?:0[2469]\|11))\|30(?!02))(0[1-9]\|1[0-2])([12]\d{3})$',
35		'required' => true,
36		'info' => 'Data final a que a apuração se refere',
37		'format' => ''
38		]
39		];
40
41		/**
42		* Constructor
43		* @param \stdClass $std
44		*/
45		public function __construct(\stdClass $std)
46		{
47		parent::__construct(self::REG);
48		$this->std = $this->standarize($std);
49		}
50		}
51

		@@ 33-65 (lines=33) @@
30		* de controle de estoque constante no campo 06 do registro 0200, UNID_INV.
31		* Validação do Registro: A chave deste registro é o campo COD_ITEM_DES.
32		*/
33		class K215 extends Element implements ElementInterface
34		{
35		const REG = 'K215';
36		const LEVEL = 4;
37		const PARENT = 'K210';
38
39		protected $parameters = [
40		'COD_ITEM_DES' => [
41		'type' => 'string',
42		'regex' => '^.{1,60}$',
43		'required' => true,
44		'info' => 'Código do item de destino (campo 02 do Registro 0200)',
45		'format' => ''
46		],
47		'QTD_DES' => [
48		'type' => 'numeric',
49		'regex' => '^\d+(\.\d*)?\|\.\d+$',
50		'required' => true,
51		'info' => 'Quantidade de destino – entrada em estoque',
52		'format' => '15v6'
53		],
54		];
55
56		/**
57		* Constructor
58		* @param \stdClass $std
59		*/
60		public function __construct(\stdClass $std)
61		{
62		parent::__construct(self::REG);
63		$this->std = $this->standarize($std);
64		}
65		}
66

		@@ 24-56 (lines=33) @@
21		* NOTA: usada a letra Z no nome da Classe pois os nomes não podem ser exclusivamente
22		* numeréricos e também para não confundir os com elementos do bloco B
23		*/
24		class Z0400 extends Element implements ElementInterface
25		{
26		const REG = '0400';
27		const LEVEL = 0;
28		const PARENT = '';
29
30		protected $parameters = [
31		'COD_NAT' => [
32		'type' => 'string',
33		'regex' => '^.{1,10}$',
34		'required' => true,
35		'info' => 'Código da natureza da operação/prestação',
36		'format' => ''
37		],
38		'DESCR_NAT' => [
39		'type' => 'string',
40		'regex' => '^.{1,255}$',
41		'required' => true,
42		'info' => 'Descrição da natureza da operação/prestação',
43		'format' => ''
44		]
45		];
46
47		/**
48		* Constructor
49		* @param stdClass $std
50		*/
51		public function __construct(stdClass $std)
52		{
53		parent::__construct(self::REG);
54		$this->std = $this->standarize($std);
55		}
56		}
57

		@@ 27-59 (lines=33) @@
24		* NOTA: usada a letra Z no nome da Classe pois os nomes não podem ser exclusivamente
25		* numeréricos e também para não confundir os com elementos do bloco B
26		*/
27		class Z0450 extends Element implements ElementInterface
28		{
29		const REG = '0450';
30		const LEVEL = 0;
31		const PARENT = '';
32
33		protected $parameters = [
34		'COD_INF' => [
35		'type' => 'string',
36		'regex' => '^.{1,6}$',
37		'required' => true,
38		'info' => 'Código da informação complementar do documento fiscal.',
39		'format' => ''
40		],
41		'TXT' => [
42		'type' => 'string',
43		'regex' => '^.{1,1000}$',
44		'required' => true,
45		'info' => 'Texto livre da informação complementar existente no documento fiscal',
46		'format' => ''
47		]
48		];
49
50		/**
51		* Constructor
52		* @param stdClass $std
53		*/
54		public function __construct(stdClass $std)
55		{
56		parent::__construct(self::REG);
57		$this->std = $this->standarize($std);
58		}
59		}
60

nfephp-org / sped-efd

Code Duplication Length = 33-37 lines in 44 locations

src/Elements/Contribuicoes/A110.php 1 location

src/Elements/Contribuicoes/A111.php 1 location

src/Elements/Contribuicoes/C010.php 1 location

src/Elements/Contribuicoes/C110.php 1 location

src/Elements/Contribuicoes/C111.php 1 location

src/Elements/Contribuicoes/C188.php 1 location

src/Elements/Contribuicoes/C198.php 1 location

src/Elements/Contribuicoes/C489.php 1 location

src/Elements/Contribuicoes/C499.php 1 location

src/Elements/Contribuicoes/C509.php 1 location

src/Elements/Contribuicoes/C609.php 1 location

src/Elements/Contribuicoes/C830.php 1 location

src/Elements/Contribuicoes/C890.php 1 location

src/Elements/Contribuicoes/D111.php 1 location

src/Elements/Contribuicoes/D209.php 1 location

src/Elements/Contribuicoes/D309.php 1 location

src/Elements/Contribuicoes/D359.php 1 location

src/Elements/Contribuicoes/D509.php 1 location

src/Elements/Contribuicoes/D609.php 1 location

src/Elements/Contribuicoes/P199.php 1 location

src/Elements/Contribuicoes/Z0400.php 1 location

src/Elements/Contribuicoes/Z0450.php 1 location

src/Elements/Contribuicoes/Z1809.php 1 location

src/Elements/ICMSIPI/C105.php 1 location

src/Elements/ICMSIPI/C110.php 1 location

src/Elements/ICMSIPI/C111.php 1 location

src/Elements/ICMSIPI/C171.php 1 location

src/Elements/ICMSIPI/C177.php 1 location

src/Elements/ICMSIPI/C195.php 1 location

src/Elements/ICMSIPI/C410.php 1 location

src/Elements/ICMSIPI/E100.php 1 location

src/Elements/ICMSIPI/G140.php 1 location

src/Elements/ICMSIPI/K100.php 1 location

src/Elements/ICMSIPI/K215.php 1 location

src/Elements/ICMSIPI/Z0400.php 1 location

src/Elements/ICMSIPI/Z0450.php 1 location

src/Elements/ICMSIPI/Z0460.php 1 location

src/Elements/ICMSIPI/Z1360.php 1 location

src/Elements/ICMSIPI/Z1710.php 1 location

src/Elements/ICMSIPI/Z1910.php 1 location

src/Elements/ICMSIPI/K291.php 1 location

src/Elements/ICMSIPI/K292.php 1 location

src/Elements/ICMSIPI/K301.php 1 location

src/Elements/ICMSIPI/K302.php 1 location