geodedo 0.1.0

package/dist/index.js

@@ -0,0 +1,1021 @@
+// src/core/errors.ts
+var GeoDedoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GeoDedoError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var APIError = class _APIError extends GeoDedoError {
+  /** HTTP status code. */
+  status;
+  /** Machine-readable error code from the response body, if present. */
+  code;
+  /** Request ID from the X-Request-Id response header, if present. */
+  requestId;
+  /** Raw response body. */
+  body;
+  constructor(status, body, message, code, requestId) {
+    super(message);
+    this.name = "APIError";
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+    this.body = body;
+  }
+  /**
+   * Factory that maps an HTTP status code to the appropriate error subclass.
+   */
+  static fromResponse(status, body, headers) {
+    const parsed = typeof body === "object" && body !== null ? body : {};
+    const message = typeof parsed.error === "string" ? parsed.error : `Request failed with status ${status}`;
+    const code = typeof parsed.code === "string" ? parsed.code : void 0;
+    let requestId;
+    if (headers) {
+      if (typeof headers.get === "function") {
+        requestId = headers.get("x-request-id") ?? void 0;
+      } else {
+        requestId = headers["x-request-id"];
+      }
+    }
+    switch (status) {
+      case 401:
+        return new AuthenticationError(body, message, code, requestId);
+      case 402:
+        return new InsufficientCreditsError(
+          body,
+          message,
+          code,
+          requestId,
+          typeof parsed.credits_needed === "number" ? parsed.credits_needed : void 0,
+          typeof parsed.credits_remaining === "number" ? parsed.credits_remaining : void 0
+        );
+      case 403:
+        return new PermissionDeniedError(body, message, code, requestId);
+      case 404:
+        return new NotFoundError(body, message, code, requestId);
+      case 422:
+        return new ValidationError(body, message, code, requestId);
+      case 429: {
+        let retryAfter;
+        if (headers) {
+          const raw = typeof headers.get === "function" ? headers.get("retry-after") : headers["retry-after"];
+          if (raw) {
+            const parsed2 = Number(raw);
+            if (!Number.isNaN(parsed2)) retryAfter = parsed2;
+          }
+        }
+        return new RateLimitError(body, message, code, requestId, retryAfter);
+      }
+      default:
+        if (status >= 500) {
+          return new InternalServerError(status, body, message, code, requestId);
+        }
+        return new _APIError(status, body, message, code, requestId);
+    }
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(body, message, code, requestId) {
+    super(401, body, message, code, requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var InsufficientCreditsError = class extends APIError {
+  /** Number of credits required for the operation. */
+  creditsRequired;
+  /** Current credit balance. */
+  creditsRemaining;
+  constructor(body, message, code, requestId, creditsRequired, creditsRemaining) {
+    super(402, body, message, code, requestId);
+    this.name = "InsufficientCreditsError";
+    this.creditsRequired = creditsRequired;
+    this.creditsRemaining = creditsRemaining;
+  }
+};
+var PermissionDeniedError = class extends APIError {
+  constructor(body, message, code, requestId) {
+    super(403, body, message, code, requestId);
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(body, message, code, requestId) {
+    super(404, body, message, code, requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends APIError {
+  constructor(body, message, code, requestId) {
+    super(422, body, message, code, requestId);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends APIError {
+  /** Seconds to wait before retrying, from the Retry-After header. */
+  retryAfter;
+  constructor(body, message, code, requestId, retryAfter) {
+    super(429, body, message, code, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var InternalServerError = class extends APIError {
+  constructor(status, body, message, code, requestId) {
+    super(status, body, message, code, requestId);
+    this.name = "InternalServerError";
+  }
+};
+var APIConnectionError = class extends GeoDedoError {
+  /** The underlying error that caused the connection failure. */
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "APIConnectionError";
+    this.cause = cause;
+  }
+};
+var APITimeoutError = class extends APIConnectionError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "APITimeoutError";
+  }
+};
+
+// src/core/api-client.ts
+var VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://geodedo-api.vercel.app";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var MIN_RETRY_DELAY = 500;
+var MAX_RETRY_DELAY = 5e3;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 409, 500, 502, 503, 504]);
+var APIClient = class {
+  apiKey;
+  userId;
+  baseURL;
+  maxRetries;
+  timeout;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.userId = options.userId;
+    this.baseURL = (options.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  }
+  /**
+   * Core request method. All convenience methods delegate here.
+   */
+  async request(method, path, body, options) {
+    const url = `${this.baseURL}${path}`;
+    const apiKey = options?.apiKey ?? this.apiKey;
+    const userId = options?.userId ?? this.userId;
+    const timeout = options?.timeout ?? this.timeout;
+    const headers = {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": `geodedo-node/${VERSION}`,
+      ...options?.headers
+    };
+    if (userId) {
+      headers["X-User-Id"] = userId;
+    }
+    const maxRetries = this.maxRetries;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const externalSignal = options?.signal;
+      let onExternalAbort;
+      if (externalSignal) {
+        if (externalSignal.aborted) {
+          clearTimeout(timeoutId);
+          throw new APITimeoutError("Request aborted");
+        }
+        onExternalAbort = () => controller.abort();
+        externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+      }
+      try {
+        const fetchOptions = {
+          method,
+          headers,
+          signal: controller.signal
+        };
+        if (body !== void 0 && method !== "GET") {
+          fetchOptions.body = JSON.stringify(body);
+        }
+        let response;
+        try {
+          response = await fetch(url, fetchOptions);
+        } catch (err) {
+          if (controller.signal.aborted) {
+            throw new APITimeoutError();
+          }
+          throw new APIConnectionError(
+            `Connection error: ${err instanceof Error ? err.message : String(err)}`,
+            err
+          );
+        } finally {
+          clearTimeout(timeoutId);
+          if (externalSignal && onExternalAbort) {
+            externalSignal.removeEventListener("abort", onExternalAbort);
+          }
+        }
+        if (response.ok) {
+          if (response.status === 204) {
+            return void 0;
+          }
+          return await response.json();
+        }
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch {
+          errorBody = { error: response.statusText };
+        }
+        const apiError = APIError.fromResponse(response.status, errorBody, response.headers);
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < maxRetries) {
+          lastError = apiError;
+          await this.sleep(this.retryDelay(attempt));
+          continue;
+        }
+        throw apiError;
+      } catch (err) {
+        if ((err instanceof APIConnectionError || err instanceof APITimeoutError) && attempt < maxRetries) {
+          lastError = err;
+          await this.sleep(this.retryDelay(attempt));
+          continue;
+        }
+        if (err instanceof APIError || err instanceof APIConnectionError) {
+          throw err;
+        }
+        throw new APIConnectionError(
+          `Unexpected error: ${err instanceof Error ? err.message : String(err)}`,
+          err
+        );
+      }
+    }
+    throw lastError;
+  }
+  /** Calculate retry delay with exponential backoff and jitter. */
+  retryDelay(attempt) {
+    const base = MIN_RETRY_DELAY * Math.pow(2, attempt);
+    const capped = Math.min(base, MAX_RETRY_DELAY);
+    const jitter = Math.random() * capped;
+    return Math.min(capped + jitter, MAX_RETRY_DELAY);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ── Convenience methods ─────────────────────────────────────────────
+  async get(path, options) {
+    return this.request("GET", path, void 0, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, body, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, void 0, options);
+  }
+};
+
+// src/core/pagination.ts
+var Page = class {
+  /** The items on this page. */
+  data;
+  /** Total number of items across all pages. */
+  total;
+  /** Current page number (1-indexed). */
+  page;
+  /** Number of items per page (inferred from the current page size). */
+  perPage;
+  _requestOptions;
+  constructor(data, total, page, perPage, requestOptions) {
+    this.data = data;
+    this.total = total;
+    this.page = page;
+    this.perPage = perPage;
+    this._requestOptions = requestOptions;
+  }
+  /**
+   * Whether there is a next page available.
+   */
+  hasNextPage() {
+    return this.page * this.perPage < this.total;
+  }
+  /**
+   * Fetch the next page. Throws if there is no next page.
+   */
+  async getNextPage() {
+    if (!this.hasNextPage()) {
+      throw new Error("No more pages available");
+    }
+    return fetchPage({
+      ...this._requestOptions,
+      query: {
+        ...this._requestOptions.query,
+        page: this.page + 1
+      },
+      body: this._requestOptions.body ? { ...this._requestOptions.body, page: this.page + 1 } : void 0
+    });
+  }
+  /**
+   * Async iterator that yields every item across all pages,
+   * automatically fetching subsequent pages as needed.
+   */
+  async *[Symbol.asyncIterator]() {
+    let page = this;
+    while (true) {
+      for (const item of page.data) {
+        yield item;
+      }
+      if (!page.hasNextPage()) break;
+      page = await page.getNextPage();
+    }
+  }
+};
+async function fetchPage(opts) {
+  const { client, method, path, body, query, responseKey, options } = opts;
+  let fullPath = path;
+  if (query && Object.keys(query).length > 0) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0 && value !== null) {
+        params.set(key, String(value));
+      }
+    }
+    const qs = params.toString();
+    if (qs) {
+      fullPath += (fullPath.includes("?") ? "&" : "?") + qs;
+    }
+  }
+  let raw;
+  if (method === "POST") {
+    raw = await client.post(fullPath, body, options);
+  } else {
+    raw = await client.get(fullPath, options);
+  }
+  const data = raw[responseKey] ?? [];
+  const total = typeof raw.total === "number" ? raw.total : data.length;
+  const page = typeof raw.page === "number" ? raw.page : 1;
+  const perPage = typeof raw.pageSize === "number" ? raw.pageSize : typeof raw.perPage === "number" ? raw.perPage : data.length > 0 ? data.length : 25;
+  return new Page(data, total, page, perPage, opts);
+}
+
+// src/resources/contacts.ts
+var Contacts = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Search for contacts matching the given ICP criteria.
+   * Returns a paginated list of enriched contacts.
+   */
+  async search(params, options) {
+    const { page, perPage, ...body } = params;
+    return fetchPage({
+      client: this.client,
+      method: "POST",
+      path: "/api/contacts/search",
+      body: { ...body, page: page ?? 1, perPage: perPage ?? 25 },
+      responseKey: "contacts",
+      options
+    });
+  }
+  /**
+   * Enrich a single contact by email, LinkedIn URL, or name+company.
+   */
+  async enrich(params, options) {
+    const raw = await this.client.post(
+      "/api/contacts/enrich",
+      params,
+      options
+    );
+    return raw.contact;
+  }
+  /**
+   * Import a batch of contacts (CSV-like).
+   */
+  async importCsv(params, options) {
+    return this.client.post("/api/contacts/import", params, options);
+  }
+  /**
+   * List stored contacts for the current user. Paginated.
+   */
+  async list(params, options) {
+    const query = {};
+    if (params?.page) query.page = params.page;
+    if (params?.perPage) query.perPage = params.perPage;
+    return fetchPage({
+      client: this.client,
+      method: "GET",
+      path: "/api/contacts",
+      query,
+      responseKey: "contacts",
+      options
+    });
+  }
+  /**
+   * List all CSV lists (imports) for the current user.
+   */
+  async csvLists(options) {
+    const raw = await this.client.get(
+      "/api/contacts/csv-lists",
+      options
+    );
+    return raw.lists;
+  }
+};
+
+// src/resources/sequences.ts
+var Sequences = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new outreach sequence.
+   */
+  async create(params, options) {
+    const raw = await this.client.post(
+      "/api/sequences",
+      params,
+      options
+    );
+    return raw.sequence;
+  }
+  /**
+   * List all sequences for the current user. Paginated.
+   */
+  async list(params, options) {
+    const query = {};
+    if (params?.page) query.page = params.page;
+    if (params?.perPage) query.perPage = params.perPage;
+    return fetchPage({
+      client: this.client,
+      method: "GET",
+      path: "/api/sequences",
+      query,
+      responseKey: "sequences",
+      options
+    });
+  }
+  /**
+   * Get a single sequence by ID.
+   */
+  async get(sequenceId, options) {
+    const raw = await this.client.get(
+      `/api/sequences/${sequenceId}`,
+      options
+    );
+    return raw.sequence;
+  }
+  /**
+   * Pause a running sequence.
+   */
+  async pause(sequenceId, options) {
+    const raw = await this.client.post(
+      `/api/sequences/${sequenceId}/pause`,
+      void 0,
+      options
+    );
+    return raw.sequence;
+  }
+  /**
+   * Resume a paused sequence.
+   */
+  async resume(sequenceId, options) {
+    const raw = await this.client.post(
+      `/api/sequences/${sequenceId}/resume`,
+      void 0,
+      options
+    );
+    return raw.sequence;
+  }
+  /**
+   * Stop (terminate) a sequence.
+   */
+  async stop(sequenceId, options) {
+    const raw = await this.client.post(
+      `/api/sequences/${sequenceId}/stop`,
+      void 0,
+      options
+    );
+    return raw.sequence;
+  }
+  /**
+   * Get the current status of a sequence.
+   */
+  async status(sequenceId, options) {
+    const raw = await this.client.get(
+      `/api/sequences/${sequenceId}/status`,
+      options
+    );
+    return raw.sequence;
+  }
+};
+
+// src/resources/drafts.ts
+var Drafts = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Generate outreach drafts for a list of contacts.
+   */
+  async generate(params, options) {
+    return this.client.post("/api/drafts/generate", params, options);
+  }
+  /**
+   * List drafts, optionally filtered by conversation, batch, or status. Paginated.
+   */
+  async list(params, options) {
+    const query = {};
+    if (params?.conversationId) query.conversationId = params.conversationId;
+    if (params?.batchId) query.batchId = params.batchId;
+    if (params?.status) query.status = params.status;
+    if (params?.page) query.page = params.page;
+    if (params?.perPage) query.perPage = params.perPage;
+    return fetchPage({
+      client: this.client,
+      method: "GET",
+      path: "/api/drafts",
+      query,
+      responseKey: "drafts",
+      options
+    });
+  }
+  /**
+   * Update a specific draft's subject and/or body.
+   */
+  async update(draftId, params, options) {
+    const raw = await this.client.put(
+      `/api/drafts/${draftId}`,
+      params,
+      options
+    );
+    return raw.draft;
+  }
+  /**
+   * Approve drafts by their IDs.
+   */
+  async approve(params, options) {
+    return this.client.post("/api/drafts/approve", params, options);
+  }
+  /**
+   * Send approved drafts.
+   */
+  async send(params, options) {
+    return this.client.post("/api/drafts/send", params, options);
+  }
+};
+
+// src/resources/messages.ts
+var Messages = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Send an email via Gmail or AgentMail.
+   */
+  async sendEmail(params, options) {
+    return this.client.post("/api/messages/email", params, options);
+  }
+  /**
+   * Send a LinkedIn message or connection request.
+   */
+  async sendLinkedIn(params, options) {
+    return this.client.post("/api/messages/linkedin", params, options);
+  }
+  /**
+   * Send an Instagram DM.
+   */
+  async sendInstagram(params, options) {
+    return this.client.post("/api/messages/instagram", params, options);
+  }
+  /**
+   * Send an SMS message.
+   */
+  async sendSms(params, options) {
+    return this.client.post("/api/messages/sms", params, options);
+  }
+  /**
+   * Get the unified inbox for a specific channel.
+   */
+  async inbox(channel, options) {
+    return this.client.get(
+      `/api/messages/inbox/${channel}`,
+      options
+    );
+  }
+};
+
+// src/resources/chat.ts
+var ConversationsResource = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all conversations.
+   */
+  async list(options) {
+    const raw = await this.client.get(
+      "/api/chat/conversations",
+      options
+    );
+    return raw.conversations;
+  }
+  /**
+   * Get messages for a specific conversation.
+   */
+  async get(conversationId, options) {
+    const raw = await this.client.get(
+      `/api/chat/conversations/${conversationId}`,
+      options
+    );
+    return raw.messages;
+  }
+  /**
+   * Delete a conversation.
+   */
+  async delete(conversationId, options) {
+    await this.client.delete(
+      `/api/chat/conversations/${conversationId}`,
+      options
+    );
+  }
+};
+var Chat = class {
+  client;
+  /** Sub-resource for managing conversations. */
+  conversations;
+  constructor(client) {
+    this.client = client;
+    this.conversations = new ConversationsResource(client);
+  }
+  /**
+   * Send a message to the AI assistant.
+   */
+  async create(params, options) {
+    return this.client.post("/api/chat", params, options);
+  }
+};
+
+// src/resources/channels.ts
+var GmailChannel = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Initiate Gmail OAuth flow. Returns an authUrl for the user to visit.
+   */
+  async connect(options) {
+    return this.client.post("/api/channels/gmail/connect", void 0, options);
+  }
+};
+var LinkedInChannel = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Connect a LinkedIn account with credentials.
+   */
+  async connect(params, options) {
+    return this.client.post("/api/channels/linkedin/connect", params, options);
+  }
+  /**
+   * Resolve a LinkedIn 2FA checkpoint.
+   */
+  async checkpoint(params, options) {
+    return this.client.post("/api/channels/linkedin/checkpoint", params, options);
+  }
+};
+var InstagramChannel = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Connect an Instagram account with credentials.
+   */
+  async connect(params, options) {
+    return this.client.post("/api/channels/instagram/connect", params, options);
+  }
+  /**
+   * Resolve an Instagram 2FA checkpoint.
+   */
+  async checkpoint(params, options) {
+    return this.client.post("/api/channels/instagram/checkpoint", params, options);
+  }
+};
+var AgentMailChannel = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new AgentMail address.
+   */
+  async create(params, options) {
+    return this.client.post("/api/channels/agentmail/create", params, options);
+  }
+};
+var SmsChannel = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Initiate SMS verification for a phone number.
+   */
+  async verify(params, options) {
+    return this.client.post("/api/channels/sms/verify", params, options);
+  }
+  /**
+   * Confirm SMS verification with the code.
+   */
+  async confirm(params, options) {
+    return this.client.post("/api/channels/sms/confirm", params, options);
+  }
+};
+var Channels = class {
+  client;
+  /** Gmail channel operations. */
+  gmail;
+  /** LinkedIn channel operations. */
+  linkedin;
+  /** Instagram channel operations. */
+  instagram;
+  /** AgentMail channel operations. */
+  agentmail;
+  /** SMS channel operations. */
+  sms;
+  constructor(client) {
+    this.client = client;
+    this.gmail = new GmailChannel(client);
+    this.linkedin = new LinkedInChannel(client);
+    this.instagram = new InstagramChannel(client);
+    this.agentmail = new AgentMailChannel(client);
+    this.sms = new SmsChannel(client);
+  }
+  /**
+   * Get the connection status of all channels.
+   */
+  async status(options) {
+    return this.client.get("/api/channels/status", options);
+  }
+  /**
+   * Disconnect a specific channel.
+   */
+  async disconnect(channel, options) {
+    await this.client.post(`/api/channels/${channel}/disconnect`, void 0, options);
+  }
+};
+
+// src/resources/documents.ts
+var Documents = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Upload a document.
+   */
+  async upload(params, options) {
+    const raw = await this.client.post(
+      "/api/documents",
+      params,
+      options
+    );
+    return raw.document;
+  }
+  /**
+   * List all documents. Paginated.
+   */
+  async list(params, options) {
+    const query = {};
+    if (params?.page) query.page = params.page;
+    if (params?.perPage) query.perPage = params.perPage;
+    return fetchPage({
+      client: this.client,
+      method: "GET",
+      path: "/api/documents",
+      query,
+      responseKey: "documents",
+      options
+    });
+  }
+  /**
+   * Delete a document by ID.
+   */
+  async delete(documentId, options) {
+    await this.client.delete(`/api/documents/${documentId}`, options);
+  }
+};
+
+// src/resources/recommendations.ts
+var Recommendations = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get an ICP analysis recommendation.
+   */
+  async icpAnalysis(options) {
+    return this.client.get("/api/recommendations/icp", options);
+  }
+  /**
+   * Get a channel recommendation.
+   */
+  async channel(options) {
+    return this.client.get("/api/recommendations/channel", options);
+  }
+  /**
+   * Get a sequence strategy recommendation.
+   */
+  async sequenceStrategy(options) {
+    return this.client.get("/api/recommendations/sequence-strategy", options);
+  }
+};
+
+// src/resources/billing.ts
+var Billing = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get the current credit balance.
+   */
+  async balance(options) {
+    return this.client.get("/api/billing/balance", options);
+  }
+  /**
+   * List usage entries. Paginated.
+   */
+  async usage(params, options) {
+    const query = {};
+    if (params?.from) query.from = params.from;
+    if (params?.to) query.to = params.to;
+    if (params?.page) query.page = params.page;
+    return fetchPage({
+      client: this.client,
+      method: "GET",
+      path: "/api/billing/usage",
+      query,
+      responseKey: "usage",
+      options
+    });
+  }
+  /**
+   * Get an aggregated usage summary.
+   */
+  async usageSummary(options) {
+    return this.client.get("/api/billing/usage/summary", options);
+  }
+};
+
+// src/resources/users.ts
+var Users = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Register a new user.
+   */
+  async register(params, options) {
+    const raw = await this.client.post(
+      "/api/users/register",
+      params,
+      options
+    );
+    return raw.user;
+  }
+  /**
+   * Get the current user's profile.
+   */
+  async me(options) {
+    const raw = await this.client.get("/api/users/me", options);
+    return raw.user;
+  }
+  /**
+   * Update the current user's profile.
+   */
+  async update(params, options) {
+    const raw = await this.client.put(
+      "/api/users/me",
+      params,
+      options
+    );
+    return raw.user;
+  }
+};
+
+// src/client.ts
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+var GeoDedo = class {
+  _client;
+  /** Contact search, enrichment, and import. */
+  contacts;
+  /** Outreach sequence management. */
+  sequences;
+  /** Draft generation, review, and sending. */
+  drafts;
+  /** Direct message sending (email, LinkedIn, Instagram, SMS). */
+  messages;
+  /** AI chat assistant. */
+  chat;
+  /** Channel connection management. */
+  channels;
+  /** Document upload and management. */
+  documents;
+  /** AI-powered recommendations. */
+  recommendations;
+  /** Credit balance and usage tracking. */
+  billing;
+  /** User registration and profile management. */
+  users;
+  constructor(options) {
+    let envKey;
+    try {
+      if (typeof globalThis !== "undefined" && "process" in globalThis) {
+        envKey = globalThis.process?.env?.GEODEDO_API_KEY;
+      }
+    } catch {
+    }
+    const apiKey = options?.apiKey ?? envKey;
+    if (!apiKey) {
+      throw new GeoDedoError(
+        "The GEODEDO_API_KEY environment variable is missing or empty; either provide it, or pass the `apiKey` option to the GeoDedo constructor."
+      );
+    }
+    if (isBrowser() && !options?.dangerouslyAllowBrowser) {
+      throw new GeoDedoError(
+        "It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API key to attackers.\nIf you understand the risks and have appropriate mitigations in place,\nyou can set the `dangerouslyAllowBrowser` option to `true`, e.g.,\n\nnew GeoDedo({ apiKey: '...', dangerouslyAllowBrowser: true })"
+      );
+    }
+    this._client = new APIClient({
+      apiKey,
+      userId: options?.userId,
+      baseURL: options?.baseURL,
+      maxRetries: options?.maxRetries,
+      timeout: options?.timeout
+    });
+    this.contacts = new Contacts(this._client);
+    this.sequences = new Sequences(this._client);
+    this.drafts = new Drafts(this._client);
+    this.messages = new Messages(this._client);
+    this.chat = new Chat(this._client);
+    this.channels = new Channels(this._client);
+    this.documents = new Documents(this._client);
+    this.recommendations = new Recommendations(this._client);
+    this.billing = new Billing(this._client);
+    this.users = new Users(this._client);
+  }
+};
+export {
+  APIClient,
+  APIConnectionError,
+  APIError,
+  APITimeoutError,
+  AgentMailChannel,
+  AuthenticationError,
+  Billing,
+  Channels,
+  Chat,
+  Contacts,
+  ConversationsResource,
+  Documents,
+  Drafts,
+  GeoDedo,
+  GeoDedoError,
+  GmailChannel,
+  InstagramChannel,
+  InsufficientCreditsError,
+  InternalServerError,
+  LinkedInChannel,
+  Messages,
+  NotFoundError,
+  Page,
+  PermissionDeniedError,
+  RateLimitError,
+  Recommendations,
+  Sequences,
+  SmsChannel,
+  Users,
+  ValidationError
+};
+//# sourceMappingURL=index.js.map