TypeScript SDK Reference

import Avala from "@avala-ai/sdk";

const avala = new Avala({
  apiKey: "avk_...",      // or set AVALA_API_KEY env var
  baseUrl: "https://api.avala.ai/api/v1",  // default
  timeout: 30_000,        // ms
});

const dataset = await avala.datasets.create({
  name: "LiDAR Captures Q1",
  slug: "lidar-captures-q1",
  dataType: "lidar",
  visibility: "private",
  providerConfig: {
    provider: "aws_s3",
    s3_bucket_name: "my-datasets",
    s3_bucket_region: "us-east-1",
    s3_bucket_prefix: "captures/q1/",
    s3_access_key_id: "AKIA...",
    s3_secret_access_key: "your-secret-key",
  },
  ownerName: "my-org",
});

const page = await avala.datasets.list({ dataType: "image", name: "highway", limit: 20 });

const dataset = await avala.datasets.get("550e8400-e29b-41d4-a716-446655440000");

const page = await avala.datasets.listItems("my-org", "my-dataset", { limit: 50 });

const item = await avala.datasets.getItem("my-org", "my-dataset", "item_uid");

const page = await avala.datasets.listSequences("my-org", "my-dataset", { limit: 50 });

const seq = await avala.datasets.getSequence("my-org", "my-dataset", "sequence_uid");

const frame = await avala.datasets.getFrame("my-org", "my-dataset", "sequence_uid", 0);

const calib = await avala.datasets.getCalibration("my-org", "my-dataset", "sequence_uid");

const health = await avala.datasets.getHealth("my-org", "my-dataset");
if (!health.ingestOk) console.error(health.issues);

const page = await avala.projects.list({ limit: 20 });

const project = await avala.projects.get("770a9600-a40d-63f6-c938-668877660000");

const page = await avala.tasks.list({
  project: "proj_uid",
  status: "pending",
  limit: 50,
});

const task = await avala.tasks.get("990c1800-b62f-85a8-e150-880099880000");

const page = await avala.exports.list({ limit: 10 });

const exportJob = await avala.exports.create({ project: "proj_uid" });

const exportJob = await avala.exports.get("export_uid");

const page = await avala.storageConfigs.list();

const config = await avala.storageConfigs.create({
  name: "Production S3",
  provider: "aws_s3",
  s3BucketName: "my-bucket",
  s3BucketRegion: "us-west-2",
  s3AccessKeyId: process.env.AWS_ACCESS_KEY_ID!,
  s3SecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
});

const result = await avala.storageConfigs.test("config_uid");
// { verified: boolean, errors?: Record<string, string[]> }

await avala.storageConfigs.delete("config_uid");

const page = await avala.agents.list({ limit: 20 });

const agent = await avala.agents.get("agent_uid");

const agent = await avala.agents.create({
  name: "QA Bot",
  events: ["task.completed"],
  callbackUrl: "https://example.com/webhook",
  taskTypes: ["annotation"],
});

const agent = await avala.agents.update("agent_uid", {
  isActive: false,
  callbackUrl: "https://example.com/new-webhook",
});

await avala.agents.delete("agent_uid");

const page = await avala.agents.listExecutions("agent_uid", { limit: 50 });

const result = await avala.agents.test("agent_uid");
// { success: boolean }

const page = await avala.inferenceProviders.list();

const provider = await avala.inferenceProviders.get("provider_uid");

const provider = await avala.inferenceProviders.create({
  name: "My SageMaker",
  providerType: "sagemaker",
  config: { endpoint: "my-endpoint", region: "us-east-1" },
});

const provider = await avala.inferenceProviders.update("provider_uid", {
  isActive: false,
});

await avala.inferenceProviders.delete("provider_uid");

const result = await avala.inferenceProviders.test("provider_uid");
// { success: boolean, message: string, testedAt: string }

const page = await avala.autoLabelJobs.list({
  project: "proj_uid",
  status: "completed",
});

const job = await avala.autoLabelJobs.get("job_uid");
console.log(`Progress: ${job.progressPct}%`);

const job = await avala.autoLabelJobs.create("proj_uid", {
  modelType: "object_detection",
  confidenceThreshold: 0.85,
  labels: ["car", "truck"],
});

await avala.autoLabelJobs.cancel("job_uid");

const page = await avala.qualityTargets.list("proj_uid");

const target = await avala.qualityTargets.get("proj_uid", "target_uid");

const target = await avala.qualityTargets.create("proj_uid", {
  name: "Accuracy Target",
  metric: "accuracy",
  operator: "gte",
  threshold: 0.95,
  severity: "critical",
  notifyWebhook: true,
  notifyEmails: ["alerts@example.com"],
});

const target = await avala.qualityTargets.update("proj_uid", "target_uid", {
  threshold: 0.9,
});

await avala.qualityTargets.delete("proj_uid", "target_uid");

const results = await avala.qualityTargets.evaluate("proj_uid");
for (const r of results) {
  console.log(`${r.name}: ${r.currentValue} (breached: ${r.isBreached})`);
}

const summary = await avala.consensus.getSummary("proj_uid");
console.log(`Mean score: ${summary.meanScore}`);
console.log(`Items with consensus: ${summary.itemsWithConsensus}/${summary.totalItems}`);

const page = await avala.consensus.listScores("proj_uid", { limit: 50 });

const result = await avala.consensus.compute("proj_uid");
console.log(result.status);  // "started"

const config = await avala.consensus.getConfig("proj_uid");
console.log(`IoU threshold: ${config.iouThreshold}`);

const config = await avala.consensus.updateConfig("proj_uid", {
  iouThreshold: 0.7,
  minAgreementRatio: 0.8,
  minAnnotations: 3,
});

const page = await avala.webhooks.list();

const webhook = await avala.webhooks.get("webhook_uid");

const webhook = await avala.webhooks.create({
  targetUrl: "https://example.com/webhook",
  events: ["task.completed", "export.ready"],
  isActive: true,
});

const webhook = await avala.webhooks.update("webhook_uid", {
  isActive: false,
});

await avala.webhooks.delete("webhook_uid");

const result = await avala.webhooks.test("webhook_uid");
// { success: boolean }

const page = await avala.webhookDeliveries.list({ limit: 20 });

const delivery = await avala.webhookDeliveries.get("delivery_uid");
console.log(`Status: ${delivery.status}, Attempts: ${delivery.attempts}`);

const page = await avala.organizations.list({ limit: 20 });

const org = await avala.organizations.get("my-org");

const org = await avala.organizations.create({
  name: "My Team",
  visibility: "private",
  industry: "technology",
});

const org = await avala.organizations.update("my-org", {
  name: "New Name",
  description: "Updated description",
});

await avala.organizations.delete("my-org");

const choices = await avala.organizations.industryChoices();

const page = await avala.organizations.listMembers("my-org", { role: "admin" });

await avala.organizations.removeMember("my-org", "user_uid");

await avala.organizations.updateMemberRole("my-org", "user_uid", { role: "admin" });

await avala.organizations.leave("my-org");

await avala.organizations.transferOwnership("my-org", { newOwnerUid: "new_owner_uid" });

const invitations = await avala.organizations.listInvitations("my-org");

const invitation = await avala.organizations.createInvitation("my-org", {
  email: "user@example.com",
  role: "member",
});

await avala.organizations.resendInvitation("my-org", "invitation_uid");

await avala.organizations.cancelInvitation("my-org", "invitation_uid");

const teams = await avala.organizations.listTeams("my-org");

const team = await avala.organizations.createTeam("my-org", {
  name: "ML Engineers",
  description: "Machine learning team",
});

const team = await avala.organizations.getTeam("my-org", "team_slug");

const team = await avala.organizations.updateTeam("my-org", "team_slug", { name: "Updated Name" });

await avala.organizations.deleteTeam("my-org", "team_slug");

const members = await avala.organizations.listTeamMembers("my-org", "team_slug");

const member = await avala.organizations.addTeamMember("my-org", "team_slug", {
  userUid: "user_uid",
  role: "member",
});

await avala.organizations.removeTeamMember("my-org", "team_slug", "user_uid");

await avala.organizations.updateTeamMemberRole("my-org", "team_slug", "user_uid", {
  role: "lead",
});

const page = await avala.slices.list("my-org", { limit: 20 });

const slice = await avala.slices.get("my-org", "my-slice");

const slice = await avala.slices.create({
  name: "Validation Set",
  visibility: "private",
  subSlices: [{ dataset: "dataset_uid", filters: {} }],
  organization: "my-org",
});

const page = await avala.slices.listItems("my-org", "my-slice", { limit: 50 });

const item = await avala.slices.getItem("my-org", "my-slice", "item_uid");

interface Dataset {
  uid: string;
  name: string;
  slug: string;
  itemCount: number;
  dataType: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface DatasetItem {
  id: number | null;
  uid: string;
  key: string | null;
  dataset: string | null;
  url: string | null;
  gpuTextureUrl: string | null;
  thumbnails: string[] | null;
  videoThumbnail: string | null;
  metadata: Record<string, unknown> | null;
  exportSnippet: Record<string, unknown> | null;
  annotations: Record<string, unknown> | null;
  cropData: Record<string, unknown> | null;
  relatedItems: Record<string, unknown>[] | null;
  relatedSequenceUid: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface DatasetSequence {
  uid: string;
  key: string | null;
  customUuid: string | null;
  status: string | null;
  featuredImage: string | null;
  numberOfFrames: number | null;
  views: Record<string, unknown>[] | null;
  cropData: Record<string, unknown> | null;
  predefinedLabels: Record<string, unknown>[] | null;
  frames: Record<string, unknown>[] | null;
  metrics: Record<string, unknown> | null;
  datasetUid: string | null;
  allowLidarCalibration: boolean | null;
  lidarCalibrationEnabled: boolean | null;
  cameraCalibrationEnabled: boolean | null;
}

interface Project {
  uid: string;
  name: string;
  status: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface Task {
  uid: string;
  type: string | null;
  name: string | null;
  status: string | null;
  project: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface Export {
  uid: string;
  status: string | null;
  downloadUrl: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface StorageConfig {
  uid: string;
  name: string;
  provider: string;
  s3BucketName: string | null;
  s3BucketRegion: string | null;
  s3BucketPrefix: string | null;
  s3IsAccelerated: boolean;
  gcStorageBucketName: string | null;
  gcStoragePrefix: string | null;
  isVerified: boolean;
  lastVerifiedAt: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface Agent {
  uid: string;
  name: string;
  description: string | null;
  events: string[];
  callbackUrl: string | null;
  isActive: boolean;
  project: string | null;
  taskTypes: string[];
  createdAt: string | null;
  updatedAt: string | null;
}

interface AgentExecution {
  uid: string;
  registration: string;
  eventType: string;
  task: string | null;
  result: string | null;
  status: string | null;
  action: string | null;
  eventPayload: Record<string, unknown> | null;
  responsePayload: Record<string, unknown> | null;
  errorMessage: string | null;
  startedAt: string | null;
  completedAt: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface InferenceProvider {
  uid: string;
  name: string;
  description: string | null;
  providerType: string | null;
  config: Record<string, unknown> | null;
  isActive: boolean;
  project: string | null;
  lastTestAt: string | null;
  lastTestSuccess: boolean | null;
  createdAt: string | null;
  updatedAt: string | null;
}

interface AutoLabelJob {
  uid: string;
  status: string | null;
  modelType: string | null;
  confidenceThreshold: number | null;
  labels: string[];
  dryRun: boolean;
  totalItems: number;
  processedItems: number;
  successfulItems: number;
  failedItems: number;
  skippedItems: number;
  progressPct: number | null;
  errorMessage: string | null;
  summary: Record<string, unknown> | null;
  startedAt: string | null;
  completedAt: string | null;
  createdAt: string | null;
}

interface QualityTarget {
  uid: string;
  name: string;
  metric: string;
  operator: string;
  threshold: number;
  severity: string | null;
  isActive: boolean;
  notifyWebhook: boolean;
  notifyEmails: string[];
  lastEvaluatedAt: string | null;
  lastValue: number | null;
  isBreached: boolean;
  breachCount: number;
  lastBreachedAt: string | null;
  createdAt: string | null;
  updatedAt: string | null;
}