update docs to reflect changes requested on review

also added the docs in the spanish doc

@@ -162,13 +162,13 @@ Get.create<S>(
 
 
 ### Diferences between methods:
 ### Diferences between methods:
 
 
-We will talk about the variables `_factory` and `_singl`. Both are essential in the process of creating
- and using our dependencies, because is by it that we can store, dele and recreate the instances.
-
 First, let's of the `fenix` of Get.lazyPut and the `permanent` of the other methods.
 First, let's of the `fenix` of Get.lazyPut and the `permanent` of the other methods.
 
 
 The fundamental difference between `permanent` and `fenix` is how you want to store your instances.
 The fundamental difference between `permanent` and `fenix` is how you want to store your instances.
-Reinforcing: by default, GetX deletes instances when they are not is use (let's say screen 1 has controller 1 and screen 2 has controller 2. When you move from screen 1 to screen 2, the controller 1 lost its use so it is erased), but if you want to opt to `permanent:true`, then the controller will not be lost in this transition - which is very usefult for services that you want to keep alive thoughout the entire application. `fenix` in the other hand is for services that you don't worry in losing between screen changes, but when you need that service, you expect that it is alive. So basically, it will dispose the unused controller/service/class, but when you need that, it will "recreate from the ashes" a new instance.
+Reinforcing: by default, GetX deletes instances when they are not is use.
+It means that: If screen 1 has controller 1 and screen 2 has controller 2 and you remove the first route from stack, (like if you use `Get.off()` or `Get.offName()`) the controller 1 lost it's use so it will be erased.
+But if you want to opt to `permanent:true`, then the controller will not be lost in this transition - which is very usefult for services that you want to keep alive thoughout the entire application.
+`fenix` in the other hand is for services that you don't worry in losing between screen changes, but when you need that service, you expect that it is alive. So basically, it will dispose the unused controller/service/class, but when you need that, it will "recreate from the ashes" a new instance.
 
 
 Proceeding with the differences between methods: 
 Proceeding with the differences between methods: 
 
 

@@ -69,11 +69,11 @@ Para eliminar una instancia de GetX:
 Get.delete<Controller>();
 Get.delete<Controller>();
 ```
 ```
 
 
-## Options
+## Instancing methods
 
 
-When you use Get.put, lazyPut and putAsync you will have some options that you can change if you want
+Although Getx already delivers very good settings for use, it is possible to refine them even more so that it become more useful to the programmer. The methods and it's configurable parameters are:
 
 
-- On Get.put():
+- Get.put():
 
 
 ```dart
 ```dart
 Get.put<S>(
 Get.put<S>(
@@ -103,7 +103,7 @@ Get.put<S>(
 )
 )
 ```
 ```
 
 
-- On Get.lazyPut:
+- Get.lazyPut:
 
 
 ```dart
 ```dart
 Get.lazyPut<S>(
 Get.lazyPut<S>(
@@ -124,7 +124,7 @@ Get.lazyPut<S>(
 )
 )
 ```
 ```
 
 
-- On Get.putAsync:
+- Get.putAsync:
 
 
 ```dart
 ```dart
 Get.putAsync<S>(
 Get.putAsync<S>(
@@ -142,6 +142,44 @@ Get.putAsync<S>(
   bool permanent = false
   bool permanent = false
 ```
 ```
 
 
+- Get.create:
+
+```dart
+Get.create<S>(
+  // required: a function that returns a class that will be "fabricated" every
+  // time `Get.find()` is called
+  // Example: Get.create<YourClass>(() => YourClass())
+  FcBuilderFunc<S> builder,
+  // optional: just like Get.put(), but it is used when you need multiple instances
+  // of a of a same class
+  // Useful in case you have a list that each item need it's own controller
+  // needs to be a unique string. Just change from tag to name
+  String name,
+  // optional: just like int`Get.put()`, it is for when you need to keep the
+  // instance alive thoughout the entire app. The difference is in Get.create
+  // permanent is true by default
+  bool permanent = true
+```
+
+### Diferences between methods:
+
+First, let's of the `fenix` of Get.lazyPut and the `permanent` of the other methods.
+
+The fundamental difference between `permanent` and `fenix` is how you want to store your instances.
+Reinforcing: by default, GetX deletes instances when they are not is use.
+It means that: If screen 1 has controller 1 and screen 2 has controller 2 and you remove the first route from stack, (like if you use `Get.off()` or `Get.offName()`) the controller 1 lost it's use so it will be erased.
+But if you want to opt to `permanent:true`, then the controller will not be lost in this transition - which is very usefult for services that you want to keep alive thoughout the entire application.
+`fenix` in the other hand is for services that you don't worry in losing between screen changes, but when you need that service, you expect that it is alive. So basically, it will dispose the unused controller/service/class, but when you need that, it will "recreate from the ashes" a new instance.
+
+Proceeding with the differences between methods: 
+
+- Get.put and Get.putAsync follow the same creation order, with the difference that asyn opt for applying a asynchronous method: those two methods create and initialize the instance. That one is inserted directly in the memory, using the internal method `insert` with the parameters `permanent: false` and `isSingleton: true` (this isSingleton parameter only porpuse is to tell if it is to use the dependency on `dependency` or if it is to use the dependency on `FcBuilderFunc`). After that, `Get.find()` is called that immediately initialize the instances that are on memory.
+
+- Get.create: As the name implies, it will "create" your dependency! Similar to `Get.put()`, it also call the internal method `insert` to instancing. But `permanent` became true and `isSingleton` became false (since we are "creating" our dependency, there is no way for it to be a singleton instace, that's why is false). And because it has `permanent: true`, we have by default the benefit of not losing it between screens! Also, `Get.find()` is not called immediately, it wait to be used in the screen to be called. It is created this way to make use of the parameter `permanent`, since then, worth noticing, `Get.create()` was made with the goal of create not shared instances, but don't get disposed, like for example a button in a listView, that you want a unique instance for that list - because of that, Get.create must be used together with GetWidget.
+
+- Get.lazyPut: As the name implies, it is a lazy proccess. The instance is create, but it is not called to be used immediately, it remains waiting to be called. Contrary to the other methods, `insert` is not called here. Instead, the instance is inserted in another part of the memory, a part responsable to tell if the instance can be recreated or not, let's call it "factory". If we want to create something to be used later, it will not be mix with things been used right now. And here is where `fenix` magic enters: if you opt to leaving `fenix: false`, and your `smartManagement` are not `keepFactory`, then when using `Get.find` the instance will change the place in the memory from the "factory" to common instance memory area. Right after that, by default it is removed from the "factory". Now, if you opt for `fenix: true`, the instance continues to exist in this dedicated part, even going to the common area, to be called again in the future.
+
+
 ## Bindings
 ## Bindings
 
 
 Una de las grandes diferencias de este paquete, tal vez, es la posibilidad de una integración completa de las rutas, gestor de estado y dependencias.
 Una de las grandes diferencias de este paquete, tal vez, es la posibilidad de una integración completa de las rutas, gestor de estado y dependencias.

@@ -158,15 +158,13 @@ Get.create<S>(
 
 
 ### Diferenças entre os métodos:
 ### Diferenças entre os métodos:
 
 
-Primeiramente, vamos falar das variáveis `_factory` e `_singl`. Ambas são essenciais no processo de criação e uso de suas dependências, pois é através delas que podemos armazenar, apagar, recriar nossas instâncias. 
-
 Primeiro, vamos falar do `fenix` do Get.lazyPut e o `permanent` dos outros métodos.
 Primeiro, vamos falar do `fenix` do Get.lazyPut e o `permanent` dos outros métodos.
 
 
-- O `fenix` diz respeito ao armazenamento da instância. Quando você manipula os parâmetros `fenix` ou `smartManagement` para não perder as instâncias da sua dependência, elas serão salvas na para serem chamadas posteriormente.
-
-- O `permanent` diz respeito ao uso. Se a instância permanece ativa, ou se é apagada, quando não está em uso na tela.
-
-A diferença fundamental entre `permanent` e `fenix` está em como você quer armazenar as suas instâncias. Reforçando: por padrão, o Get apaga as instâncias quando elas não estão em uso (Digamos que a tela 1 tenha o controlador A e tela 2, controlador B. Ao mover-se de 1 para 2, o controlador A perde o uso e portanto é apagado), mas se você optar por algo `permanent: true`, então ela não se perde nessa transição - o que é muito útil para serviços que você quer manter rodando na aplicação inteira. Já o `fenix`, é para serviços que você não se preocupa em perder por uma tela ou outra, mas quando você precisar chamar o serviço, você espera que ele "retorne das cinzas" (`fenix: true`), criando uma nova instância. 
+A diferença fundamental entre `permanent` e `fenix` está em como você quer armazenar as suas instâncias.
+Reforçando: por padrão, o Get apaga as instâncias quando elas não estão em uso.
+Isso significa que: Se a tela 1 tem o controller 1 e a tela 2 tem o controller 2 e você remove a primeira rota da stack (usando `Get.off()` ou `Get.offNamed`), o controller 1 perdeu seu uso portanto será apagado.
+Mas se você optar por usar `permanent: true`, então ela não se perde nessa transição - o que é muito útil para serviços que você quer manter rodando na aplicação inteira.
+Já o `fenix`, é para serviços que você não se preocupa em perder por uma tela ou outra, mas quando você precisar chamar o serviço, você espera que ele "retorne das cinzas" (`fenix: true`), criando uma nova instância.
 
 
 Prosseguindo com as diferenças entre os métodos:
 Prosseguindo com as diferenças entre os métodos: