npm install @rotastellar/sdk

# Yarn
yarn add @rotastellar/sdk

# pnpm
pnpm add @rotastellar/sdk

# Bun
bun add @rotastellar/sdk

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

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

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

// Track a satellite
const iss = await client.getSatellite('25544');
console.log(`ISS: ${iss.position?.latitude}, ${iss.position?.longitude}`);

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

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

// Get satellite by NORAD ID
const sat = await client.getSatellite('25544'); // ISS
console.log(`Name: ${sat.name}`);
console.log(`Position: ${sat.position?.latitude}, ${sat.position?.longitude}`);
console.log(`Altitude: ${sat.position?.altitudeKm} km`);

// Get position only
const pos = await client.getSatellitePosition('25544');
console.log(`Position: ${pos.latitude}, ${pos.longitude} at ${pos.altitudeKm} km`);

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

for (const sat of satellites) {
  console.log(`${sat.name}: ${sat.noradId}`);
}

// Filter by operator
const spacexSats = await client.listSatellites({
  operator: 'SpaceX',
  limit: 50
});

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

// Get conjunction risks for a satellite
const conjunctions = await client.listConjunctions({
  satelliteId: '25544',
  thresholdKm: 5.0,
  limit: 10
});

for (const conj of conjunctions) {
  console.log(`TCA: ${conj.tca}`);
  console.log(`Miss distance: ${conj.miss_distance_km.toFixed(3)} km`);
  console.log(`Probability: ${conj.collision_probability.toExponential(2)}`);
}

// Detect maneuvers and anomalies
const patterns = await client.listPatterns({
  satelliteId: '44832', // COSMOS-2542
  lookbackDays: 30
});

for (const pattern of patterns) {
  console.log(`${pattern.type}: ${pattern.description}`);
  console.log(`Confidence: ${(pattern.confidence * 100).toFixed(1)}%`);
}

// Get predicted trajectory
const trajectory = await client.getTrajectory({
  satelliteId: '25544',
  start: new Date(),
  end: new Date(Date.now() + 2 * 60 * 60 * 1000), // +2 hours
  intervalSec: 60
});

for (const point of trajectory) {
  console.log(`${point.timestamp}: ${point.latitude.toFixed(2)}, ${point.longitude.toFixed(2)}`);
}

// Analyze if orbital compute is viable for your workload
const result = await client.analyzeFeasibility({
  workloadType: 'inference',
  computeTflops: 10,
  dataGb: 1.5,
  latencyRequirementMs: 100,
  orbitAltitudeKm: 550
});

console.log(`Feasible: ${result.feasible}`);
console.log(`Recommendation: ${result.recommendation}`);

// Model heat rejection in orbit
const thermal = await client.simulateThermal({
  powerWatts: 500,
  orbitAltitudeKm: 550,
  radiatorAreaM2: 2.0,
  durationHours: 24
});

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

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

// Model end-to-end latency
const source = new Position(37.7749, -122.4194); // San Francisco
const dest = new Position(51.5074, -0.1278);     // London

const latency = await client.simulateLatency({
  source,
  destination: dest,
  orbitAltitudeKm: 550,
  relayCount: 2
});

console.log(`Total latency: ${latency.total_latency_ms?.toFixed(1)} ms`);

// Submit inference job to orbital compute
const job = await client.submitJob({
  model: 'llama-70b',
  prompt: '...',
  constraints: {
    latencySlams: 200,
    energyBudgetWh: 0.5
  }
});

// Get result
const result = await client.getJobResult(job.id, { timeout: 30000 });
console.log(result.text);

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

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

console.log(`Page has ${page.items.length} items, hasMore=${page.hasMore}`);

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

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

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

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

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

const sat: Satellite = await client.getSatellite('25544');
const pos: Position = sat.position!;
const orbit: Orbit = sat.orbit!;

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

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

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

try {
  const sat = await client.getSatellite('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}`);
  }
}

const controller = new AbortController();

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

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

npm install @rotastellar/distributed

import { FederatedClient, CompressionConfig, CompressionMethod } from '@rotastellar/distributed';

// Configure gradient compression (100x reduction)
const compression: CompressionConfig = {
  method: CompressionMethod.TOP_K_QUANTIZED,
  kRatio: 0.01,
  quantizationBits: 8,
  errorFeedback: true
};

// Initialize client on orbital node
const client = new FederatedClient({
  nodeId: 'orbital-3',
  nodeType: 'orbital',
  compression
});

// Compute and compress gradients for transmission
const gradients = client.computeGradients(modelParams, localData);
const compressed = client.compress(gradients);

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

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

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