diff --git a/README.md b/README.md
index 724c3d6..444032b 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,62 @@
 # brado
-Bradova (BRAzilian DOcs validator) é um pacote Rust para validação de documentos brasileiros.
+<a href="https://crates.io/crates/brado">
+  <img src="https://img.shields.io/crates/v/brado.svg" alt="latest release" />
+</a>
+
+Brado (BRAzilian DOcs validator) é um pacote Rust para validação de documentos brasileiros.
 
 Este projeto é inspirado no [validate-docbr](https://github.com/alvarofpp/validate-docbr).
 
-# Contribuindo
+Para adicionar o pacote ao projeto:
+
+```bash
+cargo add brado
+```
+
+A documentação pode ser acessada [aqui](https://docs.rs/brado/) (ainda em desenvolvimento).
+
+
+## Testes
+
+Para rodar os testes, basta executar o comando a seguir:
+
+```
+make test
+```
+
+## Documentos
+
+- [x] CPF: Cadastro de Pessoas Físicas;
+- [x] CNH: Carteira Nacional de Habilitação;
+- [x] CNPJ: Cadastro Nacional da Pessoa Jurídica;
+- [ ] CNS: Cartão Nacional de Saúde;
+- [ ] PIS: PIS/NIS/PASEP/NIT;
+- [ ] Título eleitoral: Cadastro que permite cidadãos brasileiros votar;
+- [ ] RENAVAM: Registro Nacional de Veículos Automotores;
+- [ ] Certidão de Nascimento/Casamento/Óbito.
+
+
+## Funções
+
+Todos os documentos possuem as mesmas funções e funcionam da mesma forma.
+
+### validate
+
+```rust
+use brado;
+brado::cpf::validate("639.292.470-11"); // true
+brado::cpf::validate("639.292.470-10"); // false
+```
+
+### mask
+
+```rust
+use brado;
+brado::cpf::mask("63929247011"); // 639.292.470-11
+```
+
+
+# Como Contribuir
 
 1. Instalar nix (com flakes, ou seja, >2.4);
 2. Fazer um fork do projeto;
@@ -12,3 +65,4 @@ Este projeto é inspirado no [validate-docbr](https://github.com/alvarofpp/valid
 nix flake clone github:your-github-user/brado --dest ./brado \
 && cd brado 1>/dev/null 2>/dev/null \
 && direnv allow
+```
diff --git a/brado/Cargo.toml b/brado/Cargo.toml
index fe48864..8ac4d27 100644
--- a/brado/Cargo.toml
+++ b/brado/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "brado"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 readme = "../README.md"
diff --git a/brado/src/lib.rs b/brado/src/lib.rs
index 6745b6f..fc8e391 100644
--- a/brado/src/lib.rs
+++ b/brado/src/lib.rs
@@ -5,8 +5,7 @@
 //! ## Example
 //! ```
 //! use brado;
-//! let cpf_doc = String::from("639.292.470-11");
-//! brado::cpf::validate(&cpf_doc);
+//! brado::cpf::validate("639.292.470-11");
 //! ```
 pub mod cnh;
 pub mod cnpj;
diff --git a/brado/tests/cnh.rs b/brado/tests/cnh.rs
index 9ee317e..f1caf7b 100644
--- a/brado/tests/cnh.rs
+++ b/brado/tests/cnh.rs
@@ -4,81 +4,81 @@ mod cnh_tests {
 
     #[test]
     fn cnh_validate_1_valid_bare_cnh() {
-        let bare_cnh: String = String::from("84718735264");
-        assert_eq!(true, brado::cnh::validate(&bare_cnh));
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(true, brado::cnh::validate(bare_cnh));
     }
 
     #[test]
     fn cnh_validate_2_valid_masked_cnh() {
-        let masked_cnh: String = String::from("847 187 352 64");
-        assert_eq!(true, brado::cnh::validate(&masked_cnh));
+        let masked_cnh: &str = "847 187 352 64";
+        assert_eq!(true, brado::cnh::validate(masked_cnh));
     }
 
     #[test]
     fn cnh_validate_3_invalid_mask() {
-        let document = String::from("84 718 735 264");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "84 718 735 264";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_validate_4_invalid_other_document_1() {
-        let document = String::from("847187352");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "847187352";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_validate_5_invalid_other_document_2() {
-        let document = String::from("084 718 735 264");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "084 718 735 264";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_validate_6_invalid_other_document_3() {
-        let document = String::from("847 187 352 6:4");
-        assert_eq!(brado::cnh::validate(&document), false);
+        let document: &str = "847 187 352 6:4";
+        assert_eq!(brado::cnh::validate(document), false);
     }
 
     #[test]
     fn cnh_is_bare_1_bare_cnh() {
-        let bare_cnh = String::from("84718735264");
-        assert_eq!(brado::cnh::is_bare(&bare_cnh), true);
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(brado::cnh::is_bare(bare_cnh), true);
     }
 
     #[test]
     fn cnh_is_bare_2_masked_cnh() {
-        let masked_cnh = String::from("847 187 352 64");
-        assert_eq!(brado::cnh::is_bare(&masked_cnh), false);
+        let masked_cnh: &str = "847 187 352 64";
+        assert_eq!(brado::cnh::is_bare(masked_cnh), false);
     }
 
     #[test]
     fn cnh_is_masked_1_masked_cnh() {
-        let masked_cnh = String::from("847 187 352 64");
-        assert_eq!(brado::cnh::is_masked(&masked_cnh), true);
+        let masked_cnh: &str = "847 187 352 64";
+        assert_eq!(brado::cnh::is_masked(masked_cnh), true);
     }
 
     #[test]
     fn cnh_is_masked_2_bare_cnh() {
-        let bare_cnh = String::from("84718735264");
-        assert_eq!(brado::cnh::is_masked(&bare_cnh), false);
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(brado::cnh::is_masked(bare_cnh), false);
     }
 
     #[test]
     fn cnh_mask_1_bare_cnh() {
-        let bare_cnh = String::from("84718735264");
-        assert_eq!(brado::cnh::mask(&bare_cnh), String::from("847 187 352 64"),);
+        let bare_cnh: &str = "84718735264";
+        assert_eq!(brado::cnh::mask(bare_cnh), String::from("847 187 352 64"),);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNH")]
     fn cnh_mask_2_masked_cnh() {
-        let masked_cnh = String::from("847 187 352 64");
-        brado::cnh::mask(&masked_cnh);
+        let masked_cnh: &str = "847 187 352 64";
+        brado::cnh::mask(masked_cnh);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNH")]
     fn cnh_mask_3_invalid_cnh() {
-        let document = String::from("847187352");
-        brado::cnh::mask(&document);
+        let document: &str = "847187352";
+        brado::cnh::mask(document);
     }
 }
diff --git a/brado/tests/cnpj.rs b/brado/tests/cnpj.rs
index de17aa5..0ad02ed 100644
--- a/brado/tests/cnpj.rs
+++ b/brado/tests/cnpj.rs
@@ -4,69 +4,69 @@ mod cnpj_tests {
 
     #[test]
     fn cnpj_validate_1_valid_bare_cnpj() {
-        let bare_cnpj: String = String::from("05200851000100");
-        assert_eq!(true, brado::cnpj::validate(&bare_cnpj));
+        let bare_cnpj: &str = "05200851000100";
+        assert_eq!(true, brado::cnpj::validate(bare_cnpj));
     }
 
     #[test]
     fn cnpj_validate_2_valid_masked_cnpj() {
-        let masked_cnpj: String = String::from("05.200.851/0001-00");
-        assert_eq!(true, brado::cnpj::validate(&masked_cnpj));
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        assert_eq!(true, brado::cnpj::validate(masked_cnpj));
     }
 
     #[test]
     fn cnpj_validate_3_invalid_mask() {
-        let document = String::from("0.520.085/1000-100");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "0.520.085/1000-100";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_validate_4_invalid_other_document_1() {
-        let document = String::from("052008510001");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "052008510001";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_validate_5_invalid_other_document_2() {
-        let document = String::from("00.520.085/1000-100");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "00.520.085/1000-100";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_validate_6_invalid_other_document_3() {
-        let document = String::from("05.200.851/0001-0:0");
-        assert_eq!(brado::cnpj::validate(&document), false);
+        let document: &str = "05.200.851/0001-0:0";
+        assert_eq!(brado::cnpj::validate(document), false);
     }
 
     #[test]
     fn cnpj_is_bare_1_bare_cnpj() {
-        let bare_cnpj = String::from("05200851000100");
-        assert_eq!(brado::cnpj::is_bare(&bare_cnpj), true);
+        let bare_cnpj: &str = "05200851000100";
+        assert_eq!(brado::cnpj::is_bare(bare_cnpj), true);
     }
 
     #[test]
     fn cnpj_is_bare_2_masked_cnpj() {
-        let masked_cnpj = String::from("05.200.851/0001-00");
-        assert_eq!(brado::cnpj::is_bare(&masked_cnpj), false);
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        assert_eq!(brado::cnpj::is_bare(masked_cnpj), false);
     }
 
     #[test]
     fn cnpj_is_masked_1_masked_cnpj() {
-        let masked_cnpj = String::from("05.200.851/0001-00");
-        assert_eq!(brado::cnpj::is_masked(&masked_cnpj), true);
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        assert_eq!(brado::cnpj::is_masked(masked_cnpj), true);
     }
 
     #[test]
     fn cnpj_is_masked_2_bare_cnpj() {
-        let bare_cnpj = String::from("05200851000100");
-        assert_eq!(brado::cnpj::is_masked(&bare_cnpj), false);
+        let bare_cnpj: &str = "05200851000100";
+        assert_eq!(brado::cnpj::is_masked(bare_cnpj), false);
     }
 
     #[test]
     fn cnpj_mask_1_bare_cnpj() {
-        let bare_cnpj = String::from("05200851000100");
+        let bare_cnpj: &str = "05200851000100";
         assert_eq!(
-            brado::cnpj::mask(&bare_cnpj),
+            brado::cnpj::mask(bare_cnpj),
             String::from("05.200.851/0001-00"),
         );
     }
@@ -74,14 +74,14 @@ mod cnpj_tests {
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNPJ")]
     fn cnpj_mask_2_masked_cnpj() {
-        let masked_cnpj = String::from("05.200.851/0001-00");
-        brado::cnpj::mask(&masked_cnpj);
+        let masked_cnpj: &str = "05.200.851/0001-00";
+        brado::cnpj::mask(masked_cnpj);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CNPJ")]
     fn cnpj_mask_3_invalid_cnpj() {
-        let document = String::from("052008510001");
-        brado::cnpj::mask(&document);
+        let document: &str = "052008510001";
+        brado::cnpj::mask(document);
     }
 }
diff --git a/brado/tests/cpf.rs b/brado/tests/cpf.rs
index d79ed6f..17a092b 100644
--- a/brado/tests/cpf.rs
+++ b/brado/tests/cpf.rs
@@ -4,14 +4,14 @@ mod cpf_tests {
 
     #[test]
     fn cpf_validate_1_valid_bare_cpf() {
-        let bare_cpf = String::from("63929247011");
-        assert_eq!(brado::cpf::validate(&bare_cpf), true);
+        let bare_cpf: &str = "63929247011";
+        assert_eq!(brado::cpf::validate(bare_cpf), true);
     }
 
     #[test]
     fn cpf_validate_2_valid_masked_cpf() {
-        let masked_cpf = String::from("639.292.470-11");
-        assert_eq!(brado::cpf::validate(&masked_cpf), true);
+        let masked_cpf: &str = "639.292.470-11";
+        assert_eq!(brado::cpf::validate(masked_cpf), true);
     }
 
     #[test]
@@ -24,69 +24,69 @@ mod cpf_tests {
 
     #[test]
     fn cpf_validate_4_invalid_mask() {
-        let document = String::from("63.929.247-011");
-        assert_eq!(brado::cpf::validate(&document), false);
+        let document: &str = "63.929.247-011";
+        assert_eq!(brado::cpf::validate(document), false);
     }
 
     #[test]
     fn cpf_validate_5_invalid_other_document_1() {
-        let document = String::from("639292470");
-        assert_eq!(brado::cpf::validate(&document), false);
+        let document: &str = "639292470";
+        assert_eq!(brado::cpf::validate(document), false);
     }
 
     #[test]
     fn cpf_validate_6_invalid_other_document_2() {
-        let document = String::from("063.929.247-011");
-        assert_eq!(brado::cpf::validate(&document), false);
+        let document: &str = "063.929.247-011";
+        assert_eq!(brado::cpf::validate(document), false);
     }
 
     #[test]
     fn cpf_validate_7_invalid_other_document_3() {
-        let document = String::from("639.292.470-1:1");
-        assert_eq!(brado::cpf::validate(&document), false);
+        let document: &str = "639.292.470-1:1";
+        assert_eq!(brado::cpf::validate(document), false);
     }
 
     #[test]
     fn cpf_is_bare_1_bare_cpf() {
-        let bare_cpf = String::from("63929247011");
-        assert_eq!(brado::cpf::is_bare(&bare_cpf), true);
+        let bare_cpf: &str = "63929247011";
+        assert_eq!(brado::cpf::is_bare(bare_cpf), true);
     }
 
     #[test]
     fn cpf_is_bare_2_masked_cpf() {
-        let masked_cpf = String::from("639.292.470-11");
-        assert_eq!(brado::cpf::is_bare(&masked_cpf), false);
+        let masked_cpf: &str = "639.292.470-11";
+        assert_eq!(brado::cpf::is_bare(masked_cpf), false);
     }
 
     #[test]
     fn cpf_is_masked_1_masked_cpf() {
-        let masked_cpf = String::from("639.292.470-11");
-        assert_eq!(brado::cpf::is_masked(&masked_cpf), true);
+        let masked_cpf: &str = "639.292.470-11";
+        assert_eq!(brado::cpf::is_masked(masked_cpf), true);
     }
 
     #[test]
     fn cpf_is_masked_2_bare_cpf() {
-        let bare_cpf = String::from("63929247011");
-        assert_eq!(brado::cpf::is_masked(&bare_cpf), false);
+        let bare_cpf: &str = "63929247011";
+        assert_eq!(brado::cpf::is_masked(bare_cpf), false);
     }
 
     #[test]
     fn cpf_mask_1_bare_cpf() {
-        let bare_cpf = String::from("63929247011");
-        assert_eq!(brado::cpf::mask(&bare_cpf), String::from("639.292.470-11"),);
+        let bare_cpf: &str = "63929247011";
+        assert_eq!(brado::cpf::mask(bare_cpf), String::from("639.292.470-11"),);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CPF")]
     fn cpf_mask_2_masked_cpf() {
-        let masked_cpf = String::from("639.292.470-11");
-        brado::cpf::mask(&masked_cpf);
+        let masked_cpf: &str = "639.292.470-11";
+        brado::cpf::mask(masked_cpf);
     }
 
     #[test]
     #[should_panic(expected = "The given string cannot be masked as CPF")]
     fn cpf_mask_3_invalid_cpf() {
-        let document = String::from("639292470");
-        brado::cpf::mask(&document);
+        let document: &str = "639292470";
+        brado::cpf::mask(document);
     }
 }
diff --git a/brado/tests/docs.rs b/brado/tests/docs.rs
index e8c8363..faac695 100644
--- a/brado/tests/docs.rs
+++ b/brado/tests/docs.rs
@@ -6,59 +6,59 @@ mod docs_tests {
 
     #[test]
     fn docs_is_cpf_cpf() {
-        let cpf: String = String::from("63929247011");
-        assert_eq!(brado::docs::is_cpf(&cpf), true);
+        let cpf: &str = "63929247011";
+        assert_eq!(brado::docs::is_cpf(cpf), true);
     }
 
     #[test]
     fn docs_is_cpf_cnpj() {
-        let cnpj: String = String::from("05200851000100");
-        assert_eq!(brado::docs::is_cpf(&cnpj), false);
+        let cnpj: &str = "05200851000100";
+        assert_eq!(brado::docs::is_cpf(cnpj), false);
     }
 
     #[test]
     fn docs_is_cpf_cnh() {
-        let cnh: String = String::from("84718735264");
-        assert_eq!(brado::docs::is_cpf(&cnh), false);
+        let cnh: &str = "84718735264";
+        assert_eq!(brado::docs::is_cpf(cnh), false);
     }
 
     /* CNPJ */
 
     #[test]
     fn docs_is_cnpj_cnpj() {
-        let cnpj: String = String::from("05200851000100");
-        assert_eq!(brado::docs::is_cnpj(&cnpj), true);
+        let cnpj: &str = "05200851000100";
+        assert_eq!(brado::docs::is_cnpj(cnpj), true);
     }
 
     #[test]
     fn docs_is_cnpj_cpf() {
-        let cpf: String = String::from("63929247011");
-        assert_eq!(brado::docs::is_cnpj(&cpf), false);
+        let cpf: &str = "63929247011";
+        assert_eq!(brado::docs::is_cnpj(cpf), false);
     }
 
     #[test]
     fn docs_is_cnpj_cnh() {
-        let cnh: String = String::from("84718735264");
-        assert_eq!(brado::docs::is_cnpj(&cnh), false);
+        let cnh: &str = "84718735264";
+        assert_eq!(brado::docs::is_cnpj(cnh), false);
     }
 
     /* CNH */
 
     #[test]
     fn docs_is_cnh_cnh() {
-        let cnh: String = String::from("84718735264");
-        assert_eq!(brado::docs::is_cnh(&cnh), true);
+        let cnh: &str = "84718735264";
+        assert_eq!(brado::docs::is_cnh(cnh), true);
     }
 
     #[test]
     fn docs_is_cnh_cpf() {
-        let cpf: String = String::from("63929247011");
-        assert_eq!(brado::docs::is_cnh(&cpf), true);
+        let cpf: &str = "63929247011";
+        assert_eq!(brado::docs::is_cnh(cpf), true);
     }
 
     #[test]
     fn docs_is_cnh_cnpj() {
-        let cnpj: String = String::from("05200851000100");
-        assert_eq!(brado::docs::is_cnh(&cnpj), false);
+        let cnpj: &str = "05200851000100";
+        assert_eq!(brado::docs::is_cnh(cnpj), false);
     }
 }