npm install @rotastellar/sdk

# Yarn
yarn add @rotastellar/sdk

# pnpm
pnpm add @rotastellar/sdk

# Bun
bun add @rotastellar/sdk

import { RotaStellar } from '@rotastellar/sdk';

// Initialize client
const client = new RotaStellar({ apiKey: 'rs_your_api_key' });

// Or use environment variable
// export ROTASTELLAR_API_KEY=rs_your_api_key
const client = new RotaStellar();

// Track a satellite
const iss = await client.intelligence.satellite('ISS');
const pos = await iss.position();
console.log(`ISS: ${pos.lat}, ${pos.lon}`);

import { RotaStellar } from '@rotastellar/sdk';

const client = new RotaStellar({
  apiKey: 'rs_...',
  baseUrl: 'https://api.rotastellar.com/v1', // Default
  timeout: 30000,    // Request timeout in ms
  maxRetries: 3,     // Retry failed requests
});

// Feasibility analysis
const feasibility = await client.planning.analyze({
  workload: 'ai_inference',
  computeTflops: 100,
  storageTb: 10,
  bandwidthGbps: 1
});

console.log(`Recommended: ${feasibility.recommendation}`);
console.log(`Orbit: ${feasibility.orbit}`);
console.log(`Monthly cost: $${feasibility.costMonthly}`);

// Thermal simulation
const thermal = await client.planning.thermal({
  orbit: 'LEO-550',
  powerDissipationW: 500,
  radiatorAreaM2: 2.0
});

console.log(`Max temp: ${thermal.maxTempC}°C`);

// Latency simulation
const latency = await client.planning.latency({
  orbit: 'LEO-550',
  groundStations: ['us-west', 'europe', 'asia'],
  includeIsl: true
});

console.log(`P50: ${latency.p50Ms}ms`);
console.log(`P99: ${latency.p99Ms}ms`);

// Power budgeting
const power = await client.planning.power({
  orbit: 'LEO-550',
  computeLoadW: 500,
  dutyCycle: 0.8,
  missionLifeYears: 5
});

console.log(`Solar array: ${power.solarArrayM2} m²`);

// Get satellite
const sat = await client.intelligence.satellite('STARLINK-1234');
const pos = await sat.position();
const orbit = await sat.orbit();

console.log(`Position: ${pos.lat}, ${pos.lon}`);
console.log(`Altitude: ${pos.altitudeKm} km`);
console.log(`Period: ${orbit.periodMin} minutes`);

// List satellites
const starlinks = await client.intelligence.satellites({
  constellation: 'Starlink',
  limit: 100
});

for (const s of starlinks) {
  console.log(s.name);
}

// Trajectory
const trajectory = await sat.trajectory({
  start: new Date(),
  end: new Date(Date.now() + 24 * 60 * 60 * 1000), // +24h
  intervalSec: 300
});

for (const point of trajectory.points) {
  console.log(`${point.timestamp}: ${point.lat}, ${point.lon}`);
}

// Conjunction analysis
const conjunctions = await client.intelligence.conjunctions({
  satellite: 'STARLINK-1234',
  thresholdKm: 1.0,
  daysAhead: 7
});

for (const conj of conjunctions) {
  console.log(`TCA: ${conj.tca}, Miss: ${conj.missKm}km`);
}

// Pattern detection
const patterns = await client.intelligence.patterns({
  satellite: 'COSMOS-2542',
  lookbackDays: 30
});

for (const pattern of patterns) {
  console.log(`${pattern.type}: ${pattern.description}`);
}

// Submit job
const job = await client.runtime.submit({
  model: 'llama-70b',
  prompt: '...',
  constraints: {
    latencySlams: 200,
    energyBudgetWh: 0.5
  }
});

// Get result
const result = await job.result({ timeout: 30000 });
console.log(result.text);
console.log(result.adaptations);

import { RotaStellar } from '@rotastellar/sdk';
import type {
  Satellite,
  Position,
  Orbit,
  Conjunction,
  Pattern,
  FeasibilityResult
} from '@rotastellar/sdk';

const client = new RotaStellar({ apiKey: 'rs_...' });

const sat: Satellite = await client.intelligence.satellite('ISS');
const pos: Position = await sat.position();
const orbit: Orbit = await sat.orbit();

// Full autocomplete and type checking
console.log(pos.lat);         // number
console.log(pos.lon);         // number
console.log(pos.altitudeKm);  // number
console.log(orbit.periodMin); // number

import { RotaStellar } from '@rotastellar/sdk';
import {
  AuthenticationError,
  RateLimitError,
  NotFoundError,
  ValidationError,
  APIError
} from '@rotastellar/sdk';

const client = new RotaStellar({ apiKey: 'rs_...' });

try {
  const sat = await client.intelligence.satellite('INVALID-ID');
} catch (error) {
  if (error instanceof NotFoundError) {
    console.log('Satellite not found');
  } else if (error instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${error.retryAfter}s`);
  } else if (error instanceof AuthenticationError) {
    console.log('Invalid API key');
  } else if (error instanceof ValidationError) {
    console.log(`Invalid request: ${error.message}`);
  } else if (error instanceof APIError) {
    console.log(`API error: ${error.message}`);
  }
}

// Automatic pagination with async iteration
for await (const sat of client.intelligence.satellites({
  constellation: 'Starlink'
})) {
  console.log(sat.name);
}

// Manual pagination
let page = await client.intelligence.satellites({
  constellation: 'Starlink',
  limit: 100
});

while (page) {
  for (const sat of page.items) {
    console.log(sat.name);
  }

  if (page.hasMore) {
    page = await page.nextPage();
  } else {
    break;
  }
}

// Stream conjunction updates
const stream = client.intelligence.conjunctions.stream({
  satellite: 'STARLINK-1234',
  thresholdKm: 5.0
});

for await (const update of stream) {
  console.log(`New conjunction: ${update.tca}, Miss: ${update.missKm}km`);
}

const controller = new AbortController();

// Cancel after 5 seconds
setTimeout(() => controller.abort(), 5000);

try {
  const result = await client.planning.analyze({
    workload: 'ai_inference',
    computeTflops: 100
  }, { signal: controller.signal });
} catch (error) {
  if (error.name === 'AbortError') {
    console.log('Request cancelled');
  }
}

import { RotaStellar } from '@rotastellar/sdk';

const client = new RotaStellar({
  apiKey: 'rs_...',
  debug: true  // Logs all requests/responses
});

// Or use custom logger
const client = new RotaStellar({
  apiKey: 'rs_...',
  logger: {
    debug: console.debug,
    info: console.info,
    warn: console.warn,
    error: console.error
  }
});