const artifact: Artifact = {
  id: "artifact_abc123",
  name: "model-weights",
  type: artifactType,
  description: "Trained model weights",
  aliases: ["latest", "production"],
  createdAt: new Date("2024-01-15")
};

const artifactType: ArtifactType = {
  name: "model"
};

const artifactVersion: ArtifactVersion = {
  id: "version_xyz789",
  version: "v3",
  versionIndex: 3,
  aliases: ["latest", "production"],
  createdAt: new Date("2024-01-15"),
  metadata: {
    accuracy: 0.95,
    model_type: "transformer"
  }
};

// Typical ML configuration:
const config: ConfigDict = {
  // Training hyperparameters
  learning_rate: 0.001,
  batch_size: 32,
  epochs: 100,
  optimizer: "adam",
  
  // Model architecture
  model_name: "resnet50",
  num_layers: 50,
  dropout_rate: 0.2,
  hidden_dims: [512, 256, 128],
  
  // Data settings
  dataset: "imagenet",
  augmentation: true,
  train_split: 0.8,
  
  // System settings
  device: "cuda",
  num_workers: 4,
  seed: 42
};

// What you see after logging a W&B Table to config:
const config: ConfigDict = {
  // ... your normal config ...
  
  // This appears automatically when you log wandb.Table() to config:
  "evaluation_results": {
    "_type": "table-file",
    "ncols": 5,
    "nrows": 100,
    "path": "media/table/eval_results_2_abc123.table.json"
  }
};

// What you see after referencing an artifact in config:
const config: ConfigDict = {
  // ... your normal config ...
  
  // This appears when you use an artifact:
  "model_artifact": {
    "_type": "artifactVersion",
    "id": "QXJ0aWZhY3Q6MTIzNDU2",
    "version": "v3",
    "path": "model-weights:v3"
  }
};

// Nested configuration groups
const config: ConfigDict = {
  optimizer: {
    type: "adam",
    betas: [0.9, 0.999],
    weight_decay: 0.0001
  },
  scheduler: {
    type: "cosine",
    warmup_steps: 1000
  }
};

// Environment and metadata
const config: ConfigDict = {
  experiment_name: "baseline_v2",
  git_commit: "abc123def",
  python_version: "3.9.7",
  cuda_version: "11.8"
};

const entity: Entity = {
  id: "entity_abc123",
  name: "my-team",
  isTeam: true
};

const project: Project = {
  name: "my-awesome-project",
  entity: entity,
  createdAt: new Date("2023-01-01"),
  updatedAt: new Date("2024-01-20")
};

const run: Run = {
  id: "run_abc123",
  name: "sunny-dawn-42",
  state: "finished",
  config: {
    learning_rate: 0.001,
    batch_size: 32,
    epochs: 10
  },
  summaryMetrics: {
    loss: 0.023,
    accuracy: 0.95,
    val_accuracy: 0.93
  },
  createdAt: new Date("2024-01-15T10:30:00Z"),
  updatedAt: new Date("2024-01-15T14:45:00Z")
};

// Typical training summary:
const summary: SummaryDict = {
  // Final metrics
  final_loss: 0.0234,
  final_accuracy: 0.9523,
  
  // Best values during training
  best_val_loss: 0.0198,
  best_val_accuracy: 0.9612,
  best_epoch: 87,
  
  // Training statistics
  total_train_time: 3600.5,  // seconds
  total_steps: 50000,
  early_stopped: false,
  
  // Test set results
  test_accuracy: 0.9487,
  test_f1_score: 0.9465
};

// What you see after logging W&B special types to summary:
const summary: SummaryDict = {
  // ... your normal metrics ...
  
  // This appears when you log wandb.Histogram():
  "weight_distribution": {
    "_type": "histogram",
    "bins": [0, 0.1, 0.2, 0.3, 0.4, 0.5],
    "values": [10, 25, 45, 30, 15, 5]
  },
  
  // This appears when you log wandb.Table():
  "predictions_table": {
    "_type": "table-file", 
    "ncols": 4,
    "nrows": 1000,
    "path": "media/table/predictions_3_def456.table.json"
  },
  
  // This appears when you reference an artifact:
  "best_model": {
    "_type": "artifactVersion",
    "id": "QXJ0aWZhY3Q6OTg3NjU0",
    "version": "v12",
    "path": "model-checkpoint:v12"
  }
};

// Grouped metrics by dataset split
const summary: SummaryDict = {
  train: {
    loss: 0.023,
    accuracy: 0.975,
    samples_seen: 50000
  },
  validation: {
    loss: 0.045,
    accuracy: 0.948,
    samples_seen: 10000
  },
  test: {
    loss: 0.041,
    accuracy: 0.951,
    samples_seen: 10000
  }
};

// Multi-class classification results
const summary: SummaryDict = {
  accuracy: 0.92,
  macro_f1: 0.91,
  per_class_precision: [0.95, 0.89, 0.92, 0.90],
  per_class_recall: [0.93, 0.91, 0.90, 0.92],
  confusion_matrix_logged: true  // Actual matrix logged as W&B Table
};

// Model information
const summary: SummaryDict = {
  total_parameters: 125_000_000,
  trainable_parameters: 124_500_000,  
  model_size_mb: 476.8,
  inference_time_ms: 23.4
};

const table: Table = {
  columns: ["epoch", "loss", "accuracy"],
  data: [
    [1, 0.5, 0.75],
    [2, 0.3, 0.85],
    [3, 0.2, 0.90]
  ]
};

const user: User = {
  id: "user_123",
  username: "john_doe",
  name: "John Doe",
  email: "john@example.com"
};

artifactLink(artifact): string

const link = artifactLink(myArtifact);
console.log(View artifact: ${link});
// Output: https://wandb.ai/entity/project/artifacts/type/name

const artifacts = project.artifacts();
const markdown = artifacts.map(a => 
  - ${artifactName(a)}})
).join('\n');

artifactName(artifact): string

artifacts.forEach(artifact => {
  console.log(Artifact: ${artifactName(artifact)});
});

const modelArtifacts = artifacts.filter(a => 
  artifactName(a).includes("model")
);

artifactVersionAlias(version): string

const prodVersion = versions.find(v => 
  artifactVersionAlias(v) === "production"
);

artifactVersionCreatedAt(version): Date

const sorted = versions.sort((a, b) => 
  artifactVersionCreatedAt(a).getTime() - 
  artifactVersionCreatedAt(b).getTime()
);

artifactVersionDigest(version): string

const digest = artifactVersionDigest(version);
const expected = "sha256:abc123...";
if (digest !== expected) {
  console.error("Artifact integrity check failed!");
}

artifactVersionNumber(version): number

const versions = artifactVersions(artifact);
const maxVersion = Math.max(...versions.map(v => 
  artifactVersionNumber(v)
));
console.log(Latest version: v${maxVersion});

artifactVersionSize(version): number

const bytes = artifactVersionSize(version);
const mb = (bytes / 1e6).toFixed(2);
console.log(Size: ${mb} MB);

const largeVersions = versions.filter(v => 
  artifactVersionSize(v) > 1e9 // > 1GB
);

artifactVersions(artifact): ArtifactVersion[]

const versions = artifactVersions(myArtifact);
versions.forEach(v => {
  console.log(v${v.version}: ${v.alias} (${v.size} bytes));
});

const versions = artifactVersions(artifact);
const latest = versions.find(v => v.alias === "latest");
if (latest) {
  console.log(Latest is v${latest.version});
}

const versions = artifactVersions(artifact);
const totalSize = versions.reduce((sum, v) => sum + v.size, 0);
console.log(Total storage: ${(totalSize / 1e9).toFixed(2)} GB);

runConfig(run): ConfigDict

const config = runConfig(myRun);
console.log(config.learning_rate); // 0.001
console.log(config.batch_size);    // 32

// Find all runs with learning rate > 0.01
const highLRRuns = runs.filter(run => {
  const config = runConfig(run);
  return config.learning_rate > 0.01;
});

const config1 = runConfig(baseline);
const config2 = runConfig(experiment);
const differences = Object.keys(config1).filter(key => 
  config1[key] !== config2[key]
);

runCreatedAt(run): Date

const oneWeekAgo = new Date();
oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);

const recentRuns = runs.filter(run => 
  runCreatedAt(run) > oneWeekAgo
);

const sortedRuns = runs.sort((a, b) => 
  runCreatedAt(a).getTime() - runCreatedAt(b).getTime()
);

const runsByDate = runs.reduce((groups, run) => {
  const date = runCreatedAt(run).toDateString();
  groups[date] = groups[date] || [];
  groups[date].push(run);
  return groups;
}, {});

runHeartbeatAt(run): Date

const isActive = (run: Run) => {
  const lastHeartbeat = runHeartbeatAt(run);
  const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
  return lastHeartbeat > fiveMinutesAgo;
};

runJobType(run): string | undefined

const trainingRuns = runs.filter(run => 
  runJobType(run) === "train"
);
const evalRuns = runs.filter(run => 
  runJobType(run) === "eval"
);

runLoggedArtifactVersion(run, artifactVersionName): ArtifactVersion | undefined

const model = runLoggedArtifactVersion(run, "model:latest");
if (model) {
  console.log(Model version: v${model.version});
  console.log(Model size: ${model.size} bytes);
  console.log(Created: ${model.createdAt});
}

const requiredOutputs = ["model:latest", "evaluation:latest"];
const missing = requiredOutputs.filter(name => 
  !runLoggedArtifactVersion(run, name)
);
if (missing.length > 0) {
  console.warn(Missing outputs: ${missing.join(", ")});
}

runLoggedArtifactVersions(run): ArtifactVersion[]

const outputs = runLoggedArtifactVersions(run);
outputs.forEach(artifact => {
  console.log(Logged: ${artifact.name}:${artifact.alias});
  console.log(  Version: ${artifact.version});
  console.log(  Size: ${artifact.size} bytes);
});

const outputs = runLoggedArtifactVersions(run);
const modelCount = outputs.filter(a => a.name.includes("model")).length;
const dataCount = outputs.filter(a => a.name.includes("data")).length;
console.log(Models: ${modelCount}, Datasets: ${dataCount});

runName(run): string

runs.forEach(run => {
  console.log(Run: ${runName(run)});
});

runRuntime(run): number

const runtime = runRuntime(myRun);
const hours = Math.floor(runtime / 3600);
const minutes = Math.floor((runtime % 3600) / 60);
console.log(Runtime: ${hours}h ${minutes}m);

const longRuns = runs.filter(run => 
  runRuntime(run) > 3600 // More than 1 hour
);

runSummary(run): SummaryDict

const summary = runSummary(myRun);
console.log(Final accuracy: ${summary.accuracy});
console.log(Best validation loss: ${summary.best_val_loss});
console.log(Training time: ${summary.training_time_seconds});

const bestRun = runs.reduce((best, current) => {
  const bestSummary = runSummary(best);
  const currentSummary = runSummary(current);
  return currentSummary.accuracy > bestSummary.accuracy ? current : best;
});

const goodRuns = runs.filter(run => {
  const summary = runSummary(run);
  return summary.accuracy > 0.95 && summary.val_loss < 0.1;
});

runUsedArtifactVersions(run): ArtifactVersion[]

const inputs = runUsedArtifactVersions(run);
console.log("Run dependencies:");
inputs.forEach(artifact => {
  console.log(- ${artifact.name}:${artifact.version});
});

const inputs = runUsedArtifactVersions(run);
const dataset = inputs.find(a => a.name === "training-data");
if (dataset && dataset.version !== 3) {
  console.warn(Using outdated dataset v${dataset.version});
}

runUser(run): User

const myRuns = runs.filter(run => 
  runUser(run).username === "john_doe"
);

const runsByUser = runs.reduce((groups, run) => {
  const user = runUser(run).username;
  groups[user] = groups[user] || [];
  groups[user].push(run);
  return groups;
}, {});