validation-br 1.5.2 → 2.0.0-next-2

package/test/pix-copy-paste.spec.ts

@@ -0,0 +1,37 @@
+// pix usado pelo 10 pila.
+
+import { PixCopyPaste } from '../src/pix-copy-paste';
+
+// esse pix é um pix automatico
+const pixStone = `00020101021226820014br.gov.bcb.pix2560pix.stone.com.br/pix/v2/b411f5c8-e97f-4a18-af0e-fc66491748d7520400005303986540510.005802BR5925DIOGO DA SILVA SANTOS LTD6014RIO DE JANEIRO622905251e3afd7926983f8ffe086cdc16304FF60`;
+const pixManual = `00020126550014BR.GOV.BCB.PIX0123alexandrepato@gmail.com0206almoco5204000053039865406100.005802BR5914Alexandre Pato6009Ipanguacu61085950800062490511PIXJS76657250300017BR.GOV.BCB.BRCODE01051.0.0630455CF`;
+
+const cases = [
+  pixStone, 
+  pixManual
+]
+
+
+describe('PixCopyPaste', () => {
+  describe('constructor', () => {
+    test.each(cases)('deve estar definido', (input) => {
+      const pix = new PixCopyPaste(input);
+      expect(pix).toBeDefined();
+    });
+    
+    test('deve lançar um erro ao injetar um caractere na terceira posição', () => {
+      const copyPaste = pixStone.slice(0, 4) + 'D' + pixStone.slice(4);
+      expect(()=>new PixCopyPaste(copyPaste)).toThrow()
+    });
+  });
+
+  describe('parse', () => {
+    test.each(cases)('testa o parse', (input) => {
+      const parse = PixCopyPaste.parse(input);
+      
+      expect(parse).toBeDefined();
+      expect(Array.isArray(parse)).toBeTruthy();
+    });
+  });
+});
+

package/test/pix-key.spec.ts

@@ -0,0 +1,41 @@
+import { PixKey, PixKeys } from '../src/pix-key';
+
+describe('Pix', () => {
+  describe('constructor', () => {
+    test('deve estar definido do tipo e-mail', () => {
+      const key = new PixKey('klawdyo@gmail.com');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.email);
+    });
+
+    test('deve estar definido do tipo cpf', () => {
+      const key = new PixKey('004.129.620-63');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.cpf);
+    });
+
+    test('deve estar definido do tipo cnpj', () => {
+      const key = new PixKey('41356581000186');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.cnpj);
+    });
+
+    test('deve estar definido do tipo aleatória', () => {
+      const key = new PixKey('01234567-0123-4567-8901-234567890123');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.evp);
+    });
+
+    test('deve estar definido do tipo phone', () => {
+      const key = new PixKey('+5584987654321');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.phone);
+    });
+
+    test('deve falhar ao receber um telefone inválido', () => {
+      expect(() => new PixKey('+55849876')).toThrow()
+    });
+
+
+  });
+});

package/test/postal-track-code.test.ts

@@ -0,0 +1,83 @@
+import { PostalTrackCode } from '../src/postal-track-code';
+
+describe('PostalTrackCode', () => {
+  describe('constructor', () => {
+    test.each([
+      'PN718252423BR',
+      'PO925539762BR',
+      'JT194690698BR',
+      'SV143851674BR',
+      'RG727348650CN',
+      'RY747622885CN',
+      'RY728187035CN',
+      'RH940629235CN',
+      'RY686586175CN',
+      'RY648001205CN',
+      'UJ776469464CN',
+      'LZ667841882CN',
+      'RS737783818NL',
+    ])('%s deve estar definido', (input) => {
+      expect(new PostalTrackCode(input)).toBeDefined();
+    });
+
+    test.each([
+      'PO925524762BR', // dv inválido
+      'JT194624698BR', // dv inválido
+      'SV143824674BR', // dv inválido
+      'RG727324650CN', // dv inválido
+      'RY747624885CN', // dv inválido
+      'RY728114035CN', // dv inválido
+      'RY728114035', // sem letras no final
+      'RY728114035N', // 1 letra no final
+      'RS737783818NLL', // 3 letras no final
+      '737783818NL', // sem letra no começo
+      'S737783818NL', // só 1 letra no começo
+      'ARS737783818NL', // 3 letras no começo
+      'RS73778381NL', // numero a menos
+      null,
+      undefined,
+    ])('%s deve lançar erro', (input) => {
+      expect(() => new PostalTrackCode(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: 'pn718252423br', expected: 'PN718252423BR' },
+      { num: 'po925539762br', expected: 'PO925539762BR' },
+      { num: 'jt194690698br', expected: 'JT194690698BR' },
+    ])('Deve aplicar a máscara corretamente', (item) => {
+      const masked = new PostalTrackCode(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^[A-Z]{2}\d{9}[A-Z]{2}$/);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('deve gerar fakes válidos', () => {
+      const result = PostalTrackCode.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '71825242', expected: '3' },
+      { num: '92553976', expected: '2' },
+      { num: '19469069', expected: '8' },
+    ])('Deve calcular o Dv corretamente', (item) => {
+      const calcDv = PostalTrackCode.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+    test.each(['PN718252423BR', '925539762BR', 'JT194690698'])(
+      'Deve lançar erro',
+      (item) => {
+        expect(() => PostalTrackCode.checksum(item)).toThrow();
+      }
+    );
+  });
+});

package/test/renavam.spec.ts

@@ -0,0 +1,71 @@
+import { Renavam } from '../src/renavam';
+
+describe('Renavam', () => {
+  describe('constructor', () => {
+    test.each([
+      '1952519770-3',
+      '3394038959-9',
+      '03607626105',
+      '64090416160',
+      '80499688374',
+      '40650543741',
+    ])('deve estar definido', (input) => {
+      expect(new Renavam(input)).toBeDefined();
+    });
+
+    test.each([
+      '19525227703',
+      '33940229599',
+      '03607226105',
+      '64090226160',
+      '80499228374',
+      '', // vazio
+      '012345678900', // caracteres a mais
+      '12345678', // caracteres a menos
+      null,
+      undefined,
+    ])('deve lançar erro', (input) => {
+      expect(() => new Renavam(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '03607626105', expected: '0360762610-5' },
+      { num: '64090416160', expected: '6409041616-0' },
+      { num: '80499688374', expected: '8049968837-4' },
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+      const masked = new Renavam(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^\d{10}-\d{1}$/);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+      const result = Renavam.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '1952519770', expected: '3' },
+      { num: '0952519770', expected: '6' },
+      { num: '0052519770', expected: '2' },
+    ])('Deve gerar o dv correto', (item) => {
+      const calcDv = Renavam.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+    test.each(['00525197701', '0052519770-1', '005251977'])(
+      'deve lançar erro de dv',
+      (item) => {
+        expect(() => Renavam.checksum(item)).toThrow();
+      }
+    );
+  });
+});

package/test/tituloEleitor.spec.ts

@@ -0,0 +1,72 @@
+import { TituloEleitor } from "../src/tituloEleitor";
+
+describe('TituloEleitor', () => {
+  describe('constructor', () => {
+    test.each([
+     // masked
+     '1023.8501.0671',
+     '8365.7137.1619',
+     // string
+     '153036161686',
+     '525028881694',
+     // integer
+     '011122223360',
+     '001122223336',
+    ])('deve estar definido', (input) => {
+      expect(new TituloEleitor(input)).toBeDefined();
+    });
+
+    test.each([
+      '836531371619',
+      '743620641660',
+      '153016161686',
+      '525078881694',
+      '026367681660',
+      '558647441635',
+      '222222222222',
+      '', // vazio
+      '012345678900', // caracteres a mais
+      '12345678', // caracteres a menos
+      null,
+      undefined,
+    ])('deve lançar erro', (input) => {
+      expect(() => new TituloEleitor(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '102385010671', expected: '1023.8501.0671' },
+      { num: '836571371619', expected: '8365.7137.1619' },
+      { num: '743650641660', expected: '7436.5064.1660' },
+      { num: '011122223360', expected: '0111.2222.3360' },
+      { num: '001122223336', expected: '0011.2222.3336' },
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {    
+      const masked = new TituloEleitor(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^\d{4}.\d{4}.\d{4}$/)
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+      const result = TituloEleitor.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '1023850106', expected: '71' },
+      { num: '8365713716', expected: '19' },
+      { num: '7436506416', expected: '60' },
+      { num: '0011222233', expected: '36' },
+    ])('dv() - Verificando se o DV gerado está correto', (item) => {
+      const calcDv = TituloEleitor.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+  });
+});

package/test/utils-checkRepeatedSequence.test.ts

@@ -0,0 +1,17 @@
+import { checkRepeatedSequence } from "../src/utils"
+
+test.each([
+  '11111111',
+  '1111',
+])('testa se %s tem todos os valores iguais', (value) => {
+  expect(checkRepeatedSequence(value)).toBeTruthy()
+})
+
+test.each([
+  '12345678',
+  '11111112',
+  '1234',
+  '2111',
+])('testa se %s não tem todos os valores iguais', (value) => {
+  expect(checkRepeatedSequence(value)).toBeFalsy()
+})

package/test/utils-clearValue.test.ts

@@ -0,0 +1,85 @@
+import { clearValue } from '../src/utils'
+
+describe('clearValue()', () => {
+  test('Deve limpar o valor - Strings do Mesmo tamanho', () => {
+    //
+    const valid = [
+      { value: 1234567890, size: 10, expected: '1234567890' },
+      { value: '1234567890', size: 10, expected: '1234567890' },
+      { value: '12.345.678-90', size: 10, expected: '1234567890' },
+    ]
+
+    valid.forEach((item) => {
+      expect(clearValue(item.value, item.size)).toBe(item.expected)
+    })
+  })
+
+  test('Deve limpar os caracteres não numéricos sem verificar o tamanho da string', () => {
+    //
+    const valid = [
+      { value: 1234567890123, size: null, expected: '1234567890123' },
+      { value: '4567890', size: null, expected: '4567890' },
+      { value: '345.678-90', size: null, expected: '34567890' },
+    ]
+
+    valid.forEach((item) => {
+      expect(clearValue(item.value, item.size)).toBe(item.expected)
+    })
+  })
+
+  test('Deve limpar o valor os caracteres não numéricos e completar com zeros à esquerda', () => {
+    //
+    const valid = [
+      { value: 1234, size: 10, expected: '0000001234' },
+      { value: '1234', size: 10, expected: '0000001234' },
+      { value: '123-4', size: 10, expected: '0000001234' },
+    ]
+
+    valid.forEach((item) => {
+      expect(clearValue(item.value, item.size, { fillZerosAtLeft: true })).toBe(item.expected)
+    })
+
+    // Não completa com zeros
+    expect(clearValue(1234, 6, { fillZerosAtLeft: false })).toBe('1234')
+    expect(clearValue('1234', 6, { fillZerosAtLeft: false })).toBe('1234')
+  })
+
+  test('Deve limpar o valor os caracteres não numéricos e remover os caracteres que passarem de size', () => {
+    //
+    const valid = [
+      { value: 123456789, size: 4, expected: '1234' },
+      { value: '1234567890', size: 4, expected: '1234' },
+      { value: '12.345.678-90', size: 4, expected: '1234' },
+    ]
+
+    valid.forEach((item) => {
+      expect(clearValue(item.value, item.size, { trimAtRight: true })).toBe(item.expected)
+    })
+
+    // Não corta à direita
+    expect(clearValue(12345678, 6, { trimAtRight: false })).toBe('12345678')
+    expect(clearValue('12345678', 6, { trimAtRight: false })).toBe('12345678')
+  })
+
+  test('Deve retornar erro se receber um valor vazio', () => {
+    expect(clearValue('1112', 4, { rejectEmpty: true })).toBe('1112')
+    expect(() => clearValue('', null, { rejectEmpty: true })).toThrow()
+  })
+
+  test('Deve retornar erro se receber uma sequência de números iguais', () => {
+    expect(clearValue('1112', 4, { rejectEqualSequence: true })).toBe('1112')
+    expect(() => clearValue('1111', 4, { rejectEqualSequence: true })).toThrow()
+  })
+
+  test('Deve retornar erro se receber um valor com mais caracteres que o máximo', () => {
+    expect(clearValue('1234', 4, { rejectIfLonger: true })).toBe('1234')
+    expect(() => clearValue('12345', 4, { rejectIfLonger: true })).toThrow()
+  })
+
+  test('Deve retornar o mesmo valor inicial', () => {
+    expect(clearValue(1234, 4)).toBe('1234')
+    expect(clearValue('1234', 4)).toBe('1234')
+    expect(clearValue(1234, 4, {})).toBe('1234')
+    expect(clearValue('1234', 4, {})).toBe('1234')
+  })
+})

package/test/utils-insertAtPosition.test.ts

@@ -0,0 +1,15 @@
+import { insertAtPosition } from '../src/utils'
+
+describe('insertAtPosition()', () => {
+  test('Deve inserir um caractere em uma determinada posição da string', () => {
+    //
+    const list = [
+      { value: 'AAABBB', insert: 'C', position: 3, expected: 'AAACBBB' },
+      { value: 'J Med', insert: 'Cl ', position: 2, expected: 'J Cl Med' },
+    ]
+
+    list.forEach((item) => {
+      expect(insertAtPosition(item.value, item.insert, item.position)).toBe(item.expected)
+    })
+  })
+})

package/test/utils-removeFromPosition.test.ts

@@ -0,0 +1,15 @@
+import { removeFromPosition } from '../src/utils'
+
+describe('removeFromPosition()', () => {
+  test('', () => {
+    //
+    const list = [
+      { value: 'Jossé', start: 2, end: 3, expected: 'José' },
+      { value: 'Cláuudio', start: 4, end: 5, expected: 'Cláudio' },
+    ]
+
+    list.forEach((item) => {
+      expect(removeFromPosition(item.value, item.start, item.end)).toBe(item.expected)
+    })
+  })
+})

package/test/utils-sumElementsByMultipliers.test.ts

@@ -0,0 +1,24 @@
+import { sumElementsByMultipliers } from '../src/utils'
+
+describe('sumElementsByMultipliers()', () => {
+  test('Tipo do retorno', () => {
+    const sum = sumElementsByMultipliers('1234', [9, 8, 7, 6])
+
+    expect(typeof sum).toBe('number')
+    expect(sum).toBe(70)
+  })
+
+  test.each([
+    { input: '1234', multipliers: [9, 8, 7, 6], expected: 70 },
+    // cnpj
+    { input: '112223330001', multipliers: [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2], expected: 102 },
+    // cpf
+    { input: '280012389', multipliers: [10, 9, 8, 7, 6, 5, 4, 3, 2], expected: 162 },
+    { input: '2800123893', multipliers: [11, 10, 9, 8, 7, 6, 5, 4, 3, 2], expected: 201 },
+    // titulo
+  ])('Valores retornados', (item) => {
+    const sum = sumElementsByMultipliers(item.input, item.multipliers)
+    expect(sum).toBe(item.expected)
+
+  })
+})

package/test/utils-sumToDV.test.ts

@@ -0,0 +1,16 @@
+import { sumToDV } from '../src/utils'
+
+describe('sumToDV()', () => {
+  test('Os resultados devem ser os esperados', () => {
+    const list = [
+      { value: 102, expected: 8 },
+      { value: 120, expected: 1 },
+      { value: 162, expected: 3 },
+      { value: 179, expected: 8 },
+    ]
+
+    list.forEach((item) => {
+      expect(sumToDV(item.value)).toBe(item.expected)
+    })
+  })
+})

package/todo.md

@@ -0,0 +1,32 @@
+- [x] isCarPlate
+
+- [x] isPhone
+
+  - https://github.com/VitorLuizC/brazilian-values/blob/master/src/validators/isPhone.ts
+  - https://github.com/VitorLuizC/brazilian-values/blob/master/src/validators/isDDD.ts
+
+- ~~[ ] Conta bancária~~
+
+- [x] isPixKey - verifica se é um dos tipos de chaves
+
+- [x] isPixCopyPaste - verifica se é um dos tipos de chaves
+
+
+- [x] isCEP
+  - https://github.com/ogilvieira/validator-brasil/blob/main/src/isCEP.ts
+  - @klawdyo/qrdapio
+
+- [x] isUF
+  - @klawdyo/qrdapio
+
+- isBoleto
+  - Construtor pode receber linha digitável
+  - Pra receber o código de barras, use o static fromBarcode()
+  - mask() pode devolver a linha digitável ou o código de barras. Por padrão, a linha digitável
+  - toString() devolve a linha digitável
+  - toBarcode() devolve a linha digitável
+  - parse() é chamado no início e já separa as partes
+
+- [ ] isCAEPF
+  - https://www.gov.br/receitafederal/pt-br/assuntos/orientacao-tributaria/cadastros/caepf/legislacao
+  - https://github.com/VitorLuizC/brazilian-values/blob/master/src/validators/isCAEPF.ts

package/tsconfig.json

@@ -1,25 +1,105 @@
 {
   "compilerOptions": {
-    "baseUrl": "src",
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "target": "ES2018",
-    "moduleResolution": "node",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "declaration": true,
-    "noImplicitAny": true,
-    "noImplicitReturns": true,
-    "noImplicitThis": true,
-    "strict": true,
-    "allowJs": true,
-    "types": ["node", "jest"],
-    "typeRoots": ["node_modules/@types", "index.d.ts"],
-    "lib": ["ES2018"],
-    "paths": {
-      "*": ["node_modules/*"]
-    }
-  },
-  "exclude": ["./tsconfig.json"],
-  "include": ["./src/**/*"]
-}
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+    /* Projects */
+    "incremental": true, /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+    /* Language and Environment */
+    "target": "ES2022", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+    /* Modules */
+    "module": "commonjs", /* Specify what module code is generated. */
+    // "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    "rootDirs": [
+      "./src",
+      "./test",
+    ], /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+    /* Emit */
+    "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declarationMap": true, /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    "sourceMap": true, /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist", /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
+    /* Type Checking */
+    "strict": true, /* Enable all strict type-checking options. */
+    "noImplicitAny": true, /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    "strictNullChecks": true, /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    "noImplicitReturns": true, /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  }
+}