Instance Management

/**
 * Create a new axios instance with custom defaults
 * @param config - Default configuration for the new instance
 * @returns New axios instance with specified defaults
 */
axios.create(config?: CreateAxiosDefaults): AxiosInstance;

interface CreateAxiosDefaults {
  baseURL?: string;
  timeout?: number;
  headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;
  transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];
  transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];
  paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;
  adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];
  auth?: AxiosBasicCredentials;
  responseType?: ResponseType;
  responseEncoding?: responseEncoding;
  xsrfCookieName?: string;
  xsrfHeaderName?: string;
  maxContentLength?: number;
  maxBodyLength?: number;
  validateStatus?: (status: number) => boolean;
  maxRedirects?: number;
  proxy?: AxiosProxyConfig | false;
  // ... other AxiosRequestConfig properties
}

import axios from "axios";

// API-specific instance
const apiClient = axios.create({
  baseURL: "https://api.example.com/v1",
  timeout: 10000,
  headers: {
    "Authorization": "Bearer your-token-here",
    "Content-Type": "application/json"
  }
});

// Different environment instances
const developmentAPI = axios.create({
  baseURL: "https://dev-api.example.com",
  timeout: 30000, // Longer timeout for dev
  headers: { "X-Environment": "development" }
});

const productionAPI = axios.create({
  baseURL: "https://api.example.com",
  timeout: 5000,
  headers: { "X-Environment": "production" }
});

interface AxiosInstance extends Axios {
  // Function call interface
  <T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
  <T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;

  // Create sub-instances
  create(config?: CreateAxiosDefaults): AxiosInstance;
  
  // Instance defaults
  defaults: Omit<AxiosDefaults, 'headers'> & {
    headers: HeadersDefaults & {
      [key: string]: AxiosHeaderValue
    }
  };
  
  // All HTTP methods available
  get<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
  post<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
  put<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
  patch<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
  delete<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
  head<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
  options<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
  postForm<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
  putForm<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
  patchForm<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
}

// Use instance like default axios
const users = await apiClient.get("/users");
const newUser = await apiClient.post("/users", userData);

// Function call interface
const config = { method: "get", url: "/profile" };
const profile = await apiClient(config);

// Create sub-instance with additional defaults
const adminAPI = apiClient.create({
  headers: { "X-Admin": "true" },
  timeout: 15000
});

/**
 * Axios class constructor
 * @param instanceConfig - Configuration for the instance
 */
class Axios {
  constructor(instanceConfig?: AxiosRequestConfig);
  
  /** Instance defaults configuration */
  defaults: AxiosDefaults;
  
  /** Interceptors for requests and responses */
  interceptors: {
    request: AxiosInterceptorManager<InternalAxiosRequestConfig>;
    response: AxiosInterceptorManager<AxiosResponse>;
  };
  
  /** Core request method */
  request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
  
  /** Generate complete request URI */
  getUri(config?: AxiosRequestConfig): string;
  
  // All HTTP method implementations
  get<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
  post<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
  // ... other HTTP methods
}

import { Axios } from "axios";

// Direct class instantiation
const customClient = new Axios({
  baseURL: "https://custom-api.example.com",
  timeout: 8000
});

// Access interceptors
customClient.interceptors.request.use(config => {
  console.log("Making request to:", config.url);
  return config;
});

// Generate URI without making request
const uri = customClient.getUri({
  url: "/users",
  params: { page: 1, limit: 10 }
});
console.log(uri); // "https://custom-api.example.com/users?page=1&limit=10"

interface AxiosDefaults {
  /** Base URL for all requests */
  baseURL?: string;
  /** Request timeout in milliseconds */
  timeout: number;
  /** Default headers for different HTTP methods */
  headers: HeadersDefaults;
  /** Request data transformers */
  transformRequest: AxiosRequestTransformer[];
  /** Response data transformers */
  transformResponse: AxiosResponseTransformer[];
  /** Default request adapter */
  adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];
  /** Basic authentication credentials */
  auth?: AxiosBasicCredentials;
  /** Default response type */
  responseType?: ResponseType;
  /** Maximum request/response size */
  maxContentLength?: number;
  maxBodyLength?: number;
  /** Status validation function */
  validateStatus?: (status: number) => boolean;
  /** Maximum number of redirects */
  maxRedirects?: number;
  /** Proxy configuration */
  proxy?: AxiosProxyConfig | false;
}

interface HeadersDefaults {
  common: RawAxiosRequestHeaders;
  delete: RawAxiosRequestHeaders;
  get: RawAxiosRequestHeaders;
  head: RawAxiosRequestHeaders;
  post: RawAxiosRequestHeaders;
  put: RawAxiosRequestHeaders;
  patch: RawAxiosRequestHeaders;
  options?: RawAxiosRequestHeaders;
  purge?: RawAxiosRequestHeaders;
  link?: RawAxiosRequestHeaders;
  unlink?: RawAxiosRequestHeaders;
}

// Modify instance defaults
const api = axios.create();

// Change base URL
api.defaults.baseURL = "https://new-api.example.com";

// Set common headers
api.defaults.headers.common["Authorization"] = "Bearer new-token";

// Set method-specific headers
api.defaults.headers.post["Content-Type"] = "application/json";

// Modify timeout
api.defaults.timeout = 15000;

// Custom status validation
api.defaults.validateStatus = (status) => status < 500;

// Service-based instances
const authService = axios.create({
  baseURL: "https://auth.example.com",
  timeout: 5000
});

const dataService = axios.create({
  baseURL: "https://data.example.com",
  timeout: 10000,
  headers: { "Content-Type": "application/json" }
});

const fileService = axios.create({
  baseURL: "https://files.example.com",
  timeout: 30000, // Longer timeout for file operations
  maxBodyLength: 50 * 1024 * 1024 // 50MB max file size
});

// Environment-based factory
function createAPIClient(environment) {
  const baseURLs = {
    development: "https://dev-api.example.com",
    staging: "https://staging-api.example.com",
    production: "https://api.example.com"
  };
  
  return axios.create({
    baseURL: baseURLs[environment],
    timeout: environment === "development" ? 30000 : 10000,
    headers: {
      "X-Environment": environment
    }
  });
}

const api = createAPIClient(process.env.NODE_ENV);