import { generateApiClient } from '@g1/api-generator';

async function generateApi() {
  await generateApiClient({
    schemaUrl: 'https://your-api-server/openapi/schema.json',
    outputDir: './src/lib/api',
    skipTlsVerify: true, // Optional, default: false
    runPostProcessing: true, // Optional, default: true
    clientName: 'MyApiClient' // Optional, enables factory pattern for multiple endpoints
  });
}

generateApi().catch(console.error);

import { ClientFactory } from './src/lib/api/ClientFactory';

// Create multiple clients for different endpoints
const client1 = ClientFactory.create({
  endpoint: 'https://api1.example.com'
});

const client2 = ClientFactory.create({
  endpoint: 'https://api2.example.com',
  token: 'your-auth-token'
});

// Both clients can be used simultaneously
const response1 = await client1.users.getUsers();
const response2 = await client2.orders.getOrders();

import { ClientFactory } from './src/lib/api/ClientFactory';

const client = ClientFactory.create({
  endpoint: 'https://api.example.com',
  token: 'your-auth-token',
  headers: {
    'X-Custom-Header': 'custom-value'
  },
  timeout: 10000 // 10 seconds
});

import { ClientFactory } from './src/lib/api/ClientFactory';

const client = ClientFactory.create({
  endpoint: 'https://secure-api.com'
});

// Override the request method to add custom signature
const originalRequest = client.request;
client.request = async (options: any) => {
  const timestamp = Date.now().toString();
  const requestData = JSON.stringify({
    method: options.method,
    url: options.url,
    body: options.body,
    timestamp
  });

  // Generate signature (replace with actual crypto implementation)
  const signature = await generatePublicKeySignature(requestData, 'your-private-key');

  // Add signature headers
  options.headers = {
    ...options.headers,
    'X-Timestamp': timestamp,
    'X-Signature': signature,
    'X-Public-Key-ID': 'your-public-key-id'
  };

  return originalRequest.call(client, options);
};

// All requests now include the signature
const data = await client.users.getUsers();

// OAuth2 API
const oauthClient = ClientFactory.create({
  endpoint: 'https://oauth-api.com',
  token: 'bearer-token'
});

// API Key API
const apiKeyClient = ClientFactory.create({
  endpoint: 'https://apikey-api.com',
  headers: {
    'X-API-Key': 'your-api-key'
  }
});

// Custom JWT API with request interception
const jwtClient = ClientFactory.create({
  endpoint: 'https://jwt-api.com'
});

jwtClient.request = async (options: any) => {
  const token = await generateJWT({
    issuer: 'your-app',
    audience: 'jwt-api.com',
    privateKey: 'your-jwt-private-key'
  });

  options.headers = {
    ...options.headers,
    'Authorization': `Bearer ${token}`
  };

  return originalRequest.call(jwtClient, options);
};

// Use all clients simultaneously with their respective security systems
const [oauthData, apiKeyData, jwtData] = await Promise.all([
  oauthClient.users.getUsers(),
  apiKeyClient.products.getProducts(),
  jwtClient.analytics.getAnalytics()
]);

import { MyApiClient, createClient } from './src/lib/api';

// Legacy approach (still works)
const api = new MyApiClient({
  BASE: 'https://api.example.com',
  TOKEN: 'your-token'
});

// Or using the legacy helper function
const api2 = createClient({
  BASE: 'https://api.example.com',
  TOKEN: 'your-token'
});

import { ApiClient } from './src/lib/api';
const api = new ApiClient({ BASE: 'https://api.example.com', TOKEN: 'token' });