TypeScript Examples

interface IPOResponse {
  meta: {
    count: number;
    countOnPage: number;
    totalPages: number;
    page: number;
    limit: number;
  };
  ipos: IPO[];
}

interface IPO {
  id: string;
  name: string;
  symbol: string;
  slug: string;
  type?: string;
  startDate?: string;
  endDate?: string;
  listingDate?: string;
  priceRange?: string;
  listingGain?: string;
  minQty?: number;
  minAmount?: number;
  issueSize?: string;
  status?: string;
  logo?: string;
  prospectusUrl?: string;
  schedule?: ScheduleItem[];
  about?: string;
  strengths?: string[];
  risks?: string[];
  mediaCoverageLinks?: string[];
  nseInfoUrl?: string;
  infoUrl?: string;
}

interface ScheduleItem {
  event: string;
  date: string;
}

interface IPODetailResponse {
  ipo: IPO;
}

class IPOAlertsClient {
  private apiKey: string;
  private baseURL: string;

  constructor(apiKey: string) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.ipoalerts.in';
  }

  private async makeRequest<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
    const response = await fetch(`${this.baseURL}${endpoint}`, {
      ...options,
      headers: {
        'x-api-key': this.apiKey,
        'Content-Type': 'application/json',
        ...options.headers,
      },
    });

    if (!response.ok) {
      throw new Error(`HTTP error: ${response.status}`);
    }

    return response.json();
  }

  async getIPOs(
    status?: string,
    type?: string,
    page: number = 1,
    limit: number = 10
  ): Promise<IPOResponse> {
    const params = new URLSearchParams();
    if (status) params.append('status', status);
    if (type) params.append('type', type);
    params.append('page', page.toString());
    params.append('limit', limit.toString());

    return this.makeRequest<IPOResponse>(`/ipos?${params}`);
  }

  async getIPO(identifier: string): Promise<IPO> {
    const response = await this.makeRequest<IPODetailResponse>(`/ipos/${identifier}`);
    return response.ipo;
  }
}

// Usage
async function main() {
  const client = new IPOAlertsClient('YOUR_API_KEY');

  try {
    // Get upcoming IPOs
    const ipos = await client.getIPOs('upcoming', 'EQ', 1, 10);
    console.log(`Found ${ipos.meta.count} upcoming equity IPOs`);

    ipos.ipos.forEach(ipo => {
      console.log(`${ipo.name} (${ipo.symbol}) - ${ipo.priceRange}`);
    });

    // Get specific IPO
    const ipoDetails = await client.getIPO('example-company-limited');
    console.log(`IPO Details: ${ipoDetails.name}`);

  } catch (error) {
    console.error('Error:', error);
  }
}

main();

import { useState, useEffect, useCallback } from 'react';

interface UseIPOAlertsReturn {
  loading: boolean;
  error: string | null;
  data: IPOResponse | null;
  getIPOs: (filters?: IPOFilters) => Promise<IPOResponse>;
  getIPO: (identifier: string) => Promise<IPO>;
}

interface IPOFilters {
  status?: string;
  type?: string;
  page?: number;
  limit?: number;
}

const useIPOAlerts = (apiKey: string): UseIPOAlertsReturn => {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [data, setData] = useState<IPOResponse | null>(null);

  const makeRequest = useCallback(async <T>(endpoint: string, options: RequestInit = {}): Promise<T> => {
    setLoading(true);
    setError(null);

    try {
      const response = await fetch(`https://api.ipoalerts.in${endpoint}`, {
        ...options,
        headers: {
          'x-api-key': apiKey,
          'Content-Type': 'application/json',
          ...options.headers
        }
      });

      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }

      const result = await response.json();
      setData(result);
      return result;
    } catch (err) {
      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  }, [apiKey]);

  const getIPOs = useCallback(async (filters: IPOFilters = {}): Promise<IPOResponse> => {
    const params = new URLSearchParams();
    if (filters.status) params.append('status', filters.status);
    if (filters.type) params.append('type', filters.type);
    if (filters.page) params.append('page', filters.page.toString());
    if (filters.limit) params.append('limit', filters.limit.toString());
    
    return makeRequest<IPOResponse>(`/ipos?${params}`);
  }, [makeRequest]);

  const getIPO = useCallback(async (identifier: string): Promise<IPO> => {
    const response = await makeRequest<IPODetailResponse>(`/ipos/${identifier}`);
    return response.ipo;
  }, [makeRequest]);

  return {
    loading,
    error,
    data,
    getIPOs,
    getIPO
  };
};

export default useIPOAlerts;