update docs with how the valkey class hierarchy is structured now

Author: amirreza8002

docs/commands/valkey_native_commands.md

@@ -12,7 +12,7 @@ False
 "value1"
 ```
 
-the list of supported commands is very long, if needed you can check the methods at ``django_valkey.cache.ValkeyCache```
+the list of supported commands is very long, if needed you can check the methods at `django_valkey.base.BackendCommands`.
 
 ### Infinite timeout
 

docs/customize.md

@@ -8,9 +8,9 @@ django-valkey comes with three base classes: `django_valkey.base.BaseValkeyCache
 
 ## BaseValkeyCache
 
-`BaseValkeyCache` inherits from django's `BaseCache` class and `typing.Generic`.
-`BaseCache` adds basic cache functionality, such as `get()` and `set()`, and `typing.Generic` allows for a more robust type hinting.
-`BaseValkeyCache` adds more valkey oriented methods to BaseCache, things like `expire()` and `get_lock()`, and uses Generic to type hint two things:
+`BaseValkeyCache` is not a standalone class, to make use of it you need to add the actual methods, in `django-valkey` this is done by `django_valkey.base.BackendCommands` or `django_valkey.base.AsyncBackendCommands` depending if you use sync or async clients
+`BaseValkeyCache` contains connection methods and configures the behaviour of the cache
+`BaseValkeyCache` inherits from `typing.Generic` to type hint two things:
 1. the client, such as `django_valkey.client.default.DefaultClient`.
 2. the underlying backend, such as `valkey.Valkey`.
 
@@ -19,23 +19,26 @@ to inherit from this base class you can take the example of our own cache backen
 ```python
 from valkey import Valkey
 
-from django_valkey.base import BaseValkeyCache
+from django_valkey.base import BaseValkeyCache, BackendCommands
 from django_valkey.client import DefaultClient
 
-class ValkeyCache(BaseValkeyCache[DefaultClient, Valkey]):
+class ValkeyCache(BaseValkeyCache[DefaultClient, Valkey], BackendCommands):
     DEFAULT_CLIENT_CLASS = "django_valkey.client.DefaultClient"
     ...
 ```        
 
-the class attribute defined in the example is **mandatory**, it is so we can have imports in other modules.
+the `DEFAULT_CLIENT_CLASS` class attribute defined in the example is **mandatory**, it is so we can have imports in other modules.
 
-`BaseValkeyCache` has both *sync* and *async* methods implemented, but there is no logic in them, most methods need to be overwritten.
+`BaseValkeyCache` can work with both *sync* and *async* subclasses, but it doesn't implement any of the methods, you need to inherit the command classes for this to work.
 
 
 ## BaseClient
-`BaseClient` inherits from `typing.Generic` to make cleaner type hints.
-this class has all the logic necessary for a cache client (it is a copy of the old DefaultClient class), it finds the different servers and connects to them, add has all the commands that valkey supports.
+like `BaseValkeyCache`, `BaseClient` is not a standalone class.
+this class has all the logic necessary to connect to a cache server, and utility methods that helps with different operations,
+but it does not handle any of the operations by itself, you need one of `django_valkey.base_client.ClientCommands` or `django_valkey.base_client.AsyncClientCommands` for sync or async clients, respectively.
+the command classes implement the actual operations such as `get` and `set`.
 
+`BaseClient` inherits from `typing.Generic` to make cleaner type hints.
 the `typing.Generic` needs a backend to be passed in, e.g: `valkey.Valkey`
 
 the base class also needs the subclasses to have a `CONNECTION_FACTORY_PATH` class variable pointing to the connection factory class.
@@ -45,14 +48,16 @@ an example code would look like this:
 ```python
 from valkey import Valkey
 
-from django_valkey.base_client import BaseClient
+from django_valkey.base_client import BaseClient, ClientCommands
 
-class DefaultClient(BaseClient[Valkey]):
+class DefaultClient(BaseClient[Valkey], ClientCommands[Valkey]):
     CONNECTION_FACTORY_PATH = "django_valkey.pool.ConnectionFactory"
 ```
 
 *note* that CONNECTION_FACTORY_PATH is only used if `DJANGO_VALKEY_CONNECTION_FACTORY` is not set.
 
+`BaseClient` can work with both sync and async subclasses, you would use one of `django_valkey.base_client.ClientCommands` for sync, and `django_valkey.base_client.AsyncClientCommands` for async clients.
+
 
 ## BaseConnectionFactory