@77sol-lab/form-schemas 1.1.0

package/README.md

@@ -0,0 +1,182 @@
+# @77sol-lab/form-schemas
+
+Repositório **central de schemas Zod da 77**: a **fonte única de verdade para validação** compartilhada entre frontend e backend. A regra é escrita **uma única vez** em [Zod](https://zod.dev) e importada nas duas pontas — o front valida o formulário (on blur/submit) e o back valida o payload (na borda da API) com o **mesmo schema**. Sem duplicar lógica, sem divergência, sem o clássico "passou no front e o back recusou".
+
+A estrutura cresce **por domínio**: cada contexto de negócio mora em `src/domains/<domínio>/<escopo>/`, e a camada `src/shared/` reúne primitivos reutilizáveis (regex/validadores de formato, primitivos de campo Zod e enums comuns) — agnósticos a domínio. Crescer é **adicionar um domínio**, não inflar um arquivo gigante.
+
+O **primeiro domínio** é o de **financiamento** (`financing/formalization`) e serve de exemplo concreto ao longo deste README. Ele define, por banco, uma ficha **PF** (pessoa física) e uma ficha **PJ** (pessoa jurídica): **cada banco são dois arquivos próprios em `schemas/`** — `<Banco>PFSchema.ts` e `<Banco>PJSchema.ts` — com o **shape declarado explicitamente** (`z.object({...}).strict()`). Você abre o arquivo e lê os campos direto, sem build dinâmico nem catálogo.
+
+> Contexto do primeiro domínio: [USI-4045](https://linear.app/77sol/issue/USI-4045).
+
+## Instalação
+
+Pacote público no **npm**. Instale junto com o `zod`:
+
+```bash
+yarn add @77sol-lab/form-schemas zod
+# ou
+npm install @77sol-lab/form-schemas zod
+```
+
+`zod` é `peerDependency` (fica a cargo do consumidor, evita versões duplicadas). O pacote é **source-only** (distribui `.ts`, sem build): inclua-o na sua transpilação — ex.: `transpilePackages: ['@77sol-lab/form-schemas']` no Next.js.
+
+## Import (subpath por banco)
+
+Cada banco é **self-contained**: os arquivos `<Banco>PFSchema.ts`/`<Banco>PJSchema.ts`
+ficam disponíveis individualmente via o **subpath export com wildcard**
+`./financing/formalization/schemas/*`. Não há mais registry agregado nem mapas
+centrais — você importa **diretamente o arquivo do banco**:
+
+```ts
+import { bvPfSchema } from '@77sol-lab/form-schemas/financing/formalization/schemas/BvPFSchema'
+import { bvPjSchema } from '@77sol-lab/form-schemas/financing/formalization/schemas/BvPJSchema'
+import { santanderPjSchema } from '@77sol-lab/form-schemas/financing/formalization/schemas/SantanderPJSchema'
+import { credito77PfSchema } from '@77sol-lab/form-schemas/financing/formalization/schemas/Credito77PFSchema'
+```
+
+O nome do **arquivo** é PascalCase do slug (`bv`→`Bv`, `banco-do-brasil`→`BancoDoBrasil`,
+`cash-me`→`CashMe`, `credito77`→`Credito77`, `hdt-energy`→`HdtEnergy`, `sol-agora`→`SolAgora`);
+o nome do **export** continua camelCase (`bvPfSchema`, `bancoDoBrasilPjSchema`, …).
+
+## Uso
+
+A validação roda igual no front (on blur/submit) e no back (no submit), a partir do
+mesmo schema. Importe o arquivo do banco e use `.parse()`/`.safeParse()`:
+
+```ts
+import { bvPfSchema } from '@77sol-lab/form-schemas/financing/formalization/schemas/BvPFSchema'
+import { santanderPjSchema } from '@77sol-lab/form-schemas/financing/formalization/schemas/SantanderPJSchema'
+
+const result = bvPfSchema.safeParse(payloadPf)
+if (!result.success) {
+  console.log(result.error.issues) // → 400 no back / feedback no front
+}
+
+santanderPjSchema.parse(payloadPj) // empresa + avalista[]
+```
+
+Cada arquivo também exporta o tipo inferido correspondente (`BvPfFicha`,
+`SantanderPjFicha`, …). Como o shape é declarado explicitamente, `z.infer` produz
+**tipos precisos por campo**.
+
+> Como não há mais um mapa central, quem precisa **escolher o schema dinamicamente
+> pelo slug** monta o próprio mapa local importando só os bancos que usa.
+
+Bancos disponíveis (slug): `credito77`, `losango`, `santander`, `btg`, `bv`,
+`banco-do-brasil`, `caixa-economica-federal`, `alfa`, `safra`, `cash_me_`,
+`hdt_energy`, `solfacil`, `sol_agora`, `eos`.
+
+## Estrutura
+
+```
+src/
+  shared/                       # infra interna agnóstica a domínio (não exportada)
+    regex/                      # patterns + validators (CPF/CNPJ/cpfCnpj, datas) + field schemas de formato
+    fields/                     # primitivos de campo Zod (textField, numberField, integerField, fileUploadField…)
+    enums/                      # enums reutilizáveis (tipo_documento, sexo, nacionalidade)
+  domains/
+    financing/
+      enums/                    # bancos (BANK_SLUGS/BankEnum) + ocupações
+      formalization/
+        extras.ts               # campos da formalização comuns (uploads, vínculo, seguro RD/RE)
+        refinements.ts          # applyPfRefinements / applyPjRefinements (RN-011/012 + nacionalidade→RNE)
+        schemas/                # DOIS ARQUIVOS ACHATADOS POR BANCO, shape explícito — sem index/barril
+          BvPFSchema.ts         # ficha PF do BV (bvPfSchema)
+          BvPJSchema.ts         # ficha PJ do BV (bvPjSchema)
+          SantanderPFSchema.ts  # … um par PF/PJ por banco
+          …                     # (14 bancos = 28 arquivos achatados)
+        index.ts                # barrel do escopo (só BANK_SLUGS/BankEnum/tipos — NÃO os schemas)
+      index.ts
+  index.ts                      # API pública root
+```
+
+Cada arquivo de banco é independente: `<Banco>PFSchema.ts` e `<Banco>PJSchema.ts`
+importam os primitivos de `shared/`, os campos comuns de `extras.ts` e os refinements de
+`refinements.ts`, e declaram o `z.object({...})` de PF e de PJ. Sem gerador, sem catálogo
+de dados, sem builder e **sem registry agregado**: cada arquivo é exposto direto pelo
+subpath export `./financing/formalization/schemas/*`.
+
+## Manutenção
+
+A manutenção é **manual e local aos arquivos do banco** — edite o shape direto em
+`schemas/<Banco>PFSchema.ts` (PF) ou `schemas/<Banco>PJSchema.ts` (PJ).
+
+- **Mudar campos de um banco:** abra `schemas/<Banco>PFSchema.ts` ou `schemas/<Banco>PJSchema.ts`
+  e edite o `z.object({...})` (adicione/remova chaves, troque o schema de formato, marque `.optional()`).
+- **Regra de formato/primitivo:** `shared/regex` (CPF/CNPJ/datas…) ou
+  `shared/fields/primitives` (`textField`, `numberField`, `integerField`).
+- **Campos comuns da formalização** (uploads, vínculo, seguro): `extras.ts`.
+- **Regra cross-field (RN):** `refinements.ts`.
+
+### Adicionar um banco
+
+**Regra do pacote: cada banco são dois arquivos de schema próprios (achatados em `schemas/`).** O passo a passo
+está na skill **`adicionar-banco-financing`** (`.claude/skills/`). Em resumo:
+
+1. Crie `schemas/<Banco>PFSchema.ts` e `schemas/<Banco>PJSchema.ts` (shape explícito).
+2. (Opcional) adicione o `slug` em `BANK_SLUGS` (`enums/banks.ts`) só se quiser o banco
+   listado no enum — os schemas não dependem mais dele.
+3. `yarn check:fix && yarn typecheck`.
+
+> Teste de schema é dispensado por enquanto — não crie `.spec.ts` por banco.
+
+> Não há registry para registrar: os arquivos ficam disponíveis automaticamente via o
+> subpath export `./financing/formalization/schemas/*`, sem fiação central.
+
+## Regras de negócio materializadas
+
+Aplicadas via `.superRefine(...)` em cada banco; os campos usam os nomes definidos no schema.
+
+| RN | Onde |
+| -- | -- |
+| RN-011 (RG ≤ 10 anos) | `refinements.ts` (`type_doc='rg'` + `doc_issue_date`) · CNH "não vencida" → TODO (dado ausente) |
+| RN-012 (CNPJ por ocupação) | `refinements.ts` (`nature_of_occupation` + `cnpj_proprietary`; presentes só onde o banco os declara, ex. BV) |
+| RN-014 (Seguro RD/RE default ON) | `extras.ts` (`rd_re_insurance_toggle: z.boolean().default(true)`) |
+| Nacionalidade → RNE | `refinements.ts` (`nationality` ≠ Brasil força `type_doc='rne'`) |
+| Vínculo de terceiro | `refinements.ts` (`account_third_party` ≠ `nao_se_aplica` exige `bond_document_upload`) |
+| `.strict()` | cada ficha rejeita qualquer campo fora do shape declarado do banco |
+
+### Campos `dropdown`/`autocomplete`
+
+Campos de seleção são **string validada** (`textField`), exceto `type_doc`
+(`DocumentTypeEnum`) e `sex` (`SexEnum`). Para restringir um deles, troque no
+`<Banco>PFSchema.ts`/`<Banco>PJSchema.ts` do banco por um `z.enum([...])` — está tudo explícito no shape.
+
+## Distribuição (source-only)
+
+Este repositório **armazena apenas os schemas em TypeScript** — **não faz build**. Os `exports` apontam direto para o source (`src/*.ts`); quem consome transpila.
+
+```jsonc
+"exports": {
+  ".":                                    "./src/index.ts",
+  "./financing/formalization":            "./src/domains/financing/formalization/index.ts",
+  // wildcard: cada arquivo de banco é importável direto, sem registry central
+  "./financing/formalization/schemas/*":  "./src/domains/financing/formalization/schemas/*.ts"
+}
+```
+
+- **Next.js / frontend:** adicione `@77sol-lab/form-schemas` em `transpilePackages`.
+- **api-v3 / backend (Node + TS):** garanta que o pacote seja transpilado.
+- **`zod`** é `peerDependency`.
+
+## Agnóstico a framework
+
+Depende **apenas de `zod`** (peer) — zero React/Next/Vue/DOM. Entrega schemas Zod, não
+componentes: valide com `.parse()`/`.safeParse()` e, para renderizar, derive os campos
+do schema (`.shape`). Um guardrail do Biome (`noRestrictedImports`) barra imports de UI.
+
+## Scripts
+
+```bash
+yarn build         # typecheck + lint + test (portões de validação; não gera dist)
+yarn typecheck     # tsc --noEmit
+yarn test          # vitest
+yarn lint          # biome lint
+yarn run check     # biome check (lint + formatação)
+yarn check:fix     # biome check --write
+yarn release:local # npm publish (publica o source no npm; roda build antes via prepublishOnly)
+```
+
+## Versionamento e publicação
+
+Publicação automática no **npm** via `semantic-release` (ver `.releaserc.json`): a cada push na `main`, o CI roda typecheck/lint/test e publica a próxima versão derivada dos **Conventional Commits**, com changelog automático. Não edite a versão no `package.json` manualmente — o `semantic-release` a gerencia.

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@77sol-lab/form-schemas",
+  "version": "1.1.0",
+  "description": "Fonte central de schemas Zod da 77 (source-only). Financiamento (PF) é o primeiro domínio; consumido direto do código-fonte pelo backend e frontend.",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./financing/formalization": "./src/domains/financing/formalization/index.ts",
+    "./financing/formalization/schemas/*": "./src/domains/financing/formalization/schemas/*.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "yarn typecheck && yarn lint && yarn test",
+    "release:local": "npm publish",
+    "prepublishOnly": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome lint",
+    "lint:fix": "biome lint --write",
+    "format": "biome format --write",
+    "format:check": "biome format",
+    "check": "biome check",
+    "check:fix": "biome check --write",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "prepare": "husky"
+  },
+  "peerDependencies": {
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.15",
+    "@commitlint/cli": "^19.0.0",
+    "@commitlint/config-conventional": "^19.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^20.11.0",
+    "husky": "^9.0.0",
+    "semantic-release": "^23.0.0",
+    "typescript": "^5.4.0",
+    "vitepress": "^1.6.3",
+    "vitest": "^1.5.0",
+    "zod": "^3.23.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/domains/financing/enums/banks.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod'
+
+export const BANK_SLUGS = [
+  'credito77',
+  'losango',
+  'santander',
+  'btg',
+  'bv',
+  'banco-do-brasil',
+  'caixa-economica-federal',
+  'alfa',
+  'safra',
+  'cash_me_',
+  'hdt_energy',
+  'solfacil',
+  'sol_agora',
+  'eos',
+] as const
+
+export const BankEnum = z.enum(BANK_SLUGS)
+export type Bank = z.infer<typeof BankEnum>
+export type BankSlug = Bank

package/src/domains/financing/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './banks'
+export * from './occupation'

package/src/domains/financing/enums/occupation.ts

@@ -0,0 +1,2 @@
+// RN-012: ocupações que tornam "CNPJ do proprietário" obrigatório.
+export const OCCUPATIONS_REQUIRING_CNPJ = ['empresario', 'empresario_ou_proprietario'] as const

package/src/domains/financing/formalization/extras.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+import { fileUploadField, selectField } from '../../../shared/fields/primitives'
+
+const THIRD_PARTY_OPTIONS = [
+  'nao_se_aplica',
+  'conjuge',
+  'pai_mae',
+  'filho_filha',
+  'parente',
+  'outro',
+] as const
+
+export const formalizationExtras = {
+  energy_bill_upload: fileUploadField,
+  account_third_party: selectField(THIRD_PARTY_OPTIONS),
+  bond_document_upload: fileUploadField.optional(),
+  document_front_upload: fileUploadField,
+  document_back_upload: fileUploadField,
+  // RN-014: seguro RD/RE começa ON.
+  rd_re_insurance_toggle: z.boolean().default(true),
+}

package/src/domains/financing/formalization/index.ts

@@ -0,0 +1,18 @@
+export { NATIONALITY_BRAZIL } from '../../../shared/enums'
+export type { Bank, BankSlug } from '../enums'
+export { BANK_SLUGS, BankEnum, OCCUPATIONS_REQUIRING_CNPJ } from '../enums'
+export { applyPfRefinements, applyPjRefinements } from './refinements'
+export type { PersonType } from './registry'
+export {
+  getFormalizationBaseSchema,
+  getFormalizationSchema,
+  pfBaseSchemaRegistry,
+  pfSchemaRegistry,
+  pjBaseSchemaRegistry,
+  pjSchemaRegistry,
+} from './registry'
+export type {
+  FormalizationFieldKind,
+  FormalizationFieldMeta,
+} from './uiMeta'
+export { FORMALIZATION_FIELD_META } from './uiMeta'

package/src/domains/financing/formalization/refinements.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod'
+import { NATIONALITY_BRAZIL } from '../../../shared/enums'
+import { yearsSinceDMY } from '../../../shared/regex'
+import { OCCUPATIONS_REQUIRING_CNPJ } from '../enums'
+
+const RG_MAX_EMISSION_YEARS = 10
+
+function applyCommonRefinements(data: Record<string, unknown>, ctx: z.RefinementCtx): void {
+  // Documento de vínculo obrigatório se a conta está em nome de terceiro.
+  if (
+    'account_third_party' in data &&
+    typeof data.account_third_party === 'string' &&
+    data.account_third_party !== 'nao_se_aplica' &&
+    !data.bond_document_upload
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['bond_document_upload'],
+      message: 'Documento de vínculo é obrigatório quando a conta está em nome de terceiro',
+    })
+  }
+}
+
+export function applyPfRefinements(data: Record<string, unknown>, ctx: z.RefinementCtx): void {
+  applyCommonRefinements(data, ctx)
+
+  // RN-012: CNPJ do proprietário obrigatório se ocupação ∈ {empresário/proprietário}.
+  if (
+    'nature_of_occupation' in data &&
+    typeof data.nature_of_occupation === 'string' &&
+    (OCCUPATIONS_REQUIRING_CNPJ as readonly string[]).includes(data.nature_of_occupation) &&
+    !data.cnpj_proprietary
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['cnpj_proprietary'],
+      message: 'CNPJ do proprietário é obrigatório para esta ocupação',
+    })
+  }
+
+  // RN-011: RG aceito com no máximo 10 anos de emissão.
+  if (data.type_doc === 'rg' && typeof data.doc_issue_date === 'string') {
+    const years = yearsSinceDMY(data.doc_issue_date)
+    if (years !== null && years > RG_MAX_EMISSION_YEARS) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['doc_issue_date'],
+        message: `RG deve ter no máximo ${RG_MAX_EMISSION_YEARS} anos de emissão`,
+      })
+    }
+  }
+
+  // Nacionalidade ≠ Brasil → tipo de documento deve ser RNE (estrangeiro).
+  if (
+    typeof data.nationality === 'string' &&
+    data.nationality.toLowerCase() !== NATIONALITY_BRAZIL &&
+    'type_doc' in data &&
+    data.type_doc !== 'rne'
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['type_doc'],
+      message: 'Para nacionalidade estrangeira, o documento deve ser Registro de Estrangeiro (RNE)',
+    })
+  }
+}
+
+export function applyPjRefinements(data: Record<string, unknown>, ctx: z.RefinementCtx): void {
+  applyCommonRefinements(data, ctx)
+}

package/src/domains/financing/formalization/registry.ts

@@ -0,0 +1,153 @@
+import type { AnyZodObject, ZodTypeAny } from 'zod'
+import type { BankSlug } from '../enums'
+import { applyPfRefinements } from './refinements'
+import { alfaPfObject, alfaPfSchema } from './schemas/AlfaPFSchema'
+import { alfaPjObject, alfaPjSchema } from './schemas/AlfaPJSchema'
+import { bancoDoBrasilPfObject, bancoDoBrasilPfSchema } from './schemas/BancoDoBrasilPFSchema'
+import { bancoDoBrasilPjObject, bancoDoBrasilPjSchema } from './schemas/BancoDoBrasilPJSchema'
+import { btgPfObject, btgPfSchema } from './schemas/BtgPFSchema'
+import { btgPjObject, btgPjSchema } from './schemas/BtgPJSchema'
+import { bvPfObject, bvPfSchema } from './schemas/BvPFSchema'
+import { bvPjObject, bvPjSchema } from './schemas/BvPJSchema'
+import {
+  caixaEconomicaFederalPfObject,
+  caixaEconomicaFederalPfSchema,
+} from './schemas/CaixaEconomicaFederalPFSchema'
+import {
+  caixaEconomicaFederalPjObject,
+  caixaEconomicaFederalPjSchema,
+} from './schemas/CaixaEconomicaFederalPJSchema'
+import { cashMePfObject, cashMePfSchema } from './schemas/CashMePFSchema'
+import { cashMePjObject, cashMePjSchema } from './schemas/CashMePJSchema'
+import { credito77PfObject, credito77PfSchema } from './schemas/Credito77PFSchema'
+import { credito77PjObject, credito77PjSchema } from './schemas/Credito77PJSchema'
+import { eosPfObject, eosPfSchema } from './schemas/EosPFSchema'
+import { eosPjObject, eosPjSchema } from './schemas/EosPJSchema'
+import { hdtEnergyPfObject, hdtEnergyPfSchema } from './schemas/HdtEnergyPFSchema'
+import { hdtEnergyPjObject, hdtEnergyPjSchema } from './schemas/HdtEnergyPJSchema'
+import { losangoPfObject, losangoPfSchema } from './schemas/LosangoPFSchema'
+import { losangoPjObject, losangoPjSchema } from './schemas/LosangoPJSchema'
+import { safraPfObject, safraPfSchema } from './schemas/SafraPFSchema'
+import { safraPjObject, safraPjSchema } from './schemas/SafraPJSchema'
+import { santanderPfObject, santanderPfSchema } from './schemas/SantanderPFSchema'
+import { santanderPjObject, santanderPjSchema } from './schemas/SantanderPJSchema'
+import { solAgoraPfObject, solAgoraPfSchema } from './schemas/SolAgoraPFSchema'
+import { solAgoraPjObject, solAgoraPjSchema } from './schemas/SolAgoraPJSchema'
+import { solfacilPfObject, solfacilPfSchema } from './schemas/SolfacilPFSchema'
+import { solfacilPjObject, solfacilPjSchema } from './schemas/SolfacilPJSchema'
+
+export type PersonType = 'pf' | 'pj'
+
+export const pfSchemaRegistry = {
+  credito77: credito77PfSchema,
+  losango: losangoPfSchema,
+  santander: santanderPfSchema,
+  btg: btgPfSchema,
+  bv: bvPfSchema,
+  'banco-do-brasil': bancoDoBrasilPfSchema,
+  'caixa-economica-federal': caixaEconomicaFederalPfSchema,
+  alfa: alfaPfSchema,
+  safra: safraPfSchema,
+  cash_me_: cashMePfSchema,
+  hdt_energy: hdtEnergyPfSchema,
+  solfacil: solfacilPfSchema,
+  sol_agora: solAgoraPfSchema,
+  eos: eosPfSchema,
+} satisfies Record<BankSlug, ZodTypeAny>
+
+export const pjSchemaRegistry = {
+  credito77: credito77PjSchema,
+  losango: losangoPjSchema,
+  santander: santanderPjSchema,
+  btg: btgPjSchema,
+  bv: bvPjSchema,
+  'banco-do-brasil': bancoDoBrasilPjSchema,
+  'caixa-economica-federal': caixaEconomicaFederalPjSchema,
+  alfa: alfaPjSchema,
+  safra: safraPjSchema,
+  cash_me_: cashMePjSchema,
+  hdt_energy: hdtEnergyPjSchema,
+  solfacil: solfacilPjSchema,
+  sol_agora: solAgoraPjSchema,
+  eos: eosPjSchema,
+} satisfies Record<BankSlug, ZodTypeAny>
+
+export const pfBaseSchemaRegistry = {
+  credito77: credito77PfObject,
+  losango: losangoPfObject,
+  santander: santanderPfObject,
+  btg: btgPfObject,
+  bv: bvPfObject,
+  'banco-do-brasil': bancoDoBrasilPfObject,
+  'caixa-economica-federal': caixaEconomicaFederalPfObject,
+  alfa: alfaPfObject,
+  safra: safraPfObject,
+  cash_me_: cashMePfObject,
+  hdt_energy: hdtEnergyPfObject,
+  solfacil: solfacilPfObject,
+  sol_agora: solAgoraPfObject,
+  eos: eosPfObject,
+} satisfies Record<BankSlug, AnyZodObject>
+
+export const pjBaseSchemaRegistry = {
+  credito77: credito77PjObject,
+  losango: losangoPjObject,
+  santander: santanderPjObject,
+  btg: btgPjObject,
+  bv: bvPjObject,
+  'banco-do-brasil': bancoDoBrasilPjObject,
+  'caixa-economica-federal': caixaEconomicaFederalPjObject,
+  alfa: alfaPjObject,
+  safra: safraPjObject,
+  cash_me_: cashMePjObject,
+  hdt_energy: hdtEnergyPjObject,
+  solfacil: solfacilPjObject,
+  sol_agora: solAgoraPjObject,
+  eos: eosPjObject,
+} satisfies Record<BankSlug, AnyZodObject>
+
+export interface FormalizationSchemaOptions {
+  prestamistaIncluso?: boolean
+}
+
+const CREDITO77_PRESTAMISTA_FIELDS = {
+  doc: true,
+  issuing_body: true,
+  doc_issue_date: true,
+  sex: true,
+} as const
+
+function isCredito77WithoutPrestamista(
+  bank: BankSlug,
+  person: PersonType,
+  options: FormalizationSchemaOptions,
+): boolean {
+  return bank === 'credito77' && person === 'pf' && !options.prestamistaIncluso
+}
+
+export function getFormalizationSchema(
+  bank: BankSlug,
+  person: PersonType,
+  options: FormalizationSchemaOptions = {},
+) {
+  if (isCredito77WithoutPrestamista(bank, person, options)) {
+    return credito77PfObject
+      .omit(CREDITO77_PRESTAMISTA_FIELDS)
+      .strict()
+      .superRefine(applyPfRefinements)
+  }
+
+  return person === 'pf' ? pfSchemaRegistry[bank] : pjSchemaRegistry[bank]
+}
+
+export function getFormalizationBaseSchema(
+  bank: BankSlug,
+  person: PersonType,
+  options: FormalizationSchemaOptions = {},
+) {
+  if (isCredito77WithoutPrestamista(bank, person, options)) {
+    return credito77PfObject.omit(CREDITO77_PRESTAMISTA_FIELDS)
+  }
+
+  return person === 'pf' ? pfBaseSchemaRegistry[bank] : pjBaseSchemaRegistry[bank]
+}

package/src/domains/financing/formalization/schemas/AlfaPFSchema.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod'
+import { DocumentTypeEnum, SexEnum } from '../../../../shared/enums'
+import { textField } from '../../../../shared/fields/primitives'
+import {
+  birthDateSchema,
+  cepSchema,
+  cpfCnpjSchema,
+  cpfSchema,
+  currencySchema,
+  emailSchema,
+  issueDateSchema,
+  phoneBRSchema,
+} from '../../../../shared/regex'
+import { formalizationExtras } from '../extras'
+import { applyPfRefinements } from '../refinements'
+
+export const alfaPfObject = z.object({
+  ...formalizationExtras,
+  name: textField(),
+  cep: cepSchema,
+  cpf: cpfSchema,
+  address: textField(),
+  birth_date: birthDateSchema,
+  number: textField(),
+  sex: SexEnum,
+  complement: textField(15).optional(),
+  mother_name: textField(),
+  district: textField(),
+  energy_account_in_requester_name: textField(),
+  city: textField(),
+  energy_bill_owner_document: cpfCnpjSchema.optional(),
+  state: textField(2),
+  nationality: textField(),
+  cellphone: phoneBRSchema,
+  email: emailSchema,
+  monthly_income: currencySchema,
+  profession: textField(),
+  type_doc: DocumentTypeEnum,
+  doc: textField(15),
+  issuing_body: textField(6),
+  doc_issue_date: issueDateSchema,
+})
+
+export const alfaPfSchema = alfaPfObject.strict().superRefine(applyPfRefinements)
+
+export type AlfaPfFicha = z.infer<typeof alfaPfSchema>

package/src/domains/financing/formalization/schemas/AlfaPJSchema.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod'
+import { SexEnum } from '../../../../shared/enums'
+import { textField } from '../../../../shared/fields/primitives'
+import {
+  birthDateSchema,
+  cepSchema,
+  cnpjSchema,
+  cpfSchema,
+  currencySchema,
+  emailSchema,
+  issueDateSchema,
+  phoneBRSchema,
+} from '../../../../shared/regex'
+import { formalizationExtras } from '../extras'
+import { applyPjRefinements } from '../refinements'
+
+export const alfaPjObject = z.object({
+  ...formalizationExtras,
+  financing_company: z
+    .object({
+      corporate_name: textField(),
+      cep: cepSchema,
+      address: textField(),
+      foundation_date: issueDateSchema,
+      number: textField(),
+      cnpj: cnpjSchema,
+      email: emailSchema,
+      complement: textField(15).optional(),
+      phone: phoneBRSchema,
+      district: textField(),
+      legal_nature: textField(),
+      city: textField(),
+      economic_activity_group: textField(),
+      state: textField(2),
+      economic_activity: textField(),
+      monthly_income: currencySchema,
+    })
+    .strict(),
+  financing_company_guarantor: z.array(
+    z
+      .object({
+        name: textField(),
+        cep: cepSchema,
+        cpf: cpfSchema,
+        address: textField(),
+        birth_date: birthDateSchema,
+        number: textField(),
+        complement: textField(15).optional(),
+        cellphone: phoneBRSchema,
+        email: emailSchema,
+        district: textField(),
+        sex: SexEnum,
+        city: textField(),
+        state: textField(2),
+        office: textField(),
+        mother_name: textField(),
+        nationality: textField(),
+      })
+      .strict(),
+  ),
+})
+
+export const alfaPjSchema = alfaPjObject.strict().superRefine(applyPjRefinements)
+
+export type AlfaPjFicha = z.infer<typeof alfaPjSchema>