@hellopivot/sdk 0.0.1

package/dist/index.mjs

@@ -0,0 +1,829 @@
+import { createHmac, timingSafeEqual } from 'crypto';
+
+// libs/pivot-sdk/src/errors.ts
+var PivotError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PivotError";
+  }
+};
+var PivotAPIError = class extends PivotError {
+  status;
+  statusText;
+  body;
+  headers;
+  constructor(status, statusText, body, headers) {
+    const message = typeof body === "object" && body !== null && "message" in body ? String(body.message) : `API error: ${status} ${statusText}`;
+    super(message);
+    this.name = "PivotAPIError";
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.headers = headers;
+  }
+};
+var PivotTimeoutError = class extends PivotError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "PivotTimeoutError";
+  }
+};
+var PivotRetryError = class extends PivotError {
+  lastError;
+  attempts;
+  constructor(lastError, attempts) {
+    super(
+      `All ${attempts} retry attempts failed. Last error: ${lastError.message}`
+    );
+    this.name = "PivotRetryError";
+    this.lastError = lastError;
+    this.attempts = attempts;
+  }
+};
+var PivotAuthenticationError = class extends PivotError {
+  constructor() {
+    super(
+      "API key is required. Pass it via the `apiKey` option or set the PIVOT_API_KEY environment variable."
+    );
+    this.name = "PivotAuthenticationError";
+  }
+};
+
+// libs/pivot-sdk/src/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelayMs: 500,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2,
+  jitterFactor: 0.25,
+  retryableStatusCodes: [408, 409, 429, 500, 502, 503, 504]
+};
+function calculateDelay(attempt, config) {
+  const baseDelay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
+  const cappedDelay = Math.min(baseDelay, config.maxDelayMs);
+  const jitter = cappedDelay * config.jitterFactor * (2 * Math.random() - 1);
+  return Math.max(0, Math.round(cappedDelay + jitter));
+}
+function isRetryable(error, config) {
+  if (error instanceof TypeError) return true;
+  if (error instanceof PivotAPIError) {
+    return config.retryableStatusCodes.includes(error.status);
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, config) {
+  let lastError;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const retryable = isRetryable(error, config);
+      if (attempt < config.maxRetries && retryable) {
+        let delayMs = calculateDelay(attempt, config);
+        if (error instanceof PivotAPIError) {
+          const retryAfter = error.headers["retry-after"];
+          if (retryAfter) {
+            const retryAfterMs = Number(retryAfter) * 1e3;
+            if (!isNaN(retryAfterMs) && retryAfterMs > 0) {
+              delayMs = Math.min(retryAfterMs, config.maxDelayMs);
+            }
+          }
+        }
+        await sleep(delayMs);
+        continue;
+      }
+      if (!retryable) {
+        throw lastError;
+      }
+      break;
+    }
+  }
+  throw new PivotRetryError(
+    lastError ?? new Error("Unknown error"),
+    config.maxRetries + 1
+  );
+}
+
+// libs/pivot-sdk/src/client-core.ts
+var PivotClientCore = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  retryConfig;
+  fetchFn;
+  defaultHeaders;
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? (typeof process !== "undefined" ? process.env?.["PIVOT_API_KEY"] ?? "" : "");
+    if (!this.apiKey) {
+      throw new PivotAuthenticationError();
+    }
+    this.baseUrl = (options.baseUrl ?? "https://api.pivot.app").replace(
+      /\/$/,
+      ""
+    );
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...options.defaultHeaders
+    };
+    if (options.retry === false) {
+      this.retryConfig = false;
+    } else {
+      this.retryConfig = {
+        ...DEFAULT_RETRY_CONFIG,
+        ...options.retry
+      };
+    }
+  }
+  /**
+   * Make an authenticated HTTP request to the Pivot API.
+   */
+  async request(method, path, options = {}) {
+    const doRequest = async () => {
+      const url = new URL(`${this.baseUrl}${path}`);
+      if (options.query) {
+        for (const [key, value] of Object.entries(options.query)) {
+          if (value !== void 0 && value !== null) {
+            if (Array.isArray(value)) {
+              for (const v of value) {
+                url.searchParams.append(key, String(v));
+              }
+            } else {
+              url.searchParams.set(key, String(value));
+            }
+          }
+        }
+      }
+      const headers = {
+        ...this.defaultHeaders,
+        Authorization: `Bearer ${this.apiKey}`,
+        ...options.headers
+      };
+      const init = {
+        method,
+        headers
+      };
+      if (options.body !== void 0 && method !== "GET") {
+        init.body = JSON.stringify(options.body);
+      }
+      const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+      const controller = new AbortController();
+      let didTimeout = false;
+      const timeoutId = setTimeout(() => {
+        didTimeout = true;
+        controller.abort();
+      }, timeoutMs);
+      const onAbort = () => controller.abort();
+      if (options.signal) {
+        if (options.signal.aborted) {
+          controller.abort();
+        } else {
+          options.signal.addEventListener("abort", onAbort, { once: true });
+        }
+      }
+      init.signal = controller.signal;
+      let response;
+      try {
+        response = await this.fetchFn(url.toString(), init);
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error?.name === "AbortError" && didTimeout) {
+          throw new PivotTimeoutError(timeoutMs);
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+        if (options.signal) {
+          options.signal.removeEventListener("abort", onAbort);
+        }
+      }
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      if (!response.ok) {
+        let body;
+        try {
+          body = await response.json();
+        } catch {
+          body = await response.text().catch(() => null);
+        }
+        throw new PivotAPIError(
+          response.status,
+          response.statusText,
+          body,
+          responseHeaders
+        );
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        return await response.json();
+      }
+      return await response.text();
+    };
+    if (this.retryConfig) {
+      return withRetry(doRequest, this.retryConfig);
+    }
+    return doRequest();
+  }
+};
+
+// libs/pivot-sdk/src/generated/resources.ts
+var BlocksResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Delete a block response attachment
+   * 
+   * Deletes a file attached to a block response.
+   */
+  async deleteBlockResponseAttachment(attachmentId) {
+    return this.client.request("DELETE", `/v1/blocks/responses/attachments/${attachmentId}`);
+  }
+  /**
+   * Delete a block response
+   * 
+   * Deletes a response from a block.
+   */
+  async deleteResponseForBlock(responseId) {
+    return this.client.request("DELETE", `/v1/blocks/responses/${responseId}`);
+  }
+  /**
+   * Update block response
+   * 
+   * Updates an existing block response.
+   */
+  async updateResponseForBlock(responseId, body) {
+    return this.client.request("PATCH", `/v1/blocks/responses/${responseId}`, { body });
+  }
+  /**
+   * Create an attachment for a block response
+   * 
+   * Adds a file to a block response.
+   */
+  async createBlockResponseAttachment(responseId, body) {
+    return this.client.request("POST", `/v1/blocks/responses/${responseId}/attachments`, { body });
+  }
+  /**
+   * Send block response
+   * 
+   * Sends or marks the response as submitted.
+   */
+  async sendResponseForBlock(responseId) {
+    return this.client.request("POST", `/v1/blocks/responses/${responseId}/send`);
+  }
+  /**
+   * Get block
+   * 
+   * Returns a block by ID.
+   */
+  async getBlockById(blockId) {
+    return this.client.request("GET", `/v1/blocks/${blockId}`);
+  }
+  /**
+   * List block responses
+   * 
+   * Returns responses for a block.
+   */
+  async getBlockResponsesByBlockId(blockId) {
+    return this.client.request("GET", `/v1/blocks/${blockId}/responses`);
+  }
+  /**
+   * Create block response
+   * 
+   * Creates a new response for a block.
+   */
+  async createResponseForBlock(blockId, body) {
+    return this.client.request("POST", `/v1/blocks/${blockId}/responses`, { body });
+  }
+};
+var GroupsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List groups
+   * 
+   * Returns groups in the organization.
+   */
+  async getGroupsByOrganizationId(organizationId, offset) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/groups/${offset}`);
+  }
+  /**
+   * List group members
+   * 
+   * Returns users in the specified group.
+   */
+  async getGroupMembersByGroupId(organizationId, groupId) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/${groupId}/members`);
+  }
+  /**
+   * Add group members
+   * 
+   * Adds users to the specified group.
+   */
+  async createGroupMembersByGroupId(organizationId, groupId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/${groupId}/members`, { body });
+  }
+  /**
+   * Remove group members
+   * 
+   * Removes users from a group.
+   */
+  async deleteGroupMembersByGroupId(organizationId, groupId, query) {
+    return this.client.request("DELETE", `/v1/organizations/${organizationId}/${groupId}/members`, { query });
+  }
+};
+var InvitesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Revoke invite by ID
+   * 
+   * Revokes an invitation by its unique ID and email address.
+   */
+  async revokeInviteById(organizationId, inviteId, email) {
+    return this.client.request("DELETE", `/v1/organizations/${organizationId}/invites/${inviteId}/${email}`);
+  }
+};
+var LabelsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Delete label
+   * 
+   * Deletes a label.
+   */
+  async deleteLabel(labelId) {
+    return this.client.request("DELETE", `/v1/labels/${labelId}`);
+  }
+  /**
+   * Update label
+   * 
+   * Updates an existing label.
+   */
+  async updateLabel(labelId, body) {
+    return this.client.request("PATCH", `/v1/labels/${labelId}`, { body });
+  }
+  /**
+   * List organization labels
+   * 
+   * Returns labels in the organization.
+   */
+  async getLabelsByOrganizationId(organizationId) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/labels`);
+  }
+  /**
+   * Create label
+   * 
+   * Creates a new label in the organization.
+   */
+  async createLabel(organizationId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/labels`, { body });
+  }
+  /**
+   * Update space labels
+   * 
+   * Adds labels to a space without removing existing labels. To remove labels, use the DELETE endpoint.
+   */
+  async updateSpaceLabels(spaceId, body) {
+    return this.client.request("PATCH", `/v1/spaces/${spaceId}/labels`, { body });
+  }
+  /**
+   * Remove label from space
+   * 
+   * Removes a single label from a space.
+   */
+  async removeLabelFromSpace(spaceId, labelId) {
+    return this.client.request("DELETE", `/v1/spaces/${spaceId}/labels/${labelId}`);
+  }
+};
+var RoomsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get room
+   * 
+   * Returns a room by ID.
+   */
+  async getRoomById(roomId) {
+    return this.client.request("GET", `/v1/rooms/${roomId}`);
+  }
+  /**
+   * Invite to room
+   * 
+   * Invites users to a room by email.
+   */
+  async inviteToRoomByEmails(roomId, body) {
+    return this.client.request("POST", `/v1/rooms/${roomId}/invites`, { body });
+  }
+  /**
+   * Revoke room invite
+   * 
+   * Revokes an invitation to a room by email address.
+   */
+  async revokeRoomInvite(roomId, email) {
+    return this.client.request("DELETE", `/v1/rooms/${roomId}/invites/${email}`);
+  }
+  /**
+   * Add room members
+   * 
+   * Adds users to a room with a role.
+   */
+  async createRoomMembersByRoomId(roomId, body) {
+    return this.client.request("POST", `/v1/rooms/${roomId}/members`, { body });
+  }
+  /**
+   * List room messages (Deprecated)
+   * 
+   * Deprecated: Use GET /v2/rooms/{room_id}/messages instead. Returns messages in a room by offset.
+   * @deprecated
+   */
+  async getMessagesByRoomId(roomId, offset) {
+    return this.client.request("GET", `/v1/rooms/${roomId}/messages/${offset}`);
+  }
+  /**
+   * List message replies (Deprecated)
+   * 
+   * Deprecated: Use GET /v2/rooms/{room_id}/threads/{parent_id}/messages instead. Returns replies under a parent message.
+   * @deprecated
+   */
+  async getMessagesByParentId(roomId, parentId, query) {
+    return this.client.request("GET", `/v1/rooms/${roomId}/messages/${parentId}/children`, { query });
+  }
+  /**
+   * List room recordings
+   * 
+   * Returns recordings for a room, including transcripts and other assets.
+   */
+  async getRoomRecordingsByRoomId(roomId, query) {
+    return this.client.request("GET", `/v1/rooms/${roomId}/recordings`, { query });
+  }
+  /**
+   * Get room recording
+   * 
+   * Returns a specific room recording by ID, including transcripts and other assets.
+   */
+  async getRoomRecordingById(roomId, recordingId, query) {
+    return this.client.request("GET", `/v1/rooms/${roomId}/recordings/${recordingId}`, { query });
+  }
+  /**
+   * Get active participants in a room and their messages stats
+   * 
+   * Returns active users in a room and their message stats.
+   */
+  async getRoomActiveParticipants(roomId) {
+    return this.client.request("GET", `/v1/rooms/${roomId}/users`);
+  }
+  /**
+   * List room messages
+   * 
+   * Returns messages in a room using cursor-based pagination (newest first). For partition navigation, backfill strategy, and examples, see https://pivot.app/docs/developers/rest-api/message-retrieval.
+   */
+  async getRoomMessages(roomId, query) {
+    return this.client.request("GET", `/v2/rooms/${roomId}/messages`, { query });
+  }
+  /**
+     * Get message by ID
+     * 
+     * Retrieves a single message by ID.
+  
+  The `sent_at` parameter is currently optional but will become required in a future release. For thread messages, `thread_parent_message_id` will also become required. Clients should start passing these parameters now to ensure continued functionality after the migration.
+     */
+  async getMessageById(roomId, messageId, query) {
+    return this.client.request("GET", `/v2/rooms/${roomId}/messages/${messageId}`, { query });
+  }
+  /**
+   * List thread messages
+   * 
+   * Returns messages in a thread using cursor-based pagination (oldest first). For guidance and examples, see https://pivot.app/docs/developers/rest-api/message-retrieval.
+   */
+  async getThreadMessages(roomId, parentId, query) {
+    return this.client.request("GET", `/v2/rooms/${roomId}/threads/${parentId}/messages`, { query });
+  }
+};
+var SpacesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create space
+   * 
+   * Creates a new space in the organization.
+   */
+  async createSpace(organizationId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/spaces`, { body });
+  }
+  /**
+   * List spaces
+   * 
+   * Returns spaces in the organization. Filter by status using 'active', 'archived', 'hidden', or 'deleted'. If no status is provided, defaults to returning only active spaces. Sort results using sort_by: 'created_at_asc' (default), 'created_at_desc', 'last_activity_asc', or 'last_activity_desc'.
+   */
+  async getSpacesByOrganizationId(organizationId, offset, query) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/spaces/${offset}`, { query });
+  }
+  /**
+   * Update space
+   * 
+   * Updates space settings or metadata.
+   */
+  async updateSpace(organizationId, spaceId, body) {
+    return this.client.request("PATCH", `/v1/organizations/${organizationId}/spaces/${spaceId}`, { body });
+  }
+  /**
+   * List assignment blocks
+   * 
+   * Returns all assignment blocks in the space.
+   */
+  async getAssignmentBlocksBySpaceId(organizationId, spaceId) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/spaces/${spaceId}/assignments`);
+  }
+  /**
+   * Copy space
+   * 
+   * Creates a copy of an existing space with a new name.
+   */
+  async copySpace(organizationId, spaceId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/spaces/${spaceId}/copy`, { body });
+  }
+  /**
+   * Add group to space
+   * 
+   * Grants a group access to a space.
+   */
+  async addGroupToSpace(organizationId, spaceId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/spaces/${spaceId}/groups`, { body });
+  }
+  /**
+   * Hide space
+   * 
+   * Hides a space from view.
+   */
+  async hideSpace(organizationId, spaceId) {
+    return this.client.request("PATCH", `/v1/organizations/${organizationId}/spaces/${spaceId}/hide`);
+  }
+  /**
+   * Invite to space
+   * 
+   * Invite users by email. Existing users are added directly.
+   */
+  async inviteToSpaceByEmails(organizationId, spaceId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/spaces/${spaceId}/invites`, { body });
+  }
+  /**
+   * Revoke space invite
+   * 
+   * Revokes an invitation to a space by email address.
+   */
+  async revokeSpaceInvite(organizationId, spaceId, email) {
+    return this.client.request("DELETE", `/v1/organizations/${organizationId}/spaces/${spaceId}/invites/${email}`);
+  }
+  /**
+   * Add space members
+   * 
+   * Adds users to a space.
+   */
+  async createSpaceMembersBySpaceId(organizationId, spaceId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/spaces/${spaceId}/members`, { body });
+  }
+  /**
+   * Remove space member
+   * 
+   * Removes a user from a space.
+   */
+  async deleteSpaceMember(organizationId, spaceId, memberId) {
+    return this.client.request("DELETE", `/v1/organizations/${organizationId}/spaces/${spaceId}/members/${memberId}`);
+  }
+  /**
+   * Update space member
+   * 
+   * Updates a member’s role or title in a space.
+   */
+  async updateSpaceMember(organizationId, spaceId, memberId, body) {
+    return this.client.request("PATCH", `/v1/organizations/${organizationId}/spaces/${spaceId}/members/${memberId}`, { body });
+  }
+  /**
+   * List space members
+   * 
+   * Returns members of a space.
+   */
+  async getSpaceMembers(organizationId, spaceId, offset) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/spaces/${spaceId}/members/${offset}`);
+  }
+  /**
+   * List space roles
+   * 
+   * Returns roles available in a space.
+   */
+  async getSpaceRoles(organizationId, spaceId) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/spaces/${spaceId}/roles`);
+  }
+  /**
+   * Create space role
+   * 
+   * Creates a custom role in a space.
+   */
+  async createSpaceRole(organizationId, spaceId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/spaces/${spaceId}/roles`, { body });
+  }
+  /**
+   * List room blocks
+   * 
+   * Returns all room blocks in the space.
+   */
+  async getRoomBlocksBySpaceId(organizationId, spaceId) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/spaces/${spaceId}/rooms`);
+  }
+};
+var UsersResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get user context
+   * 
+   * Returns user info, memberships, and groups.
+   */
+  async getUserContextByOrganizationId(organizationId, identifier) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/users/${identifier}`);
+  }
+  /**
+   * Delete user
+   * 
+   * Deletes a user if their email is verified by the org and not verified by any others. This is permanent and affects all orgs.
+   */
+  async deleteUser(organizationId, identifier) {
+    return this.client.request("DELETE", `/v1/organizations/${organizationId}/users/${identifier}`);
+  }
+  /**
+   * Delete or remove user
+   * 
+   * Deletes the user if verified by the org; otherwise removes org memberships.
+   */
+  async deleteVerifiedUserOrRemoveFromOrg(organizationId, userId) {
+    return this.client.request("DELETE", `/v1/organizations/${organizationId}/users/${userId}/membership`);
+  }
+};
+var WebhooksResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List webhooks
+   * 
+   * Returns all webhooks for the organization.
+   */
+  async getWebhooksByOrganizationId(organizationId) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/webhooks`);
+  }
+  /**
+   * Create webhook
+   * 
+   * Creates a new webhook for the organization. Returns the webhook secret which must be stored securely.
+   */
+  async createWebhook(organizationId, body) {
+    return this.client.request("POST", `/v1/organizations/${organizationId}/webhooks`, { body });
+  }
+  /**
+   * Delete webhook
+   * 
+   * Deletes a webhook.
+   */
+  async deleteWebhook(organizationId, webhookId) {
+    return this.client.request("DELETE", `/v1/organizations/${organizationId}/webhooks/${webhookId}`);
+  }
+  /**
+   * Update webhook
+   * 
+   * Updates an existing webhook. If subscriptions are provided, they replace all existing subscriptions.
+   */
+  async updateWebhook(organizationId, webhookId, body) {
+    return this.client.request("PATCH", `/v1/organizations/${organizationId}/webhooks/${webhookId}`, { body });
+  }
+  /**
+   * Get webhook logs
+   * 
+   * Returns delivery logs for a webhook. Logs are retained for 30 days.
+   */
+  async getWebhookLogs(organizationId, webhookId, query) {
+    return this.client.request("GET", `/v1/organizations/${organizationId}/webhooks/${webhookId}/logs`, { query });
+  }
+};
+
+// libs/pivot-sdk/src/client.ts
+var Pivot = class {
+  core;
+  /** Block operations (pages, assignments, forms, etc.) */
+  blocks;
+  /** Group operations */
+  groups;
+  /** Invite operations */
+  invites;
+  /** Label operations */
+  labels;
+  /** Room operations (chat, messages, recordings) */
+  rooms;
+  /** Space operations */
+  spaces;
+  /** User operations */
+  users;
+  /** Webhook operations */
+  webhooks;
+  constructor(options) {
+    this.core = new PivotClientCore(options);
+    this.blocks = new BlocksResource(this.core);
+    this.groups = new GroupsResource(this.core);
+    this.invites = new InvitesResource(this.core);
+    this.labels = new LabelsResource(this.core);
+    this.rooms = new RoomsResource(this.core);
+    this.spaces = new SpacesResource(this.core);
+    this.users = new UsersResource(this.core);
+    this.webhooks = new WebhooksResource(this.core);
+  }
+};
+
+// libs/pivot-sdk/src/pagination.ts
+async function autoPageOffset(fetchPage, extractPage, options = {}) {
+  const { startOffset = 0, maxItems = Infinity } = options;
+  const allItems = [];
+  let currentOffset = startOffset;
+  while (allItems.length < maxItems) {
+    const response = await fetchPage(currentOffset);
+    const page = extractPage(response);
+    allItems.push(...page.items);
+    const nextOffset = page.nextOffset;
+    if (page.items.length === 0 || nextOffset == null) {
+      break;
+    }
+    if (nextOffset <= currentOffset) {
+      throw new Error(
+        `Offset pagination did not advance (current=${currentOffset}, next=${nextOffset}).`
+      );
+    }
+    currentOffset = nextOffset;
+  }
+  return allItems.slice(0, maxItems);
+}
+async function autoPageCursor(fetchPage, extractPage, options = {}) {
+  const { maxItems = Infinity, maxPages = Infinity } = options;
+  const allItems = [];
+  let cursor;
+  let pageCount = 0;
+  while (allItems.length < maxItems && pageCount < maxPages) {
+    const response = await fetchPage(cursor);
+    const page = extractPage(response);
+    allItems.push(...page.items);
+    pageCount++;
+    if (!page.hasMore || page.items.length === 0) {
+      break;
+    }
+    if (!page.nextCursor) {
+      throw new Error(
+        "Cursor pagination indicated more pages but no nextCursor was returned."
+      );
+    }
+    cursor = page.nextCursor;
+  }
+  return allItems.slice(0, maxItems);
+}
+function verifyWebhookSignature(payload, signature, secret) {
+  if (!payload || !signature || !secret) {
+    return false;
+  }
+  const expectedSignature = "sha256=" + createHmac("sha256", secret).update(payload).digest("hex");
+  const sigBuffer = Buffer.from(signature);
+  const expectedBuffer = Buffer.from(expectedSignature);
+  if (sigBuffer.length !== expectedBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(sigBuffer, expectedBuffer);
+}
+function constructWebhookSignature(payload, secret) {
+  return "sha256=" + createHmac("sha256", secret).update(payload).digest("hex");
+}
+function parseWebhookEvent(payload, signature, secret) {
+  if (!verifyWebhookSignature(payload, signature, secret)) {
+    throw new Error(
+      "Invalid webhook signature. Ensure you are using the correct secret."
+    );
+  }
+  const event = JSON.parse(payload);
+  if (!event.eventType || !event.organizationId || !event.subject) {
+    throw new Error("Invalid webhook payload: missing required fields.");
+  }
+  return event;
+}
+
+export { BlocksResource, DEFAULT_RETRY_CONFIG, GroupsResource, InvitesResource, LabelsResource, Pivot, PivotAPIError, PivotAuthenticationError, PivotError, PivotRetryError, PivotTimeoutError, RoomsResource, SpacesResource, UsersResource, WebhooksResource, autoPageCursor, autoPageOffset, constructWebhookSignature, Pivot as default, parseWebhookEvent, verifyWebhookSignature };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map