opf-validator 0.0.1

package/dist/recurring-payments/validators/createRecurringConsent.js

@@ -0,0 +1,663 @@
+"use strict";
+/**
+ * Validações para CreateRecurringConsent
+ * Segue as regras especificadas no Open Finance Brasil - API de Pagamentos Automáticos
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCreateRecurringConsent = validateCreateRecurringConsent;
+const openFinanceErrors_1 = require("../../utils/openFinanceErrors");
+/**
+ * Tipos de documento válidos
+ */
+const VALID_DOCUMENT_TYPES = ["CPF", "CNPJ"];
+/**
+ * Tipos de conta válidos para consentimentos
+ */
+const VALID_ACCOUNT_TYPES = ["CACC", "SVGS", "TRAN"];
+/**
+ * Intervalos válidos para Pix Automático
+ */
+const VALID_INTERVALS = ["SEMANAL", "MENSAL", "ANUAL", "SEMESTRAL", "TRIMESTRAL"];
+/**
+ * Tipos de pessoa válidos
+ */
+const VALID_PERSON_TYPES = ["PESSOA_NATURAL", "PESSOA_JURIDICA"];
+/**
+ * Valida o payload de criação de consentimento de pagamento recorrente
+ */
+function validateCreateRecurringConsent(payload) {
+    const errors = [];
+    // Validação: data deve existir
+    if (!payload.data) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("data"));
+        return { isValid: false, errors };
+    }
+    const data = payload.data;
+    // Validação: loggedUser é obrigatório
+    if (!data.loggedUser) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("loggedUser"));
+    }
+    else {
+        const loggedUserErrors = validateLoggedUser(data.loggedUser);
+        errors.push(...loggedUserErrors);
+    }
+    // Validação: businessEntity (opcional, mas se presente deve ser válida)
+    if (data.businessEntity) {
+        const businessEntityErrors = validateBusinessEntity(data.businessEntity);
+        errors.push(...businessEntityErrors);
+    }
+    // Validação: creditors é obrigatório
+    if (!data.creditors) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("creditors"));
+    }
+    else {
+        const creditorsErrors = validateCreditors(data.creditors);
+        errors.push(...creditorsErrors);
+    }
+    // Validação: recurringConfiguration é obrigatório
+    if (!data.recurringConfiguration) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration"));
+    }
+    else {
+        const recurringConfigErrors = validateRecurringConfiguration(data.recurringConfiguration);
+        errors.push(...recurringConfigErrors);
+    }
+    // Validação: expirationDateTime (opcional)
+    if (data.expirationDateTime) {
+        const expirationErrors = validateExpirationDateTime(data.expirationDateTime, data.recurringConfiguration);
+        errors.push(...expirationErrors);
+    }
+    // Validação: additionalInformation (opcional)
+    if (data.additionalInformation) {
+        const additionalInfoErrors = validateAdditionalInformation(data.additionalInformation);
+        errors.push(...additionalInfoErrors);
+    }
+    // Validação: debtorAccount (opcional)
+    if (data.debtorAccount) {
+        const debtorAccountErrors = validateDebtorAccount(data.debtorAccount);
+        errors.push(...debtorAccountErrors);
+    }
+    // Validação: journey (opcional)
+    if (data.journey) {
+        const journeyErrors = validateJourney(data.journey);
+        errors.push(...journeyErrors);
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Valida LoggedUser
+ */
+function validateLoggedUser(loggedUser) {
+    const errors = [];
+    if (typeof loggedUser !== "object" || loggedUser === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("loggedUser", "Deve ser um objeto"));
+        return errors;
+    }
+    if (!loggedUser.document) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("loggedUser.document"));
+    }
+    else {
+        const documentErrors = validateLoggedUserDocument(loggedUser.document);
+        errors.push(...documentErrors);
+    }
+    return errors;
+}
+/**
+ * Valida documento do LoggedUser
+ */
+function validateLoggedUserDocument(document) {
+    const errors = [];
+    if (typeof document !== "object" || document === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("loggedUser.document", "Deve ser um objeto"));
+        return errors;
+    }
+    // identification é obrigatório
+    if (!document.identification) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("loggedUser.document.identification"));
+    }
+    else if (typeof document.identification !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("loggedUser.document.identification", "Deve ser uma string"));
+    }
+    else if (document.identification.length > 11) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("loggedUser.document.identification", "CPF deve ter no máximo 11 dígitos"));
+    }
+    else if (!/^\d{11}$/.test(document.identification)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("loggedUser.document.identification", "CPF deve conter apenas dígitos"));
+    }
+    // rel é obrigatório
+    if (!document.rel) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("loggedUser.document.rel"));
+    }
+    else if (document.rel !== "CPF") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("loggedUser.document.rel", "Deve ser 'CPF' para usuário logado"));
+    }
+    return errors;
+}
+/**
+ * Valida BusinessEntity
+ */
+function validateBusinessEntity(businessEntity) {
+    const errors = [];
+    if (typeof businessEntity !== "object" || businessEntity === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("businessEntity", "Deve ser um objeto"));
+        return errors;
+    }
+    if (!businessEntity.document) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("businessEntity.document"));
+    }
+    else {
+        const documentErrors = validateBusinessEntityDocument(businessEntity.document);
+        errors.push(...documentErrors);
+    }
+    return errors;
+}
+/**
+ * Valida documento de BusinessEntity
+ */
+function validateBusinessEntityDocument(document) {
+    const errors = [];
+    if (typeof document !== "object" || document === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("businessEntity.document", "Deve ser um objeto"));
+        return errors;
+    }
+    // identification é obrigatório
+    if (!document.identification) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("businessEntity.document.identification"));
+    }
+    else if (typeof document.identification !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("businessEntity.document.identification", "Deve ser uma string"));
+    }
+    else if (!/^[0-9A-Z]{12}[0-9]{2}$/.test(document.identification)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("businessEntity.document.identification", "CNPJ deve ter 14 caracteres no formato esperado"));
+    }
+    // rel é obrigatório
+    if (!document.rel) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("businessEntity.document.rel"));
+    }
+    else if (document.rel !== "CNPJ") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("businessEntity.document.rel", "Deve ser 'CNPJ' para entidade de negócio"));
+    }
+    return errors;
+}
+/**
+ * Valida array de creditors (recebedores)
+ */
+function validateCreditors(creditors) {
+    const errors = [];
+    if (!Array.isArray(creditors)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("creditors", "Deve ser um array"));
+        return errors;
+    }
+    if (creditors.length === 0) {
+        errors.push((0, openFinanceErrors_1.createError)("PARAMETRO_INVALIDO", "Parâmetro inválido.", "Array de creditors deve conter pelo menos um item"));
+        return errors;
+    }
+    creditors.forEach((creditor, index) => {
+        const creditorErrors = validateCreditor(creditor);
+        creditorErrors.forEach((error) => {
+            errors.push({
+                ...error,
+                detail: `creditors[${index}]: ${error.detail}`,
+            });
+        });
+    });
+    return errors;
+}
+/**
+ * Valida um creditor individual
+ */
+function validateCreditor(creditor) {
+    const errors = [];
+    if (typeof creditor !== "object" || creditor === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("creditor", "Deve ser um objeto"));
+        return errors;
+    }
+    // personType é obrigatório
+    if (!creditor.personType) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("personType"));
+    }
+    else if (!VALID_PERSON_TYPES.includes(creditor.personType)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("personType", `Deve ser um dos: ${VALID_PERSON_TYPES.join(", ")}`));
+    }
+    // cpfCnpj é obrigatório
+    if (!creditor.cpfCnpj) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("cpfCnpj"));
+    }
+    else if (typeof creditor.cpfCnpj !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("cpfCnpj", "Deve ser uma string"));
+    }
+    else {
+        // Validar formato de CPF ou CNPJ
+        const isCpf = /^\d{11}$/.test(creditor.cpfCnpj);
+        const isCnpj = /^[0-9A-Z]{12}[0-9]{2}$/.test(creditor.cpfCnpj);
+        if (!isCpf && !isCnpj) {
+            errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("cpfCnpj", "Deve ser um CPF (11 dígitos) ou CNPJ (14 caracteres)"));
+        }
+    }
+    // name é obrigatório
+    if (!creditor.name) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("name"));
+    }
+    else if (typeof creditor.name !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("name", "Deve ser uma string"));
+    }
+    else if (creditor.name.length > 120) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("name", "Deve ter no máximo 120 caracteres"));
+    }
+    return errors;
+}
+/**
+ * Valida recurringConfiguration
+ */
+function validateRecurringConfiguration(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("recurringConfiguration", "Deve ser um objeto"));
+        return errors;
+    }
+    // Validar que apenas um dos tipos está presente
+    const hasAutomatic = !!config.automatic;
+    const hasSweeping = !!config.sweeping;
+    const hasVrp = !!config.vrp;
+    const configCount = [hasAutomatic, hasSweeping, hasVrp].filter(Boolean).length;
+    if (configCount !== 1) {
+        errors.push((0, openFinanceErrors_1.createError)("PARAMETRO_INVALIDO", "Parâmetro inválido.", "recurringConfiguration deve conter exatamente um dos: automatic, sweeping ou vrp"));
+        return errors;
+    }
+    if (hasAutomatic) {
+        const automaticErrors = validateAutomaticConfig(config.automatic);
+        errors.push(...automaticErrors);
+    }
+    if (hasSweeping) {
+        const sweepingErrors = validateSweepingConfig(config.sweeping);
+        errors.push(...sweepingErrors);
+    }
+    if (hasVrp) {
+        const vrpErrors = validateVrpConfig(config.vrp);
+        errors.push(...vrpErrors);
+    }
+    return errors;
+}
+/**
+ * Valida configuração de Pix Automático
+ */
+function validateAutomaticConfig(automatic) {
+    const errors = [];
+    if (typeof automatic !== "object" || automatic === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("automatic", "Deve ser um objeto"));
+        return errors;
+    }
+    // contractId é obrigatório
+    if (!automatic.contractId) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration.automatic.contractId"));
+    }
+    else if (typeof automatic.contractId !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("contractId", "Deve ser uma string"));
+    }
+    else if (!/^[a-zA-Z0-9]{1,35}$/.test(automatic.contractId)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("contractId", "Deve conter de 1 a 35 caracteres alfanuméricos"));
+    }
+    // interval é obrigatório
+    if (!automatic.interval) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration.automatic.interval"));
+    }
+    else if (!VALID_INTERVALS.includes(automatic.interval)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("interval", `Deve ser um dos: ${VALID_INTERVALS.join(", ")}`));
+    }
+    // contractDebtor é obrigatório
+    if (!automatic.contractDebtor) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration.automatic.contractDebtor"));
+    }
+    else {
+        const debtorErrors = validateContractDebtor(automatic.contractDebtor);
+        errors.push(...debtorErrors);
+    }
+    // isRetryAccepted é obrigatório
+    if (automatic.isRetryAccepted === undefined) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration.automatic.isRetryAccepted"));
+    }
+    else if (typeof automatic.isRetryAccepted !== "boolean") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("isRetryAccepted", "Deve ser um valor booleano"));
+    }
+    // referenceStartDate é obrigatório
+    if (!automatic.referenceStartDate) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration.automatic.referenceStartDate"));
+    }
+    else {
+        const dateErrors = validateReferenceStartDate(automatic.referenceStartDate);
+        errors.push(...dateErrors);
+    }
+    // fixedAmount e maximumVariableAmount são excludentes
+    if (automatic.fixedAmount && automatic.maximumVariableAmount) {
+        errors.push((0, openFinanceErrors_1.createError)("PARAMETRO_INVALIDO", "Parâmetro inválido.", "fixedAmount e maximumVariableAmount são excludentes"));
+    }
+    // Validar fixedAmount se presente
+    if (automatic.fixedAmount) {
+        const fixedAmountErrors = validateAmount(automatic.fixedAmount, "fixedAmount");
+        errors.push(...fixedAmountErrors);
+    }
+    // Validar maximumVariableAmount se presente
+    if (automatic.maximumVariableAmount) {
+        const maxAmountErrors = validateAmount(automatic.maximumVariableAmount, "maximumVariableAmount");
+        errors.push(...maxAmountErrors);
+        // Se maximumVariableAmount está presente, minimumVariableAmount não pode excedê-lo
+        if (automatic.minimumVariableAmount) {
+            const minAmountErrors = validateAmount(automatic.minimumVariableAmount, "minimumVariableAmount");
+            errors.push(...minAmountErrors);
+            // Comparar valores
+            const maxValue = parseFloat(automatic.maximumVariableAmount);
+            const minValue = parseFloat(automatic.minimumVariableAmount);
+            if (minValue > maxValue) {
+                errors.push((0, openFinanceErrors_1.createError)("DETALHE_PAGAMENTO_INVALIDO", "Detalhe do pagamento inválido.", "minimumVariableAmount não pode ser maior que maximumVariableAmount"));
+            }
+        }
+    }
+    // Validar firstPayment se presente
+    if (automatic.firstPayment) {
+        const firstPaymentErrors = validateFirstPayment(automatic.firstPayment);
+        errors.push(...firstPaymentErrors);
+    }
+    return errors;
+}
+/**
+ * Valida ContractDebtor
+ */
+function validateContractDebtor(debtor) {
+    const errors = [];
+    if (typeof debtor !== "object" || debtor === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("contractDebtor", "Deve ser um objeto"));
+        return errors;
+    }
+    // name é obrigatório
+    if (!debtor.name) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration.automatic.contractDebtor.name"));
+    }
+    else if (typeof debtor.name !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("name", "Deve ser uma string"));
+    }
+    else if (debtor.name.length > 120) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("name", "Deve ter no máximo 120 caracteres"));
+    }
+    // document é obrigatório
+    if (!debtor.document) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("recurringConfiguration.automatic.contractDebtor.document"));
+    }
+    else {
+        const docErrors = validateContractDebtorDocument(debtor.document);
+        errors.push(...docErrors);
+    }
+    return errors;
+}
+/**
+ * Valida documento do ContractDebtor
+ */
+function validateContractDebtorDocument(document) {
+    const errors = [];
+    if (typeof document !== "object" || document === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("document", "Deve ser um objeto"));
+        return errors;
+    }
+    // identification é obrigatório
+    if (!document.identification) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("document.identification"));
+    }
+    else if (!/^(\d{11})|([0-9A-Z]{12}\d{2})$/.test(document.identification)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("document.identification", "Deve ser um CPF (11 dígitos) ou CNPJ (14 caracteres)"));
+    }
+    // rel é obrigatório
+    if (!document.rel) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("document.rel"));
+    }
+    else if (!["CPF", "CNPJ"].includes(document.rel)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("document.rel", "Deve ser 'CPF' ou 'CNPJ'"));
+    }
+    return errors;
+}
+/**
+ * Valida data de início da recorrência
+ */
+function validateReferenceStartDate(date) {
+    const errors = [];
+    if (typeof date !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("referenceStartDate", "Deve ser uma string"));
+        return errors;
+    }
+    const datePattern = /^(\d{4})-(1[0-2]|0?[1-9])-(3[01]|[12][0-9]|0?[1-9])$/;
+    if (!datePattern.test(date)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("referenceStartDate", "Deve estar no formato YYYY-MM-DD"));
+    }
+    return errors;
+}
+/**
+ * Valida valor monetário
+ */
+function validateAmount(amount, fieldName) {
+    const errors = [];
+    if (typeof amount !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO(fieldName, "Deve ser uma string"));
+        return errors;
+    }
+    const amountPattern = /^(\d{1,16}\.\d{2})$/;
+    if (!amountPattern.test(amount)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO(fieldName, "Deve ser um valor monetário no formato 0000000.00"));
+    }
+    return errors;
+}
+/**
+ * Valida FirstPayment
+ */
+function validateFirstPayment(payment) {
+    const errors = [];
+    if (typeof payment !== "object" || payment === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("firstPayment", "Deve ser um objeto"));
+        return errors;
+    }
+    // type é obrigatório
+    if (!payment.type) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("firstPayment.type"));
+    }
+    else if (payment.type !== "PIX") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("type", "Deve ser 'PIX'"));
+    }
+    // date é obrigatório
+    if (!payment.date) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("firstPayment.date"));
+    }
+    else {
+        const dateErrors = validateReferenceStartDate(payment.date);
+        errors.push(...dateErrors);
+    }
+    // currency é obrigatório
+    if (!payment.currency) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("firstPayment.currency"));
+    }
+    else if (payment.currency !== "BRL") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("currency", "Deve ser 'BRL' (Real Brasileiro)"));
+    }
+    // amount é obrigatório
+    if (!payment.amount) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("firstPayment.amount"));
+    }
+    else {
+        const amountErrors = validateAmount(payment.amount, "amount");
+        errors.push(...amountErrors);
+    }
+    // creditorAccount é obrigatório
+    if (!payment.creditorAccount) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("firstPayment.creditorAccount"));
+    }
+    else {
+        const creditorAccountErrors = validateCreditorAccount(payment.creditorAccount);
+        errors.push(...creditorAccountErrors);
+    }
+    return errors;
+}
+/**
+ * Valida conta de crédito
+ */
+function validateCreditorAccount(account) {
+    const errors = [];
+    if (typeof account !== "object" || account === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("creditorAccount", "Deve ser um objeto"));
+        return errors;
+    }
+    // ispb é obrigatório
+    if (!account.ispb) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("creditorAccount.ispb"));
+    }
+    else if (!/^[0-9A-Z]{8}$/.test(account.ispb)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("ispb", "Deve ter exatamente 8 caracteres alfanuméricos"));
+    }
+    // number é obrigatório
+    if (!account.number) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("creditorAccount.number"));
+    }
+    else if (!/^\d{1,20}$/.test(account.number)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("number", "Deve ter de 1 a 20 dígitos"));
+    }
+    // accountType é obrigatório
+    if (!account.accountType) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("creditorAccount.accountType"));
+    }
+    else if (!VALID_ACCOUNT_TYPES.includes(account.accountType)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("accountType", `Deve ser um dos: ${VALID_ACCOUNT_TYPES.join(", ")}`));
+    }
+    // issuer é opcional, mas se presente deve ser válido
+    if (account.issuer && !/^\d{1,4}$/.test(account.issuer)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("issuer", "Deve ter de 1 a 4 dígitos"));
+    }
+    return errors;
+}
+/**
+ * Valida DebtorAccount (opcional)
+ */
+function validateDebtorAccount(account) {
+    const errors = [];
+    if (typeof account !== "object" || account === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("debtorAccount", "Deve ser um objeto"));
+        return errors;
+    }
+    // ispb é obrigatório
+    if (!account.ispb) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("debtorAccount.ispb"));
+    }
+    else if (!/^[0-9A-Z]{8}$/.test(account.ispb)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("ispb", "Deve ter exatamente 8 caracteres alfanuméricos"));
+    }
+    // number é obrigatório
+    if (!account.number) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("debtorAccount.number"));
+    }
+    else if (!/^\d{1,20}$/.test(account.number)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("number", "Deve ter de 1 a 20 dígitos"));
+    }
+    // accountType é obrigatório
+    if (!account.accountType) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("debtorAccount.accountType"));
+    }
+    else if (!VALID_ACCOUNT_TYPES.includes(account.accountType)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("accountType", `Deve ser um dos: ${VALID_ACCOUNT_TYPES.join(", ")}`));
+    }
+    // issuer é opcional, mas se presente deve ser válido
+    if (account.issuer && !/^\d{1,4}$/.test(account.issuer)) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("issuer", "Deve ter de 1 a 4 dígitos"));
+    }
+    return errors;
+}
+/**
+ * Valida expirationDateTime
+ * [Restrição] Caso o consentimento seja para Pix Automático, o horário de expiração do consentimento precisa ser às 23:59:59 (UTC).
+ */
+function validateExpirationDateTime(expirationDateTime, recurringConfiguration) {
+    const errors = [];
+    if (typeof expirationDateTime !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("expirationDateTime", "Deve ser uma string"));
+        return errors;
+    }
+    const rfc3339Pattern = /^(\d{4})-(1[0-2]|0?[1-9])-(3[01]|[12][0-9]|0?[1-9])T(?:[01]\d|2[0123]):(?:[012345]\d):(?:[012345]\d)Z$/;
+    if (!rfc3339Pattern.test(expirationDateTime)) {
+        errors.push((0, openFinanceErrors_1.createError)("PARAMETRO_INVALIDO", "Parâmetro inválido.", "expirationDateTime deve estar no formato RFC-3339 com timezone UTC (YYYY-MM-DDTHH:mm:ssZ)"));
+        return errors;
+    }
+    // Validar que é Pix Automático
+    if (recurringConfiguration?.automatic) {
+        // Extrair hora do expirationDateTime
+        const hourMatch = expirationDateTime.match(/T(\d{2}):(\d{2}):(\d{2})Z$/);
+        if (hourMatch) {
+            const hour = hourMatch[1];
+            const minute = hourMatch[2];
+            const second = hourMatch[3];
+            if (hour !== "23" || minute !== "59" || second !== "59") {
+                errors.push((0, openFinanceErrors_1.createError)("DATA_EXPIRACAO_INVALIDA", "Nova data para expiração do consentimento é inválida.", "Para Pix Automático, o horário de expiração deve ser às 23:59:59 (UTC)"));
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Valida additionalInformation
+ */
+function validateAdditionalInformation(info) {
+    const errors = [];
+    if (typeof info !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("additionalInformation", "Deve ser uma string"));
+    }
+    else if (info.length > 140) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("additionalInformation", "Deve ter no máximo 140 caracteres"));
+    }
+    return errors;
+}
+/**
+ * Valida Journey
+ */
+function validateJourney(journey) {
+    const errors = [];
+    if (typeof journey !== "object" || journey === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("journey", "Deve ser um objeto"));
+        return errors;
+    }
+    // isLinked é obrigatório
+    if (journey.isLinked === undefined) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("journey.isLinked"));
+    }
+    else if (typeof journey.isLinked !== "boolean") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("isLinked", "Deve ser um valor booleano"));
+    }
+    // linkId é obrigatório
+    if (!journey.linkId) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_NAO_INFORMADO("journey.linkId"));
+    }
+    else if (typeof journey.linkId !== "string") {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("linkId", "Deve ser uma string"));
+    }
+    else if (journey.linkId.length > 256) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("linkId", "Deve ter no máximo 256 caracteres"));
+    }
+    return errors;
+}
+/**
+ * Valida configuração de Sweeping (Transferências Inteligentes)
+ */
+function validateSweepingConfig(sweeping) {
+    const errors = [];
+    // Por enquanto, apenas validar estrutura básica
+    if (typeof sweeping !== "object" || sweeping === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("sweeping", "Deve ser um objeto"));
+    }
+    return errors;
+}
+/**
+ * Valida configuração de VRP
+ */
+function validateVrpConfig(vrp) {
+    const errors = [];
+    // Por enquanto, apenas validar estrutura básica
+    if (typeof vrp !== "object" || vrp === null) {
+        errors.push(openFinanceErrors_1.CommonErrors.PARAMETRO_INVALIDO("vrp", "Deve ser um objeto"));
+    }
+    return errors;
+}
+//# sourceMappingURL=createRecurringConsent.js.map