// v2
client.clearCache();
client.clearCache('mainAPI');

// v3
client.invalidate();
client.invalidate({ configId: 'mainAPI' });
client.invalidate({ url: /\/users\// });
client.invalidate({ predicate: (key) => key.includes('list') });

// v2
client.setAuthorizationHeader(token);

// v3
client.setAccessToken(token);

// v2
AxlyMutationOptions<T, D, C>;

// v3
AxlyMutationOptions<T, C>;

client.upload(url, formData, { retry: 0 });

// apiClient.ts
import { createAxlyClient } from 'axly';

const apiClient = createAxlyClient({
  baseURL: 'https://api.example.com',
  token: localStorage.getItem('authToken'),
  toastHandler: (msg, type) => console.log(`[${type}]`, msg)
});

export default apiClient;

import { createAxlyClient } from 'axly';

const apiClient = createAxlyClient({
  baseURL: 'https://api.example.com',
  token: 'your-jwt-token',
  toastHandler: (message, type) => {
    console.log(`[${type}] ${message}`);
  }
});

import { createAxlyClient } from 'axly';

const client = createAxlyClient({
  mainAPI: {
    baseURL: 'https://api.example.com',
    multiToken: true,
    accessToken: localStorage.getItem('accessToken'),
    refreshToken: localStorage.getItem('refreshToken'),
    refreshEndpoint: '/auth/refresh',
    onRefresh: ({ accessToken, refreshToken }) => {
      localStorage.setItem('accessToken', accessToken);
      localStorage.setItem('refreshToken', refreshToken);
    },
    onRefreshFail: () => {
      window.location.href = '/login';
    }
  },
  publicAPI: {
    baseURL: 'https://public.example.com'
  }
});

// Use a specific config
await client.request({ method: 'GET', url: '/data', configId: 'publicAPI' });

createAxlyClient<ConfigMap>(config: AxlyConfig | ConfigMap): AxlyClient

createAxlyNodeClient<ConfigMap>(config: AxlyConfig | ConfigMap): AxlyClient

const response = await client.request<User>({
  method: 'GET',
  url: '/users/1'
});

const form = new FormData();
form.append('file', file);
const response = await client.upload<{ url: string }>('/upload', form, {
  onUploadProgress: (percent) => console.log(`${percent}%`)
});

client.setAccessToken('new-token', 'configId'); // Set access token (updates storage + axios defaults)
client.setRefreshToken('refresh-token', 'configId'); // Set refresh token
client.setDefaultHeader('X-Custom', 'value', 'configId'); // Set a default header
client.clearDefaultHeader('X-Custom', 'configId'); // Remove a default header

client.invalidate(); // Clear everything (all configs)
client.invalidate({ configId: 'mainAPI' }); // Clear all entries for one config
client.invalidate({ url: '/users' }); // Clear entries whose key contains '/users'
client.invalidate({ url: /\/users\/\d+/ }); // Regex match against cache keys
client.invalidate({ predicate: (key) => key.startsWith('GET:') }); // Arbitrary predicate

client.cancelRequest(abortController); // Cancel a specific request
client.destroy(); // Cleanup all instances, caches, and timers
client.on('destroy', () => {}); // Listen to events

const {
  request,
  cancelRequest,
  isLoading,
  status,
  uploadProgress,
  downloadProgress
} = useAxly(client);

const { data, error, status, isLoading, isFetching, refetch } = useAxlyQuery({
  client,
  request: { method: 'GET', url: '/users' },
  enabled: true,
  refetchOnMount: true,
  refetchInterval: 30000, // poll every 30s
  onSuccess: (response) => console.log(response.data),
  onError: (error) => console.error(error)
});

const { mutate, mutateAsync, isPending, data, error, status, reset } =
  useAxlyMutation({
    client,
    onSuccess: (response) => console.log('Done:', response.data),
    onError: (error) => console.error('Failed:', error),
    onSettled: (data, error) => console.log('Settled')
  });

// Fire-and-forget
mutate({ method: 'POST', url: '/users', data: { name: 'Jane' } });

// Async with result
const response = await mutateAsync({
  method: 'POST',
  url: '/users',
  data: { name: 'Jane' }
});

// GET
const { data } = await client.request<User[]>({ method: 'GET', url: '/users' });

// POST
await client.request({ method: 'POST', url: '/users', data: { name: 'Jane' } });

// With query params
await client.request({
  method: 'GET',
  url: '/users',
  params: { page: '1', limit: '20' }
});

// Single token (simple auth)
const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  token: localStorage.getItem('token')
});

// Update token at runtime
client.setAccessToken('new-token');

// Multi-token with auto-refresh
const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  multiToken: true,
  accessToken: localStorage.getItem('accessToken'),
  refreshToken: localStorage.getItem('refreshToken'),
  refreshEndpoint: '/auth/refresh',
  onRefresh: ({ accessToken, refreshToken }) => {
    localStorage.setItem('accessToken', accessToken);
    localStorage.setItem('refreshToken', refreshToken);
  },
  onRefreshFail: () => {
    window.location.href = '/login';
  }
});

// Enable globally for a config
const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  dedupeRequests: true
});

// Or per-request
await client.request({ method: 'GET', url: '/users', dedupe: true });

// Both of these share a single network request:
const [a, b] = await Promise.all([
  client.request({ method: 'GET', url: '/users', dedupe: true }),
  client.request({ method: 'GET', url: '/users', dedupe: true })
]);

// Cache with default TTL (5 minutes)
await client.request({ method: 'GET', url: '/config', cache: true });

// Cache with custom TTL (30 seconds)
await client.request({
  method: 'GET',
  url: '/config',
  cache: { ttl: 30_000 }
});

// Combine caching with deduplication
await client.request({
  method: 'GET',
  url: '/config',
  cache: { ttl: 60_000 },
  dedupe: true
});

// Fresh for 60s; serve stale for up to 5 more minutes while refreshing
await client.request({
  method: 'GET',
  url: '/config',
  cache: {
    ttl: 60_000,
    staleWhileRevalidate: 300_000
  }
});

// After mutating a user, clear all cached GETs that touch that path
await client.request({
  method: 'PATCH',
  url: '/users/42',
  data: { name: 'Jane' }
});
client.invalidate({ url: '/users/42' });

// Clear every /users/* entry
client.invalidate({ url: /\/users\// });

// Clear by config
client.invalidate({ configId: 'mainAPI' });

// Arbitrary predicate — e.g. drop every non-GET entry (shouldn't exist, but illustrative)
client.invalidate({ predicate: (key) => !key.startsWith('GET:') });

// Clear everything (cache + in-flight dedupes, all configs)
client.invalidate();

// Retry up to 3 times with exponential backoff + jitter
await client.request({
  method: 'GET',
  url: '/unstable-endpoint',
  retry: 3
});
// Delays: ~500ms, ~1000ms, ~2000ms (with random jitter)

// Per-request: retry only on 503, up to 5 times
await client.request({
  method: 'GET',
  url: '/flaky',
  retry: 5,
  shouldRetry: (err, attempt) => err.response?.status === 503
});

// Per-config: retry everything except 4xx (v2-style aggressive retrying, but skip auth/validation errors)
const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  shouldRetry: (err) => {
    const status = err.response?.status;
    if (status != null && status >= 400 && status < 500) return false;
    return true;
  }
});

// Restore exact v2 behavior (retry on any error)
const legacyClient = createAxlyClient({
  baseURL: 'https://api.example.com',
  shouldRetry: () => true
});

// Default — emits "Authorization: Bearer abc123"
const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  token: 'abc123'
});

// GitHub-style — emits "Authorization: token abc123"
const githubClient = createAxlyClient({
  baseURL: 'https://api.github.com',
  token: 'abc123',
  authScheme: 'token'
});

// Raw token — emits "Authorization: abc123" (no prefix)
const rawClient = createAxlyClient({
  baseURL: 'https://api.example.com',
  token: 'abc123',
  authScheme: null
});

// AWS-style — emits "Authorization: AWS4-HMAC-SHA256 <sig>"
const awsClient = createAxlyClient({
  baseURL: 'https://s3.example.com',
  token: '<sig>',
  authScheme: 'AWS4-HMAC-SHA256'
});

const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  toastHandler: (message, type) => {
    // Use any toast library
    toast[type ?? 'info'](message);
  }
});

await client.request({
  method: 'POST',
  url: '/users',
  data: { name: 'Jane' },
  successToast: true,
  errorToast: true,
  customToastMessage: 'User created successfully!'
});

import { RequestError, AuthError, CancelledError } from 'axly';

try {
  await client.request({ method: 'GET', url: '/protected' });
} catch (err) {
  if (err instanceof CancelledError) {
    console.log('Request was cancelled');
  } else if (err instanceof AuthError) {
    console.log('Auth failed — redirect to login');
  } else if (err instanceof RequestError) {
    console.log('Status:', err.response?.status);
    console.log('Code:', err.code);
  }
}

const client = createAxlyClient({
  userAPI: { baseURL: 'https://users.example.com', token: 'user-token' },
  paymentAPI: { baseURL: 'https://pay.example.com', token: 'pay-token' }
});

const users = await client.request({
  method: 'GET',
  url: '/list',
  configId: 'userAPI'
});
const invoices = await client.request({
  method: 'GET',
  url: '/invoices',
  configId: 'paymentAPI'
});

const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  requestInterceptors: [
    (config) => {
      config.headers['X-Request-ID'] = crypto.randomUUID();
      return config;
    }
  ],
  responseInterceptors: [
    (response) => {
      console.log('Response time:', response.headers['x-response-time']);
      return response;
    }
  ]
});

import { createAxlyNodeClient } from 'axly';

const client = createAxlyNodeClient({
  baseURL: 'https://api.example.com',
  token: process.env.API_TOKEN
});

const { data } = await client.request<User[]>({ method: 'GET', url: '/users' });

const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  multiToken: true,
  refreshEndpoint: '/auth/refresh',
  tokenCallbacks: {
    getAccessToken: () => localStorage.getItem('accessToken'),
    setAccessToken: (token) =>
      token ?
        localStorage.setItem('accessToken', token)
      : localStorage.removeItem('accessToken'),
    getRefreshToken: () => localStorage.getItem('refreshToken'),
    setRefreshToken: (token) =>
      token ?
        localStorage.setItem('refreshToken', token)
      : localStorage.removeItem('refreshToken')
  }
});

import { useAuthStore } from './store';

const client = createAxlyClient({
  baseURL: 'https://api.example.com',
  multiToken: true,
  tokenCallbacks: {
    getAccessToken: () => useAuthStore.getState().accessToken,
    setAccessToken: (t) => useAuthStore.getState().setAccessToken(t),
    getRefreshToken: () => useAuthStore.getState().refreshToken,
    setRefreshToken: (t) => useAuthStore.getState().setRefreshToken(t)
  }
});

const unsubscribe = client.on('destroy', () => {
  console.log('Client destroyed — clearing auth state');
});

// Later: stop listening
unsubscribe();

// Destroy the client (clears all caches, deduplication maps, axios instances)
client.destroy();

interface User {
  id: number;
  name: string;
  email: string;
}

interface CreateUserPayload {
  name: string;
  email: string;
}

// Fully typed request
const response = await client.request<User, CreateUserPayload>({
  method: 'POST',
  url: '/users',
  data: { name: 'Jane', email: '[email protected]' }
});

const user: User = response.data;

// Typed multi-config client
const client = createAxlyClient({
  users: { baseURL: 'https://users.example.com' },
  billing: { baseURL: 'https://billing.example.com' }
});
// configId is narrowed to 'users' | 'billing'
await client.request({ method: 'GET', url: '/list', configId: 'users' });

// Typed hooks
const { data } = useAxlyQuery<User[]>({
  client,
  request: { method: 'GET', url: '/users' }
});
// data?.data is User[] | undefined

import type {
  AxlyClient,
  AxlyConfig,
  RequestOptions,
  UploadOptions,
  InvalidateOptions,
  CacheOptions,
  ShouldRetry,
  TokenCallbacks,
  RefreshTokens,
  StateData,
  RequestStatus,
  ToastHandler,
  AxlyQueryOptions,
  AxlyQueryResult,
  AxlyMutationOptions,
  AxlyMutationResult
} from 'axly';

// ShouldRetry signature
const mySRetry: ShouldRetry = (err, attempt) => {
  return err.response?.status === 503 && attempt < 2;
};

import { RequestError, AuthError, CancelledError } from 'axly';

// RequestError properties
err.message; // Error message
err.response; // AxiosResponse | null
err.code; // HTTP status code or Axios error code
err.original; // Original AxiosError