ambiguous 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/index.ts
 import { Command } from "commander";
@@ -98,8 +104,868 @@ function info(msg) {
   console.error(dim(msg));
 }
 
-// src/lib/client.ts
-import { AmbiguousClient, AmbiguousApiError } from "@ambiguous/api-client";
+// ../../packages/api-client/dist/index.js
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var AmbiguousApiError = class extends Error {
+  constructor(statusCode, body) {
+    super(body.error || `HTTP ${statusCode}`);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "AmbiguousApiError";
+  }
+};
+var AmbiguousClient = class {
+  baseUrl;
+  apiKey;
+  token;
+  _fetch;
+  auth;
+  docs;
+  sheets;
+  slides;
+  chat;
+  mail;
+  drive;
+  tasks;
+  crm;
+  forms;
+  calendar;
+  wiki;
+  admin;
+  webhooks;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.token = options.token;
+    this._fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.auth = new AuthNamespace(this);
+    this.docs = new DocsNamespace(this);
+    this.sheets = new SheetsNamespace(this);
+    this.slides = new SlidesNamespace(this);
+    this.chat = new ChatNamespace(this);
+    this.mail = new MailNamespace(this);
+    this.drive = new DriveNamespace(this);
+    this.tasks = new TasksNamespace(this);
+    this.crm = new CrmNamespace(this);
+    this.forms = new FormsNamespace(this);
+    this.calendar = new CalendarNamespace(this);
+    this.wiki = new WikiNamespace(this);
+    this.admin = new AdminNamespace(this);
+    this.webhooks = new WebhooksNamespace(this);
+  }
+  /** Set the API key after construction */
+  setApiKey(key) {
+    this.apiKey = key;
+    this.token = void 0;
+  }
+  /** Set the JWT token after construction */
+  setToken(token) {
+    this.token = token;
+    this.apiKey = void 0;
+  }
+  /** Health check */
+  async health() {
+    return this.request("GET", "/api/health");
+  }
+  /** Internal request method — used by all namespaces */
+  async request(method, path, body, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null) url.searchParams.set(k, v);
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    } else if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    const init = { method, headers };
+    if (body !== void 0 && method !== "GET") {
+      init.body = JSON.stringify(body);
+    }
+    const res = await this._fetch(url.toString(), init);
+    if (!res.ok) {
+      const errBody = await res.json().catch(() => ({}));
+      throw new AmbiguousApiError(res.status, errBody);
+    }
+    if (res.status === 204) return void 0;
+    return res.json();
+  }
+};
+var AuthNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Register a human account */
+  async registerHuman(params) {
+    return this.client.request("POST", "/api/auth/register", { ...params, type: "human" });
+  }
+  /** Register an agent account */
+  async registerAgent(params) {
+    return this.client.request("POST", "/api/auth/register", { ...params, type: "agent" });
+  }
+  /** Login with email and password */
+  async login(params) {
+    return this.client.request("POST", "/api/auth/login", params);
+  }
+  /** Get the current user's profile */
+  async me() {
+    return this.client.request("GET", "/api/users/me");
+  }
+};
+var DocsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List user's documents */
+  async list(params) {
+    return this.client.request("GET", "/api/documents", void 0, { type: params?.type });
+  }
+  /** Create a document */
+  async create(params) {
+    return this.client.request("POST", "/api/documents", params);
+  }
+  /** Get a document by ID (includes comments) */
+  async get(id) {
+    return this.client.request("GET", `/api/documents/${id}`);
+  }
+  /** Update a document */
+  async update(id, params) {
+    return this.client.request("PATCH", `/api/documents/${id}`, params);
+  }
+  /** Delete a document */
+  async delete(id) {
+    return this.client.request("DELETE", `/api/documents/${id}`);
+  }
+  /** List permissions on a document */
+  async listPermissions(docId) {
+    return this.client.request("GET", `/api/documents/${docId}/permissions`);
+  }
+  /** Grant or update a permission */
+  async setPermission(docId, params) {
+    return this.client.request("POST", `/api/documents/${docId}/permissions`, params);
+  }
+  /** Remove a permission */
+  async removePermission(docId, userId) {
+    return this.client.request("DELETE", `/api/documents/${docId}/permissions/${userId}`);
+  }
+  /** List threaded comments */
+  async listComments(docId) {
+    return this.client.request("GET", `/api/documents/${docId}/comments`);
+  }
+  /** Add a comment or reply */
+  async addComment(docId, params) {
+    return this.client.request("POST", `/api/documents/${docId}/comments`, params);
+  }
+  /** Resolve or unresolve a comment */
+  async resolveComment(docId, commentId, resolved) {
+    return this.client.request("PATCH", `/api/documents/${docId}/comments/${commentId}`, { resolved });
+  }
+  /** Delete a comment */
+  async deleteComment(docId, commentId) {
+    return this.client.request("DELETE", `/api/documents/${docId}/comments/${commentId}`);
+  }
+};
+var SheetsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get sheet data as structured JSON */
+  async getData(id) {
+    return this.client.request("GET", `/api/sheets/${id}/data`);
+  }
+  /** Update specific cells */
+  async updateCells(id, cells) {
+    return this.client.request("PATCH", `/api/sheets/${id}/cells`, { cells });
+  }
+  /** Add a sheet tab */
+  async addTab(id, name) {
+    return this.client.request("POST", `/api/sheets/${id}/tabs`, name ? { name } : {});
+  }
+  /** Rename a sheet tab */
+  async renameTab(id, tabName, newName) {
+    return this.client.request("PATCH", `/api/sheets/${id}/tabs/${encodeURIComponent(tabName)}`, { name: newName });
+  }
+  /** Remove a sheet tab */
+  async removeTab(id, tabName) {
+    return this.client.request("DELETE", `/api/sheets/${id}/tabs/${encodeURIComponent(tabName)}`);
+  }
+  /** Replace tab data (columns and/or rows) */
+  async replaceTabData(id, tabName, data) {
+    return this.client.request("PUT", `/api/sheets/${id}/tabs/${encodeURIComponent(tabName)}`, data);
+  }
+  /** Add a column */
+  async addColumn(id, params) {
+    return this.client.request("POST", `/api/sheets/${id}/columns`, params);
+  }
+  /** Remove a column */
+  async removeColumn(id, columnId, sheet) {
+    return this.client.request("DELETE", `/api/sheets/${id}/columns/${columnId}`, void 0, { sheet });
+  }
+  /** Add rows */
+  async addRows(id, rows, sheet) {
+    return this.client.request("POST", `/api/sheets/${id}/rows`, { rows, sheet });
+  }
+  /** Delete rows by indices */
+  async deleteRows(id, indices, sheet) {
+    return this.client.request("DELETE", `/api/sheets/${id}/rows`, { indices, sheet });
+  }
+};
+var SlidesNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List available slide layouts */
+  async listLayouts() {
+    return this.client.request("GET", "/api/slides/layouts");
+  }
+  /** Get presentation data */
+  async getData(id) {
+    return this.client.request("GET", `/api/slides/${id}/data`);
+  }
+  /** Update a specific slide */
+  async updateSlide(id, index, params) {
+    return this.client.request("PATCH", `/api/slides/${id}/slides/${index}`, params);
+  }
+  /** Add a new slide */
+  async addSlide(id, params) {
+    return this.client.request("POST", `/api/slides/${id}/slides`, params ?? {});
+  }
+  /** Remove a slide */
+  async removeSlide(id, index) {
+    return this.client.request("DELETE", `/api/slides/${id}/slides/${index}`);
+  }
+  /** Reorder slides */
+  async reorder(id, order) {
+    return this.client.request("PATCH", `/api/slides/${id}/reorder`, { order });
+  }
+  /** Update deck settings */
+  async updateSettings(id, settings) {
+    return this.client.request("PATCH", `/api/slides/${id}/settings`, settings);
+  }
+};
+var ChatNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List user's channels */
+  async listChannels() {
+    return this.client.request("GET", "/api/channels");
+  }
+  /** Create a channel */
+  async createChannel(params) {
+    return this.client.request("POST", "/api/channels", params);
+  }
+  /** Get channel details */
+  async getChannel(id) {
+    return this.client.request("GET", `/api/channels/${id}`);
+  }
+  /** Update channel */
+  async updateChannel(id, params) {
+    return this.client.request("PATCH", `/api/channels/${id}`, params);
+  }
+  /** Delete channel */
+  async deleteChannel(id) {
+    return this.client.request("DELETE", `/api/channels/${id}`);
+  }
+  /** Add member(s) to a channel */
+  async addMembers(channelId, userIds) {
+    return this.client.request("POST", `/api/channels/${channelId}/members`, { user_ids: userIds });
+  }
+  /** Remove a member from a channel */
+  async removeMember(channelId, userId) {
+    return this.client.request("DELETE", `/api/channels/${channelId}/members/${userId}`);
+  }
+  /** List messages in a channel */
+  async listMessages(channelId, params) {
+    return this.client.request("GET", `/api/channels/${channelId}/messages`, void 0, {
+      limit: params?.limit?.toString(),
+      before: params?.before
+    });
+  }
+  /** Send a message */
+  async sendMessage(channelId, params) {
+    return this.client.request("POST", `/api/channels/${channelId}/messages`, params);
+  }
+  /** Edit a message */
+  async editMessage(channelId, messageId, content) {
+    return this.client.request("PATCH", `/api/channels/${channelId}/messages/${messageId}`, { content });
+  }
+  /** Delete a message */
+  async deleteMessage(channelId, messageId) {
+    return this.client.request("DELETE", `/api/channels/${channelId}/messages/${messageId}`);
+  }
+  /** Add a reaction */
+  async addReaction(channelId, messageId, emoji) {
+    return this.client.request("POST", `/api/channels/${channelId}/messages/${messageId}/reactions`, { emoji });
+  }
+  /** Remove a reaction */
+  async removeReaction(channelId, messageId, emoji) {
+    return this.client.request("DELETE", `/api/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`);
+  }
+  /** Get thread replies */
+  async getThread(channelId, messageId) {
+    return this.client.request("GET", `/api/channels/${channelId}/messages/${messageId}/thread`);
+  }
+};
+var MailNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Send an email */
+  async send(params) {
+    return this.client.request("POST", "/api/mail/send", params);
+  }
+  /** List inbox emails */
+  async inbox(params) {
+    return this.client.request("GET", "/api/mail/inbox", void 0, {
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString(),
+      unread: params?.unread !== void 0 ? String(params.unread) : void 0
+    });
+  }
+  /** List sent emails */
+  async sent(params) {
+    return this.client.request("GET", "/api/mail/sent", void 0, {
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+  /** Get a single email (marks as read) */
+  async get(id) {
+    return this.client.request("GET", `/api/mail/${id}`);
+  }
+  /** Mark email as read or unread */
+  async markRead(id, read) {
+    return this.client.request("PATCH", `/api/mail/${id}`, { read });
+  }
+  /** Delete an email */
+  async delete(id) {
+    return this.client.request("DELETE", `/api/mail/${id}`);
+  }
+};
+var DriveNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List files in a folder (or root) */
+  async list(params) {
+    return this.client.request("GET", "/api/drive", void 0, {
+      parent_id: params?.parent_id,
+      q: params?.q
+    });
+  }
+  /** Create a folder */
+  async createFolder(params) {
+    return this.client.request("POST", "/api/drive/folders", params);
+  }
+  /** Initiate a file upload (returns presigned URL) */
+  async initiateUpload(params) {
+    return this.client.request("POST", "/api/drive/upload", params);
+  }
+  /** Get file/folder metadata */
+  async get(id) {
+    return this.client.request("GET", `/api/drive/${id}`);
+  }
+  /** Get a presigned download URL */
+  async getDownloadUrl(id) {
+    return this.client.request("GET", `/api/drive/${id}/download`);
+  }
+  /** Rename or move a file */
+  async update(id, params) {
+    return this.client.request("PATCH", `/api/drive/${id}`, params);
+  }
+  /** Delete a file or folder */
+  async delete(id) {
+    return this.client.request("DELETE", `/api/drive/${id}`);
+  }
+};
+var TasksNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List tasks */
+  async list(params) {
+    return this.client.request("GET", "/api/tasks", void 0, {
+      assignee_id: params?.assignee_id,
+      creator_id: params?.creator_id,
+      status: params?.status,
+      priority: params?.priority,
+      project_id: params?.project_id,
+      parent_task_id: params?.parent_task_id === null ? "null" : params?.parent_task_id,
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+  /** Create a task */
+  async create(params) {
+    return this.client.request("POST", "/api/tasks", params);
+  }
+  /** Get a task */
+  async get(id) {
+    return this.client.request("GET", `/api/tasks/${id}`);
+  }
+  /** Update a task */
+  async update(id, params) {
+    return this.client.request("PATCH", `/api/tasks/${id}`, params);
+  }
+  /** Delete a task */
+  async delete(id) {
+    return this.client.request("DELETE", `/api/tasks/${id}`);
+  }
+  /** List subtasks of a task */
+  async listSubtasks(id) {
+    return this.client.request("GET", `/api/tasks/${id}/subtasks`);
+  }
+};
+var CrmNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --- Contacts ---
+  /** List contacts */
+  async listContacts(params) {
+    return this.client.request("GET", "/api/crm/contacts", void 0, {
+      type: params?.type,
+      lifecycle_stage: params?.lifecycle_stage,
+      owner_id: params?.owner_id,
+      q: params?.q,
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+  /** Create a contact */
+  async createContact(params) {
+    return this.client.request("POST", "/api/crm/contacts", params);
+  }
+  /** Get a contact */
+  async getContact(id) {
+    return this.client.request("GET", `/api/crm/contacts/${id}`);
+  }
+  /** Update a contact */
+  async updateContact(id, params) {
+    return this.client.request("PATCH", `/api/crm/contacts/${id}`, params);
+  }
+  /** Delete a contact */
+  async deleteContact(id) {
+    return this.client.request("DELETE", `/api/crm/contacts/${id}`);
+  }
+  /** List activities for a contact */
+  async listContactActivities(contactId, params) {
+    return this.client.request("GET", `/api/crm/contacts/${contactId}/activities`, void 0, { type: params?.type });
+  }
+  // --- Deals ---
+  /** List deals */
+  async listDeals(params) {
+    return this.client.request("GET", "/api/crm/deals", void 0, {
+      pipeline_id: params?.pipeline_id,
+      stage_id: params?.stage_id,
+      status: params?.status,
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+  /** Create a deal */
+  async createDeal(params) {
+    return this.client.request("POST", "/api/crm/deals", params);
+  }
+  /** Get a deal */
+  async getDeal(id) {
+    return this.client.request("GET", `/api/crm/deals/${id}`);
+  }
+  /** Update a deal */
+  async updateDeal(id, params) {
+    return this.client.request("PATCH", `/api/crm/deals/${id}`, params);
+  }
+  /** Delete a deal */
+  async deleteDeal(id) {
+    return this.client.request("DELETE", `/api/crm/deals/${id}`);
+  }
+  // --- Pipelines ---
+  /** List pipelines with stages */
+  async listPipelines() {
+    return this.client.request("GET", "/api/crm/pipelines");
+  }
+  /** Create a pipeline */
+  async createPipeline(params) {
+    return this.client.request("POST", "/api/crm/pipelines", params);
+  }
+  /** Update a pipeline */
+  async updatePipeline(id, params) {
+    return this.client.request("PATCH", `/api/crm/pipelines/${id}`, params);
+  }
+  /** Delete a pipeline */
+  async deletePipeline(id) {
+    return this.client.request("DELETE", `/api/crm/pipelines/${id}`);
+  }
+  // --- Activities ---
+  /** Log an activity */
+  async logActivity(params) {
+    return this.client.request("POST", "/api/crm/activities", params);
+  }
+  /** Delete an activity */
+  async deleteActivity(id) {
+    return this.client.request("DELETE", `/api/crm/activities/${id}`);
+  }
+};
+var FormsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List user's forms */
+  async list(params) {
+    return this.client.request("GET", "/api/forms", void 0, {
+      q: params?.q,
+      published: params?.published !== void 0 ? String(params.published) : void 0
+    });
+  }
+  /** Create a form */
+  async create(params) {
+    return this.client.request("POST", "/api/forms", params);
+  }
+  /** Get a form */
+  async get(id) {
+    return this.client.request("GET", `/api/forms/${id}`);
+  }
+  /** Update a form */
+  async update(id, params) {
+    return this.client.request("PATCH", `/api/forms/${id}`, params);
+  }
+  /** Delete a form */
+  async delete(id) {
+    return this.client.request("DELETE", `/api/forms/${id}`);
+  }
+  /** List form responses */
+  async listResponses(formId, params) {
+    return this.client.request("GET", `/api/forms/${formId}/responses`, void 0, {
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+  /** Get a single response */
+  async getResponse(formId, responseId) {
+    return this.client.request("GET", `/api/forms/${formId}/responses/${responseId}`);
+  }
+  /** Delete a response */
+  async deleteResponse(formId, responseId) {
+    return this.client.request("DELETE", `/api/forms/${formId}/responses/${responseId}`);
+  }
+  /** Submit a response (public endpoint — uses slug) */
+  async submit(slug, data) {
+    return this.client.request("POST", `/api/forms/${slug}/submit`, { data });
+  }
+};
+var CalendarNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List user's calendars */
+  async listCalendars() {
+    return this.client.request("GET", "/api/calendars");
+  }
+  /** Create a calendar */
+  async createCalendar(params) {
+    return this.client.request("POST", "/api/calendars", params);
+  }
+  /** Update a calendar */
+  async updateCalendar(id, params) {
+    return this.client.request("PATCH", `/api/calendars/${id}`, params);
+  }
+  /** Delete a calendar */
+  async deleteCalendar(id) {
+    return this.client.request("DELETE", `/api/calendars/${id}`);
+  }
+  /** List events across calendars */
+  async listEvents(params) {
+    return this.client.request("GET", "/api/calendars/events", void 0, {
+      start: params?.start,
+      end: params?.end,
+      calendar_id: params?.calendar_id
+    });
+  }
+  /** Create an event */
+  async createEvent(calendarId, params) {
+    return this.client.request("POST", `/api/calendars/${calendarId}/events`, params);
+  }
+  /** Get an event */
+  async getEvent(id) {
+    return this.client.request("GET", `/api/calendars/events/${id}`);
+  }
+  /** Update an event */
+  async updateEvent(id, params) {
+    return this.client.request("PATCH", `/api/calendars/events/${id}`, params);
+  }
+  /** Delete an event */
+  async deleteEvent(id) {
+    return this.client.request("DELETE", `/api/calendars/events/${id}`);
+  }
+  /** RSVP to an event */
+  async rsvp(eventId, status) {
+    return this.client.request("POST", `/api/calendars/events/${eventId}/rsvp`, { rsvp: status });
+  }
+  /** Check free/busy availability */
+  async checkAvailability(params) {
+    return this.client.request("GET", "/api/calendars/availability", void 0, {
+      user_ids: params.user_ids.join(","),
+      start: params.start,
+      end: params.end
+    });
+  }
+};
+var WikiNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --- Spaces ---
+  /** List wiki spaces */
+  async listSpaces() {
+    return this.client.request("GET", "/api/wiki/spaces");
+  }
+  /** Create a wiki space */
+  async createSpace(params) {
+    return this.client.request("POST", "/api/wiki/spaces", params);
+  }
+  /** Get a space with page tree */
+  async getSpace(slug) {
+    return this.client.request("GET", `/api/wiki/spaces/${slug}`);
+  }
+  /** Update a space */
+  async updateSpace(id, params) {
+    return this.client.request("PATCH", `/api/wiki/spaces/${id}`, params);
+  }
+  /** Delete a space */
+  async deleteSpace(id) {
+    return this.client.request("DELETE", `/api/wiki/spaces/${id}`);
+  }
+  // --- Pages ---
+  /** Create a page in a space */
+  async createPage(spaceId, params) {
+    return this.client.request("POST", `/api/wiki/spaces/${spaceId}/pages`, params);
+  }
+  /** Get a page */
+  async getPage(id) {
+    return this.client.request("GET", `/api/wiki/pages/${id}`);
+  }
+  /** Update a page */
+  async updatePage(id, params) {
+    return this.client.request("PATCH", `/api/wiki/pages/${id}`, params);
+  }
+  /** Delete a page (and children) */
+  async deletePage(id) {
+    return this.client.request("DELETE", `/api/wiki/pages/${id}`);
+  }
+  /** List child pages */
+  async listChildren(pageId) {
+    return this.client.request("GET", `/api/wiki/pages/${pageId}/children`);
+  }
+  /** List backlinks */
+  async listBacklinks(pageId) {
+    return this.client.request("GET", `/api/wiki/pages/${pageId}/backlinks`);
+  }
+  /** Duplicate a page */
+  async duplicatePage(pageId) {
+    return this.client.request("POST", `/api/wiki/pages/${pageId}/duplicate`);
+  }
+  /** Search wiki */
+  async search(params) {
+    return this.client.request("GET", "/api/wiki/search", void 0, {
+      q: params.q,
+      space: params.space
+    });
+  }
+  // --- Databases ---
+  /** Get a database */
+  async getDatabase(id) {
+    return this.client.request("GET", `/api/wiki/databases/${id}`);
+  }
+  /** Update a database schema or views */
+  async updateDatabase(id, params) {
+    return this.client.request("PATCH", `/api/wiki/databases/${id}`, params);
+  }
+  /** Create a database in a page */
+  async createDatabase(pageId, params) {
+    return this.client.request("POST", `/api/wiki/pages/${pageId}/databases`, params);
+  }
+  /** Create a database row */
+  async createRow(databaseId, properties) {
+    return this.client.request("POST", `/api/wiki/databases/${databaseId}/rows`, { properties });
+  }
+  /** Update a database row */
+  async updateRow(databaseId, rowId, properties) {
+    return this.client.request("PATCH", `/api/wiki/databases/${databaseId}/rows/${rowId}`, { properties });
+  }
+  /** Delete a database row */
+  async deleteRow(databaseId, rowId) {
+    return this.client.request("DELETE", `/api/wiki/databases/${databaseId}/rows/${rowId}`);
+  }
+  /** Query database rows */
+  async queryRows(databaseId, params) {
+    return this.client.request("GET", `/api/wiki/databases/${databaseId}/query`, void 0, {
+      page_size: params?.page_size?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+};
+var AdminNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --- Users ---
+  /** List all users */
+  async listUsers(params) {
+    return this.client.request("GET", "/api/admin/users", void 0, {
+      type: params?.type,
+      role: params?.role,
+      q: params?.q,
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+  /** Get user details */
+  async getUser(id) {
+    return this.client.request("GET", `/api/admin/users/${id}`);
+  }
+  /** Update user */
+  async updateUser(id, params) {
+    return this.client.request("PATCH", `/api/admin/users/${id}`, params);
+  }
+  /** Delete user */
+  async deleteUser(id) {
+    return this.client.request("DELETE", `/api/admin/users/${id}`);
+  }
+  /** Assign role to user */
+  async assignRole(userId, roleName) {
+    return this.client.request("POST", `/api/admin/users/${userId}/roles`, { role: roleName });
+  }
+  /** Remove role from user */
+  async removeRole(userId, roleName) {
+    return this.client.request("DELETE", `/api/admin/users/${userId}/roles/${roleName}`);
+  }
+  // --- Roles ---
+  /** List all roles */
+  async listRoles() {
+    return this.client.request("GET", "/api/admin/roles");
+  }
+  /** Create a custom role */
+  async createRole(params) {
+    return this.client.request("POST", "/api/admin/roles", params);
+  }
+  /** Update a role */
+  async updateRole(id, params) {
+    return this.client.request("PATCH", `/api/admin/roles/${id}`, params);
+  }
+  /** Delete a role */
+  async deleteRole(id) {
+    return this.client.request("DELETE", `/api/admin/roles/${id}`);
+  }
+  // --- Settings ---
+  /** Get workspace settings */
+  async getSettings() {
+    return this.client.request("GET", "/api/admin/settings");
+  }
+  /** Update workspace settings */
+  async updateSettings(settings) {
+    return this.client.request("PATCH", "/api/admin/settings", settings);
+  }
+  // --- Audit Log ---
+  /** Query audit log */
+  async queryAuditLog(params) {
+    return this.client.request("GET", "/api/admin/audit-log", void 0, {
+      user_id: params?.user_id,
+      action: params?.action,
+      resource_type: params?.resource_type,
+      start: params?.start,
+      end: params?.end,
+      limit: params?.limit?.toString(),
+      offset: params?.offset?.toString()
+    });
+  }
+  // --- API Keys ---
+  /** List all API keys */
+  async listApiKeys(params) {
+    return this.client.request("GET", "/api/admin/api-keys", void 0, {
+      user_id: params?.user_id
+    });
+  }
+  /** Create an API key */
+  async createApiKey(params) {
+    return this.client.request("POST", "/api/admin/api-keys", params);
+  }
+  /** Revoke an API key */
+  async revokeApiKey(id) {
+    return this.client.request("DELETE", `/api/admin/api-keys/${id}`);
+  }
+  // --- Usage ---
+  /** Get usage statistics */
+  async getUsage() {
+    return this.client.request("GET", "/api/admin/usage");
+  }
+  /** Initialize system roles */
+  async initRoles() {
+    return this.client.request("POST", "/api/admin/init");
+  }
+};
+var WebhooksNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List user's registered webhooks */
+  async list() {
+    return this.client.request("GET", "/api/webhooks");
+  }
+  /** Register a new webhook */
+  async create(params) {
+    return this.client.request("POST", "/api/webhooks", params);
+  }
+  /** Get webhook details by ID */
+  async get(id) {
+    return this.client.request("GET", `/api/webhooks/${id}`);
+  }
+  /** Update a webhook */
+  async update(id, params) {
+    return this.client.request("PATCH", `/api/webhooks/${id}`, params);
+  }
+  /** Delete a webhook */
+  async delete(id) {
+    return this.client.request("DELETE", `/api/webhooks/${id}`);
+  }
+  /** Rotate the webhook signing secret */
+  async rotateSecret(id) {
+    return this.client.request("POST", `/api/webhooks/${id}/rotate-secret`);
+  }
+  /** List delivery attempts for a webhook */
+  async listDeliveries(id, params) {
+    const query = params ? {
+      limit: params.limit?.toString(),
+      offset: params.offset?.toString()
+    } : void 0;
+    return this.client.request("GET", `/api/webhooks/${id}/deliveries`, void 0, query);
+  }
+  /** Send a test ping to a webhook */
+  async test(id) {
+    return this.client.request("POST", `/api/webhooks/${id}/test`);
+  }
+  /** List available webhook event types */
+  async listEventTypes() {
+    return this.client.request("GET", "/api/webhooks/event-types");
+  }
+  /** Verify a webhook signature (static utility) */
+  static verifySignature(payload, timestamp, signature, secret) {
+    const { createHmac } = __require2("crypto");
+    const signatureInput = `${timestamp}.${payload}`;
+    const expected = createHmac("sha256", secret).update(signatureInput).digest("hex");
+    return `sha256=${expected}` === signature;
+  }
+};
 
 // src/lib/config.ts
 import Conf from "conf";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ambiguous",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "CLI for Ambiguous Workspace — manage docs, tasks, mail, calendar, CRM, and more from the terminal",
   "type": "module",
   "bin": {
@@ -23,8 +23,6 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@ambiguous/api-client": "*",
-    "@ambiguous/shared-types": "*",
     "chalk": "^5.4.0",
     "commander": "^13.1.0",
     "conf": "^13.1.0",