npm - @ahsan-iftikhar-114/api-toolkit-react-query - Versions diffs - 1.0.0 → 1.0.2 - Mend

@ahsan-iftikhar-114/api-toolkit-react-query 1.0.0 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/README.md +364 -723
package/package.json +37 -16

package/README.md CHANGED Viewed

@@ -1,396 +1,277 @@
 # @ahsan-iftikhar-114/api-toolkit-react-query
-**A simple and reusable API toolkit for React applications using Axios and TanStack Query.**
+A reusable API toolkit for React applications using Axios and TanStack Query.
-This package makes it easier to connect your React application with your backend API.
+The package provides a generic `createApi()` function for creating API queries and mutations without writing the same API setup repeatedly.
-You do not need to build API handling, loading states, error handling, authentication, caching, and request management from scratch.
+## Main Function
-The package provides these features in one reusable solution.
+The main function provided by this package is:
----
-## What is this package?
-When a React application needs information from a backend server, it has to send an **API request**.
-For example:
-* Get users
-* Create a user
-* Update a user
-* Delete a user
-* Get products
-* Submit a form
-* Login a user
-* Upload or send data
-* Refresh information from the server
-Normally, developers have to write a lot of code to manage these requests.
-This package provides a simpler and more consistent way to manage them.
-### In simple words
-You tell the package:
-**What is this API?**
-**Which HTTP method should it use?**
-**Which API URL should it call?**
-The package handles the rest.
----
-# Who is this package for?
-This package is useful for:
-* React developers
-* Frontend developers
-* Backend developers working with React
-* Beginners learning API integration
-* Developers building dashboards
-* Developers building admin panels
-* Developers building SaaS applications
-* Developers building business applications
-* Teams that want a consistent API structure
-* Projects using Laravel, Node.js, PHP, .NET, Python or another backend
-You do not need to understand every internal part of Axios or TanStack Query to use the basic functionality.
+```text
+createApi(name, method, url)
+```
----
+This is the primary function you will use.
-# What problem does it solve?
+The same function can be used for all supported HTTP methods:
-Without an API toolkit, developers often need to manage several things separately:
+```text
+GET
+POST
+PUT
+PATCH
+DELETE
+```
-* API requests
-* Axios configuration
-* Authentication tokens
-* Loading states
-* Error states
-* Request cancellation
-* API caching
-* Data refreshing
-* Cache invalidation
-* Query management
-* Mutation management
+The package automatically handles the API as a TanStack Query query or mutation based on the HTTP method.
-This package brings these responsibilities together.
+```text
+GET
+  ↓
+Query
-### Instead of building everything separately
+POST / PUT / PATCH / DELETE
+  ↓
+Mutation
+```
-You can use one consistent API system throughout your React application.
+This provides a consistent way to manage API communication in React applications.
 ---
-# How does it work?
-The basic idea is very simple.
+## How `createApi()` works
-You define an API using three things:
+`createApi()` accepts three basic parameters:
-**1. Name**
+| Parameter | Description               |
+| --------- | ------------------------- |
+| `name`    | A unique name for the API |
+| `method`  | HTTP method               |
+| `url`     | API endpoint              |
-A name that identifies the API.
-**2. Method**
-The type of request:
+For example:
-* GET
-* POST
-* PUT
-* PATCH
-* DELETE
+```text
+createApi("users", "GET", "/users")
+```
-**3. URL**
+This creates a GET API for `/users`.
-The backend API address.
+For creating a user:
-That's it.
+```text
+createApi("create-user", "POST", "/users")
+```
-The package then automatically decides how that API should work inside React.
+The function remains the same. Only the API name, method, and URL change.
 ---
-# What are GET, POST, PUT, PATCH and DELETE?
-You do not need to be an API expert to understand these.
-Think about a simple employee management system.
-### GET
-Used when you want to **get information**.
-Examples:
-* Get employees
-* Get users
-* Get products
-* Get invoices
+## Installation
----
-### POST
+Install the package using npm:
-Used when you want to **create something new**.
+```bash
+npm install @ahsan-iftikhar-114/api-toolkit-react-query
+```
-Examples:
+### Requirements
-* Create employee
-* Create user
-* Create invoice
-* Submit form
+* React 18 or newer
+* TanStack Query 5 or newer
+* Axios 1 or newer
+* TypeScript 5 or newer recommended
 ---
-### PUT
-Used when you want to **update existing information**.
+## Basic Setup
-Examples:
+There are three main steps to start using the package.
-* Update employee
-* Update user
-* Update profile
+### 1. Configure the API
----
+Configure your backend API URL and, if required, your authentication token.
-### PATCH
+The configuration is applied globally so that individual API definitions do not need to repeat the same settings.
-Also used to **update information**, usually when changing only part of it.
+You can configure:
-Examples:
-* Change employee status
-* Update user name
-* Change invoice status
+* Base API URL
+* Request timeout
+* Global headers
+* Authentication token
 ---
-### DELETE
-Used when you want to **remove something**.
-Examples:
-* Delete employee
-* Delete user
-* Delete product
+### 2. Configure TanStack Query
----
+The package uses TanStack Query for managing server data.
-# How do I install it?
+Your React application needs a `QueryClient` and `QueryClientProvider`.
-Open your React project's terminal and install the package:
+You can create a QueryClient using the package helper:
 ```text
-npm install @ahsan-iftikhar-114/api-toolkit-react-query
+createApiQueryClient()
 ```
-The package works with:
-* React
-* Axios
-* TanStack Query
+or use your own TanStack Query `QueryClient`.
-If your project does not already have the required React Query package, install it as well.
+The package does not create or force a global QueryClient.
 ---
-# What do I need before using it?
-You need a React application.
+### 3. Create APIs
-You also need:
-* React 18 or newer
-* TanStack Query 5 or newer
-* Axios 1 or newer
-TypeScript is recommended, but the package can also be used in JavaScript projects.
----
-# Basic setup
-The setup can be understood in four simple steps.
-## Step 1 — Install the package
-Install the package in your React project.
----
-## Step 2 — Tell the package your API address
-Your backend normally has a common address.
-For example:
+Create your APIs using:
 ```text
-https://api.example.com
+createApi(name, method, url)
 ```
-You configure this once.
+This is the main API creation function of the package.
-After that, you can use shorter API paths throughout your application.
+---
-For example:
+# HTTP Methods
-```text
-/users
-/products
-/orders
-/invoices
-```
+## GET
----
+GET requests are used to retrieve data.
-## Step 3 — Connect TanStack Query
+Examples:
-The package uses TanStack Query to manage server data.
+* Get users
+* Get employees
+* Get products
+* Get orders
+* Get reports
-Your React application needs a Query Client.
+When `GET` is used with `createApi()`, the package creates a TanStack Query.
-You can use the Query Client provided by the package or create your own TanStack Query client.
+The query provides access to:
-This is normally configured once in your application.
+* Response data
+* Loading state
+* Error state
+* Fetching state
+* Refetching
+* Cached data
 ---
-## Step 4 — Create your APIs
+## POST
-For every API, provide:
+POST requests are generally used to create new data.
-* Name
-* Method
-* URL
-For example, conceptually:
-**Users**
+Examples:
-**GET**
+* Create user
+* Create employee
+* Create product
+* Submit a form
-**/users**
+When `POST` is used, the package creates a TanStack Query mutation.
-The package will treat this as a data-fetching API.
+---
-For a create-user API:
+## PUT
-**Create User**
+PUT requests are used to update existing data.
-**POST**
+Examples:
-**/users**
+* Update user
+* Update employee
+* Update product
-The package will treat this as a data-changing API.
+PUT APIs are handled as mutations.
 ---
-# GET APIs
+## PATCH
-GET APIs are used when your application needs to **read information from the server**.
+PATCH requests are used to partially update existing data.
-For example:
+Examples:
-* Employee list
-* Customer list
-* Product list
-* Dashboard statistics
-* Notifications
-* User profile
+* Change user status
+* Update employee status
+* Change order status
-When you use a GET API, the package provides the information needed to manage the request, including:
-* Data
-* Loading state
-* Error state
-* Fetching state
-* Refetching
-* Cached data
-This means your application can easily know whether information is loading, successfully received, or failed.
+PATCH APIs are handled as mutations.
 ---
-# POST, PUT, PATCH and DELETE APIs
+## DELETE
-These APIs are used when your application needs to **change information on the server**.
+DELETE requests are used to remove data.
-For example:
+Examples:
-* Create employee
-* Update employee
+* Delete user
 * Delete employee
-* Create invoice
-* Update invoice
-* Submit request
-The package manages these operations as mutations.
-You can easily know:
+* Delete product
-* Whether the operation is running
-* Whether it succeeded
-* Whether it failed
-* What data was returned
-* What error occurred
+DELETE APIs are handled as mutations.
 ---
-# Sending information to the server
+# Request Data
-When creating or updating something, your application usually needs to send information.
+POST, PUT, PATCH and DELETE requests can send data to the backend.
-For example, when creating an employee:
+For example, an employee API may need:
 * Name
 * Email
 * Department
 * Position
-The package allows you to send this information to your backend API.
+The package supports request payloads along with query parameters, headers and additional Axios configuration.
-You can also send:
+---
-* Query parameters
-* Request headers
-* Authentication information
-* Additional Axios configuration
+# Query Parameters
----
+GET requests can include query parameters for:
-# Authentication
+* Search
+* Pagination
+* Filtering
+* Sorting
+* Page size
+* Status
-Many APIs require users to log in before they can access protected information.
+For example:
-This package supports **Bearer Token authentication**.
+```text
+/users?page=1&search=ahsan
+```
-You can configure an authentication token globally.
+Query parameters are also included in the query key, allowing TanStack Query to manage different parameter combinations separately.
-The token can be:
+---
-* A fixed token
-* A dynamically retrieved token
+# Authentication
-A dynamic token is useful when the token is stored in browser storage or another authentication system.
+The package supports Bearer token authentication.
-The package automatically adds the token to API requests.
+You can configure either:
-This means you do not need to manually add the authentication header to every request.
+* A static token
+* A function that returns the current token
+This allows applications to keep authentication configuration in one place instead of manually adding the token to every request.
+The backend remains responsible for authentication and authorization.
 ---
 # API Base URL
-You can configure one common API address for your application.
+A global base URL can be configured for the application.
 For example:
@@ -398,9 +279,7 @@ For example:
 https://api.example.com
 ```
-Then individual APIs only need their own path.
-For example:
+Individual APIs can then use relative paths:
 ```text
 /users
@@ -409,544 +288,302 @@ For example:
 /orders
 ```
-This makes API configuration easier to maintain.
-If your backend address changes, you can update the main configuration instead of changing every API.
+This keeps API definitions short and makes it easier to change the backend URL later.
 ---
-# Loading states
+# Loading and Request States
-When your application requests information from a server, the server may take some time to respond.
+TanStack Query provides request state information for GET requests and mutation state information for POST, PUT, PATCH and DELETE requests.
-The package provides request status information so your application can show things such as:
+This can be used to display:
-* Loading...
-* Please wait...
-* Loading spinner
-* Refreshing...
-* Saving...
-* Deleting...
+* Loading indicators
+* Saving indicators
+* Delete progress
+* Error messages
+* Refreshing states
-This makes it easier to create a better user experience.
+The package does not require developers to create separate loading state variables for every API request.
 ---
-# Error handling
+# Error Handling
-API requests can fail for many reasons.
+The package normalizes API errors into a consistent `ApiError` structure.
-For example:
-* Internet connection problem
-* Server error
-* Unauthorized request
-* Validation error
-* Not found
-* Request timeout
-The package provides a consistent error format so your application can handle API errors more easily.
-Instead of every API returning a completely different error structure to your application, the package normalizes common API errors.
----
-# Query parameters
-Sometimes an API needs additional information in the URL.
-For example:
+The error can include:
-* Page number
-* Number of records
-* Search text
-* Sorting
-* Filtering
-* Status
+* Message
+* HTTP status
+* Status text
+* Response data
+* Validation errors
+* Original Axios error
-The package supports query parameters.
-This makes it suitable for:
-* Search pages
-* Data tables
-* Pagination
-* Filters
-* Reports
-* Admin dashboards
+This provides a consistent way to handle API errors throughout the application.
 ---
 # Caching
-One of the major features of this package is API data caching through TanStack Query.
-Caching means your application can temporarily remember information it has already received.
-This can reduce unnecessary API requests.
-For example:
-A user opens the employee page.
+GET requests use TanStack Query's caching system.
-The application gets the employee list from the server.
+Previously fetched data can be stored in the query cache according to the configured TanStack Query settings.
-If the same information is needed again, TanStack Query can use its cached data according to your configured caching rules.
-This can make applications feel faster and reduce unnecessary network requests.
+Caching can reduce unnecessary API requests and improve the responsiveness of an application.
 ---
 # Refetching
-Sometimes information needs to be updated from the server.
+TanStack Query provides refetching functionality for keeping server data up to date.
-For example:
+Depending on your configuration, queries can be refetched when:
-* User clicks Refresh
-* User returns to a page
-* Application reconnects to the internet
+* A user manually refreshes data
 * Data becomes stale
-The package works with TanStack Query's refetching functionality.
-This allows your application to keep server data up to date.
+* The application reconnects
+* A component mounts
+* A configured interval is reached
 ---
-# Cache invalidation
-Suppose you have an employee list.
-A user creates a new employee.
+# Cache Invalidation
-The old employee list may no longer be correct.
+When data is created, updated or deleted, previously cached data may become outdated.
-The package provides cache invalidation utilities that can tell TanStack Query:
+The package provides cache utilities for invalidating queries.
-**"This data may have changed. Get the latest information."**
+Available utilities include:
-This is especially useful after:
+```text
+invalidateApi()
+invalidateApis()
+invalidateAllApis()
+```
-* Creating records
-* Updating records
-* Deleting records
-* Changing statuses
-* Performing other server-side operations
+You can use these after mutations to tell TanStack Query that related data should be refreshed.
 ---
-# Request cancellation
-Sometimes a request is no longer needed.
-For example:
-A user starts searching for employees.
-Then immediately changes the search.
-The previous request may no longer be useful.
+# Request Cancellation
 The package supports request cancellation through `AbortSignal`.
-This can help prevent unnecessary work and improve request management.
----
-# Advanced configuration
-Although the basic API is simple, the package also supports advanced configuration.
-Developers can use TanStack Query options such as:
-* Cache duration
-* Stale time
-* Retry behavior
-* Automatic refetching
-* Conditional requests
-* Placeholder data
-* Initial data
-* Data selection
-* Other compatible TanStack Query options
-This means beginners can start with the simple functionality while experienced developers can customize the behavior when needed.
----
-# TypeScript support
-The package is designed with TypeScript support in mind.
-You can define the type of:
-* API response
-* Request data
-* Mutation context
-* Selected data
-This helps developers get:
-* Better autocomplete
-* Better editor support
-* Better type checking
-* Fewer mistakes
-* Easier maintenance
-TypeScript is especially useful for large applications.
----
-# Works with different backends
-This package is designed for the frontend API layer.
-Your backend can be built using many different technologies.
-For example:
-* Laravel
-* PHP
-* Node.js
-* Express
-* NestJS
-* .NET
-* ASP.NET
-* Django
-* FastAPI
-* Spring Boot
-* Other REST APIs
-As long as your backend provides an API that your React application can communicate with, this package can be used as the API management layer.
----
-# What happens behind the scenes?
-You do not need to manage all of these individually.
-The package combines:
-**React**
-↓
-**API Toolkit**
-↓
-**Axios**
-↓
-**Backend API**
-And for server data management:
-**TanStack Query**
-↓
-**Caching**
-↓
-**Refetching**
-↓
+This is useful when a request is no longer required, such as when a user changes a search request before the previous request has completed.
-**Loading & Error States**
+The package also provides:
-↓
-**Cache Invalidation**
+```text
+cancelApi()
+```
-The goal is to give your application one consistent way to communicate with APIs.
+for cancelling queries associated with an API.
 ---
-# Why use this package?
+# React Query Options
-### Simple API creation
-Define an API using:
-* Name
-* Method
-* URL
+The package supports standard TanStack Query options.
----
+These include:
-### Less repeated code
+* `staleTime`
+* `gcTime`
+* `enabled`
+* `retry`
+* `retryDelay`
+* `refetchInterval`
+* `refetchOnWindowFocus`
+* `refetchOnReconnect`
+* `refetchOnMount`
+* `initialData`
+* `placeholderData`
+* `select`
-You do not have to repeatedly create the same API request structure.
+This allows the basic API creation system to remain simple while still providing access to TanStack Query's configuration options.
 ---
-### Centralized configuration
-Configure:
-* API URL
-* Timeout
-* Headers
-* Authentication
+# Data Selection
-in one place.
+The `select` option can be used when the component only needs a specific part or transformed version of the API response.
----
-### Built-in React Query support
+For example, an API may return a complete list of users while a component only needs the number of users.
-Use the powerful server-state management capabilities of TanStack Query.
+TanStack Query's `select` functionality can be used for this transformation without changing the original cached data.
 ---
-### Authentication support
+# Axios Configuration
-Bearer token authentication can be configured centrally.
+The package uses Axios for HTTP requests.
----
+In addition to the global configuration, individual requests can use:
-### Consistent errors
-API errors are normalized into a common structure.
----
-### Caching support
+* Request-specific headers
+* Query parameters
+* Request data
+* Axios request configuration
+* Request cancellation
-Use TanStack Query caching to reduce unnecessary requests.
+This provides additional control when a specific API needs different settings.
 ---
-### Request cancellation
-Cancel requests when they are no longer required.
+# TypeScript
----
+The package supports TypeScript generics for API responses, request data and selected data.
-### TypeScript friendly
+This provides type checking and editor support when working with API data.
-Use types for safer development and better editor support.
+TypeScript is recommended for larger React applications.
 ---
-### Flexible
+# Query Client
-Beginners can use the simple API creation system, while experienced developers can use advanced Axios and TanStack Query options.
+The package provides:
----
+```text
+createApiQueryClient()
+```
-# Recommended for
+as a helper for creating a TanStack Query `QueryClient`.
-This package is particularly useful for applications such as:
+You can also create and configure your own `QueryClient`.
-* Admin panels
-* HRMS systems
-* CRM systems
-* ERP systems
-* SaaS applications
-* E-commerce applications
-* Project management applications
-* Business management systems
-* Dashboards
-* Customer portals
-* Employee portals
-* Internal company applications
-* REST API based React applications
+The package does not maintain a hidden global QueryClient. This allows the application to control its own QueryClient and cache lifecycle.
 ---
-# Package Architecture
+# Complete API Flow
-The package internally separates different responsibilities.
+The package follows this general flow:
 ```text
-API Configuration
-        ↓
-Axios
-        ↓
-API Request Layer
-        ↓
-TanStack Query
-        ↓
-React Application
+createApi(name, method, url)
+              |
+              v
+        API Definition
+              |
+              v
+           Axios
+              |
+              v
+        Backend API
+              |
+              v
+      TanStack Query
+              |
+              v
+   Data / Cache / Loading
+   Errors / Refetching
+   Mutations / Invalidation
 ```
-This separation keeps the package reusable and easier to maintain.
----
-# Supported HTTP Methods
-The package supports:
-| Method | Purpose                      |
-| ------ | ---------------------------- |
-| GET    | Get information              |
-| POST   | Create information           |
-| PUT    | Update information           |
-| PATCH  | Partially update information |
-| DELETE | Delete information           |
+The developer mainly works with `createApi()` while Axios and TanStack Query handle the underlying API and server-state functionality.
 ---
-# Important terms explained simply
-### API
-An API allows your application to communicate with a backend server.
-### Axios
+# Example Use Cases
-Axios is the technology used to send HTTP requests to the backend.
+The same generic API function can be used in different types of applications.
-### TanStack Query
+For an HRMS:
-TanStack Query manages server data inside your React application.
-It helps with:
-* Loading
-* Errors
-* Caching
-* Refetching
-* Mutations
-* Server state
-### Query
-A query normally means:
-**"Get information from the server."**
-### Mutation
-A mutation normally means:
-**"Change something on the server."**
-### Cache
+```text
+Employees
+Attendance
+Leave
+Payroll
+Performance
+Requests
+Notifications
+```
-Previously received server information that can temporarily be stored and reused.
+For a CRM:
-### Query invalidation
+```text
+Leads
+Contacts
+Companies
+Opportunities
+Deals
+Customers
+```
-Telling the application that previously cached information may now be outdated and should be refreshed.
+For an e-commerce application:
-### Bearer Token
+```text
+Products
+Categories
+Orders
+Customers
+Payments
+```
-A common way of sending an authentication token with an API request.
+The API creation pattern remains the same.
 ---
-# Is this package difficult to use?
-No.
-The package is designed around a simple API creation concept.
-You mainly need to understand three things:
-**Name → Method → URL**
-For example:
-**Employees → GET → /employees**
+# Supported Methods
-Once you understand this concept, you can create APIs for almost any resource in your application.
+| Method | Type     | Purpose               |
+| ------ | -------- | --------------------- |
+| GET    | Query    | Retrieve data         |
+| POST   | Mutation | Create data           |
+| PUT    | Mutation | Update data           |
+| PATCH  | Mutation | Partially update data |
+| DELETE | Mutation | Delete data           |
 ---
-# Typical application example
+# Backend Compatibility
-Imagine you are building an HRMS application.
+The package can be used with any backend that provides a compatible HTTP API.
-You might have APIs for:
+Examples include:
-* Employees
-* Attendance
-* Leave
-* Payroll
-* Departments
-* Performance
-* Requests
-* Notifications
-You can use the same package structure for all of them.
-This gives your application a consistent API architecture instead of creating a different API implementation for every module.
----
-# Browser Support
-This package is intended for modern React applications running in environments that support:
-* Promises
-* Fetch-compatible AbortSignal
-* Modern JavaScript features
+* Laravel
+* PHP
+* Node.js
+* Express
+* NestJS
+* .NET
+* ASP.NET
+* Django
+* FastAPI
+* Spring Boot
+* Other REST API backends
-For older browser environments, appropriate polyfills may be required depending on the application's setup.
+The package is responsible for the React API layer. Backend authentication, authorization, validation and business logic remain the responsibility of the backend application.
 ---
-# Security Note
+# Security
-This package helps send authentication tokens, but it does not provide a complete authentication system.
+The package supports authentication tokens but does not provide an authentication system.
-Your application and backend are still responsible for:
+Your application and backend are responsible for:
 * Login
-* User registration
+* Registration
 * Token generation
-* Token expiration
 * Token refresh
-* Permissions
+* Token expiration
 * Roles
-* Backend authorization
-* Secure token storage
-Never expose sensitive secrets such as backend private keys or server credentials in a React frontend.
----
-# Performance
-The package uses TanStack Query for server-state management and caching.
-Performance will depend on:
-* API design
-* Backend performance
-* Database performance
-* Network speed
-* Query configuration
-* Cache configuration
-* Amount of requested data
-For large applications, developers should also use appropriate backend pagination, filtering, indexing and optimized API responses.
----
-# Package Philosophy
-The main goal of this package is:
-> **Make API integration simple, reusable and consistent.**
-Instead of creating a separate API architecture for every React project, developers can use the same basic approach across different applications.
-Beginners can start with the simple functionality.
+* Permissions
+* Authorization
-Experienced developers can take advantage of advanced Axios and TanStack Query features.
+Do not expose private server credentials or secrets in a React application.
 ---
 # Technology
-This package is built around:
+This package uses:
 * React
 * TypeScript
@@ -955,63 +592,67 @@ This package is built around:
 ---
-# Keywords
+# Package Structure
-This package is useful for developers searching for:
+The package separates its main responsibilities into:
-* React API client
-* React API toolkit
-* React Query API
-* TanStack Query API
-* Axios React Query
-* Axios API client
-* React API hooks
-* React Query hooks
-* React mutation hooks
-* React query hooks
-* TypeScript API client
-* React REST API client
-* API caching
-* React Query caching
-* API cache invalidation
-* Axios TypeScript
-* TanStack Query TypeScript
-* React API management
-* Generic React API client
-* Reusable React API hooks
-* API request management
-* React server state management
+```text
+Configuration
+     |
+     v
+Axios
+     |
+     v
+API Request
+     |
+     v
+TanStack Query
+     |
+     v
+React Application
+```
----
+This keeps API communication and server-state management reusable across the application.
-# Version
+---
-Current version:
+# Main API
-**1.0.0**
+The main public function is:
----
+```text
+createApi(name, method, url)
+```
-# License
+Additional public utilities include:
-This package is released under the **MIT License**.
+```text
+configureApi()
+createApiQueryClient()
+invalidateApi()
+invalidateApis()
+invalidateAllApis()
+cancelApi()
+```
-See the `LICENSE` file for more information.
+The package also provides TypeScript types for API configuration, requests, responses, errors and React Query options.
 ---
-# Author
+# Keywords
-**Ahsan Iftikhar**
+React API toolkit, React API client, React Query API, TanStack Query API, Axios React Query, Axios API client, React API hooks, React Query hooks, React mutation hooks, TypeScript API client, React REST API client, API caching, React Query caching, API cache invalidation, Axios TypeScript, TanStack Query TypeScript, React API management, generic React API client, reusable React API hooks, API request management, React server state management.
 ---
-# Final Note
+# License
-If you are a beginner, start with the basic setup:
+This package is released under the MIT License.
-**Install → Configure → Connect Query Client → Create API → Use API**
+See the `LICENSE` file for complete license information.
-You do not need to understand every advanced feature before starting.
+---
+# Author
-Once your application grows, you can use the advanced configuration, caching, authentication, cancellation, TypeScript and React Query features provided by the package.
+Ahsan Iftikhar