// Query a dataset you've been granted (returns columns + rows)
const { columns, rows, row_count } = await erdo.queryDataset("acme.sales", {
  query: "SELECT month, revenue FROM data ORDER BY month",
  limit: 1000,
});

// Same query, shaped as objects keyed by column name (usually what you want)
const records = await erdo.queryAsObjects("acme.sales", { limit: 100 });

// File datasets (CSV/Excel) with multiple sheets: pass resource_key to pick one.
// Pass filters to apply the page's filter-bar state server-side.
const sheet = await erdo.queryAsObjects("acme.workbook", {
  resource_key: "Q1",
  filters: erdo.getFilters(),
});

// Discover and inspect datasets
const { datasets } = await erdo.listDatasets({ limit: 50 });
const dataset = await erdo.getDataset(datasetId);   // UUID; requires direct dataset access

// Operational status for datasets bound to this saved, signed-in Page
const { datasets: refreshStates } = await erdo.getDatasetRefreshStatus([datasetId]);

// Other resources you can dereference by id
await erdo.getResource("knowledge_object", id);
await erdo.getKnowledgeObject(id);   // { object, links, backlinks, related_objects }
await erdo.getAsk(id);               // a saved shortcut/ask
await erdo.runAsk(id);               // open it in a new thread
await erdo.runAsk(id, { parameters: { request_id: 'your-request-uuid' } });
await erdo.runAsk(id, { navigate: false }); // start in the background, without navigation
const { artifacts } = await erdo.listArtifacts({ type: "html_page", limit: 20 });

// A table: columns pick, rename and format fields; the row order is the
// query's ORDER BY (see note below).
<DatasetTable
  invocationId="iframe"
  datasetSlug="acme.sales"
  sqlQuery="SELECT month, region, revenue FROM data ORDER BY revenue DESC LIMIT 200"
  maxRows={200}
  columns={[
    { key: 'month', name: 'Month' },
    { key: 'region', name: 'Region' },
    { key: 'revenue', name: 'Revenue', format: 'currency' },
  ]}
/>

// A chart: same self-fetching pattern (line, bar, pie, scatter, heatmap, histogram)
<DatasetChart
  chartType="line"
  invocationId="iframe"
  datasetSlugs={['acme.sales']}
  xAxis={{ key: 'month', label: 'Month', type: 'date' }}
  yAxes={[{ key: 'revenue', label: 'Revenue', type: 'number' }]}
  series={[{ key: 'revenue', name: 'Revenue', color: '#2a78d6', datasetSlug: 'acme.sales' }]}
/>

// A single KPI value
<DatasetMetric invocationId="iframe" datasetSlug="acme.sales" sqlQuery="SELECT sum(revenue) FROM data" />

<ComboChart
  data={rows}
  displayConfig={{
    leads: { label: 'Leads', color: '#2563eb' },
    rate: { label: 'Conversion rate', color: '#16a34a' },
  }}
  dataConfig={{
    chartType: 'combo',
    xAxis: { key: 'month', label: 'Month', type: 'category' },
    yAxes: [
      { key: 'leads', label: 'Leads', type: 'number' },
      { key: 'rate', label: 'Conversion rate', type: 'number', format: '.1%' },
    ],
    series: [
      { key: 'leads', name: 'Leads', color: '#2563eb', type: 'bar' },
      { key: 'rate', name: 'Conversion rate', color: '#16a34a', type: 'line', axisIndex: 1 },
    ],
  }}
/>

// Everything Erdo is proposing about one campaign, in a client organization you manage
const { items, total } = await erdo.listAttentionItems({
  organization: "acme-property",
  statuses: ["open"],
  subject_kind: "google_ads_campaign",
  subject_id: "23926631489",
  limit: 50,
});

// items[] → { slug, kind, severity, status, title, body_markdown, created_at,
//             expires_at, answer, payload, subjects, workstream_slug, url }
items.forEach((item) => {
  console.log(item.severity, item.title, item.url); // url opens the item in Erdo
});

// Approve an escalation's proposed answer
await erdo.respondAttentionItem(item.slug, {
  organization: "acme-property",
  action: "answer",
  answer: { approved: true, decision: "approve", value: item.payload.proposed_answer },
});

// Decline it and let the automation keep running
await erdo.respondAttentionItem(item.slug, {
  organization: "acme-property",
  action: "answer",
  answer: { approved: false, decision: "reject" },
});

// Answer a choice — one entry per question, values from that question's options
await erdo.respondAttentionItem(item.slug, {
  action: "answer",
  answer: { [question.id]: [chosenOption] },
});

// Close it without answering, or just mark it read
await erdo.respondAttentionItem(item.slug, { action: "dismiss" });
await erdo.respondAttentionItem(item.slug, { action: "acknowledge" });

// 1. insertRows — direct, RBAC-checked append. Needs a SIGNED-IN viewer and a
//    page deployed with this dataset in writable_dataset_slugs.
await erdo.insertRows("acme.leads", [
  { name: "Ada", email: "ada@example.com" },
], { key_column: "email" });          // → { rows_affected }

// 2. submitEvent — the pipeline path. Works for ANONYMOUS public-page visitors
//    too, so it's the right choice for public lead forms and actions.
const res = await erdo.submitEvent(pipelineId, { name, email }, { variant: "signup-form" });
// → { ok, status, body }

// Read (direct, viewer-authorized)
const { value, found, updated_at } = await erdo.kv.get("theme", { partition: "viewer" });
const { items } = await erdo.kv.list({ prefix: "todo:", partition: "shared" });

// Write (direct, RBAC-checked)
await erdo.kv.set("theme", { mode: "dark" }, { partition: "viewer" });
await erdo.kv.delete("todo:42", { partition: "shared" });

// Pass { kv: "slug" } to target a named, org-level store
await erdo.kv.set("count", 1, { partition: "shared", collection: "leaderboard" });

const chan = erdo.channel("cursors");

// Subscribe; returns an unsubscribe function
const off = chan.subscribe((msg) => render(msg));

// Publish to other viewers
await chan.publish({ x, y, user: "Ada" });

// later
off();

erdo.channel("kv.change").subscribe(({ kv, key }) => {
  // re-read the shared value that just changed
  erdo.kv.get(key, { partition: "shared" }).then(applyUpdate);
});

// Live row/event streams (open a subscription, then listen; clean up on unmount)
await erdo.subscribeLiveDataset(datasetId);
const offLive = erdo.onLiveEvent((evt) => append(evt));   // { datasetId, payload }
// later: offLive(); await erdo.unsubscribeLiveDataset(datasetId);

const filters = erdo.getFilters();                 // current filter-bar state
const offFilter = erdo.onFilterChange((f) => refetch(f));

// Row writes and completed refreshes — re-query the affected datasets
erdo.getDatasetUpdateVersion();                    // monotonic version token
const offData = erdo.onDatasetChange((e) => refetch()); // { version, datasetIds, updatedAt }

erdo.getTheme();                                   // 'light' | 'dark'
const offTheme = erdo.onThemeChange((t) => setTheme(t));

async function render() {
  const { value } = await erdo.kv.get("count", { partition: "shared" });
  document.getElementById("count").textContent = value ?? 0;
}

document.getElementById("inc").onclick = async () => {
  const { value } = await erdo.kv.get("count", { partition: "shared" });
  await erdo.kv.set("count", (value ?? 0) + 1, { partition: "shared" });
};

// Any viewer's write re-renders for everyone
erdo.channel("kv.change").subscribe(({ key }) => {
  if (key === "count") render();
});

render();