API Reference¶

npm install @telcoapi/client

import { TelcoAPI } from '@telcoapi/client';

const client = new TelcoAPI({
  apiKey: 'your-api-key',
  environment: 'production', // or 'sandbox'
  timeout: 30000, // 30 seconds
  retries: 3
});

interface MTP3Config {
  pointCode: string;
  networkIndicator: 'international' | 'national' | 'reserved';
  serviceIndicator: 'sccp' | 'isup' | 'tup';
}

await client.ss7.configureMTP3(config: MTP3Config): Promise<void>

interface RouteConfig {
  destination: string;
  linkset: string;
  priority: number;
}

await client.ss7.addRoute(config: RouteConfig): Promise<void>
await client.ss7.removeRoute(destination: string): Promise<void>

interface GTTConfig {
  tt: number;
  np: number;
  nai: number;
  address: string;
  routingIndicator: 'gt' | 'ssn';
}

await client.ss7.configureGTT(config: GTTConfig): Promise<void>

interface TCAPMessage {
  dialogType: 'BEGIN' | 'CONTINUE' | 'END' | 'ABORT';
  components: Array<{
    type: 'invoke' | 'returnResult' | 'returnError' | 'reject';
    operationCode: string | number;
    parameter?: any;
  }>;
}

await client.ss7.sendTCAP(message: TCAPMessage): Promise<TCAPResponse>

interface DiameterSession {
  sessionId: string;
  authApplicationId: number;
  originHost: string;
  originRealm: string;
}

await client.diameter.createSession(config: DiameterSession): Promise<Session>

interface AuthRequest {
  sessionId: string;
  userName: string;
  authSessionState: number;
  originHost: string;
  originRealm: string;
}

await client.diameter.sendAuthRequest(request: AuthRequest): Promise<AuthAnswer>

interface CCRequest {
  sessionId: string;
  requestType: 'INITIAL' | 'UPDATE' | 'TERMINATE';
  subscriptionId: string;
  requestedAction?: 'DIRECT_DEBITING' | 'REFUND_ACCOUNT';
  serviceIdentifier?: number;
}

await client.diameter.sendCCR(request: CCRequest): Promise<CCAnswer>

interface SIPRegistration {
  username: string;
  password: string;
  realm: string;
  expires?: number;
  contactUri?: string;
}

await client.sip.register(config: SIPRegistration): Promise<void>

interface CallOptions {
  to: string;
  from: string;
  mediaOptions: {
    audio: boolean;
    video: boolean;
    codecs?: string[];
  };
}

const call = await client.sip.call(options: CallOptions): Promise<Call>

// Call instance methods
call.answer(mediaOptions?: MediaOptions): Promise<void>
call.reject(code?: number, reason?: string): Promise<void>
call.terminate(): Promise<void>

interface MessageOptions {
  to: string;
  content: string;
  contentType?: string;
  headers?: Record<string, string>;
}

await client.sip.sendMessage(options: MessageOptions): Promise<void>

interface IPXConfig {
  networkId: string;
  services: string[];
  qosClass: string;
  redundancy: boolean;
}

await client.ipx.configure(config: IPXConfig): Promise<void>

interface QoSProfile {
  latency: {
    max: number;
    target: number;
  };
  jitter: {
    max: number;
    target: number;
  };
  packetLoss: {
    max: number;
    target: number;
  };
}

await client.ipx.setQoSProfile(profile: QoSProfile): Promise<void>

interface APIError {
  code: string;
  message: string;
  details?: any;
  requestId?: string;
}

try {
  await client.ss7.sendTCAP(message);
} catch (error) {
  if (error.code === 'NETWORK_ERROR') {
    // Implement retry logic
    await retry(() => client.ss7.sendTCAP(message));
  } else {
    // Log error and handle appropriately
    console.error(`Error: ${error.code}`, error.details);
  }
}

interface WebhookConfig {
  url: string;
  events: string[];
  secret: string;
}

await client.configureWebhook(config: WebhookConfig): Promise<void>

interface WebhookPayload {
  event: string;
  timestamp: string;
  data: any;
  signature: string;
}