@spike-forms/sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,1569 @@
+'use strict';
+
+// src/errors.ts
+var SpikeError = class extends Error {
+  /** HTTP status code from the API response */
+  statusCode;
+  /** Error code from the API (e.g., 'INVALID_API_KEY', 'FORM_NOT_FOUND') */
+  code;
+  /** Request ID for debugging and support purposes */
+  requestId;
+  constructor(message, options) {
+    super(message);
+    this.name = "SpikeError";
+    this.statusCode = options?.statusCode;
+    this.code = options?.code;
+    this.requestId = options?.requestId;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var AuthenticationError = class extends SpikeError {
+  constructor(message, options) {
+    super(message, { statusCode: 401, ...options });
+    this.name = "AuthenticationError";
+  }
+};
+var NotFoundError = class extends SpikeError {
+  constructor(message, options) {
+    super(message, { statusCode: 404, ...options });
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends SpikeError {
+  /** Number of seconds to wait before retrying the request */
+  retryAfter;
+  constructor(message, options) {
+    super(message, { statusCode: 429, code: options?.code, requestId: options?.requestId });
+    this.name = "RateLimitError";
+    this.retryAfter = options?.retryAfter;
+  }
+};
+var ValidationError = class extends SpikeError {
+  /** Field-specific validation error details */
+  details;
+  constructor(message, options) {
+    super(message, { statusCode: 400, code: options?.code, requestId: options?.requestId });
+    this.name = "ValidationError";
+    this.details = options?.details;
+  }
+};
+var NetworkError = class extends SpikeError {
+  constructor(message, options) {
+    super(message, { code: options?.code, requestId: options?.requestId });
+    this.name = "NetworkError";
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl;
+    this.timeout = config.timeout;
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, options) {
+    return this.request("GET", path, void 0, options);
+  }
+  /**
+   * Make a POST request with authentication
+   */
+  async post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  /**
+   * Make a PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request("PATCH", path, body, options);
+  }
+  /**
+   * Make a PUT request
+   */
+  async put(path, body, options) {
+    return this.request("PUT", path, body, options);
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path, options) {
+    return this.request("DELETE", path, void 0, options);
+  }
+  /**
+   * Make a POST request without authentication (for public form submissions)
+   */
+  async postPublic(path, body, options) {
+    return this.request("POST", path, body, options, false);
+  }
+  /**
+   * Build a URL with query parameters
+   */
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Make an HTTP request with timeout and error handling
+   */
+  async request(method, path, body, options, authenticated = true) {
+    const url = this.buildUrl(path, options?.params);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const headers = {
+        ...options?.headers
+      };
+      if (authenticated) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      if (body !== void 0) {
+        headers["Content-Type"] = "application/json";
+      }
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const text = await response.text();
+      if (!text) {
+        return {};
+      }
+      return JSON.parse(text);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError(`Request timeout after ${this.timeout}ms`);
+      }
+      if (error instanceof SpikeError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        throw new NetworkError(error.message);
+      }
+      throw new NetworkError("An unknown network error occurred");
+    }
+  }
+  /**
+   * Handle error responses and throw appropriate SDK errors
+   */
+  async handleErrorResponse(response) {
+    let errorData = {};
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    try {
+      const text = await response.text();
+      if (text) {
+        errorData = JSON.parse(text);
+      }
+    } catch {
+    }
+    const message = errorData.error || errorData.message || response.statusText || "Request failed";
+    const code = errorData.code;
+    switch (response.status) {
+      case 400:
+        throw new ValidationError(message, {
+          code,
+          requestId,
+          details: errorData.details
+        });
+      case 401:
+        throw new AuthenticationError(message, {
+          code,
+          requestId
+        });
+      case 404:
+        throw new NotFoundError(message, {
+          code,
+          requestId
+        });
+      case 429: {
+        const retryAfterHeader = response.headers.get("Retry-After");
+        const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : void 0;
+        throw new RateLimitError(message, {
+          code,
+          requestId,
+          retryAfter: Number.isNaN(retryAfter) ? void 0 : retryAfter
+        });
+      }
+      default:
+        throw new SpikeError(message, {
+          statusCode: response.status,
+          code,
+          requestId
+        });
+    }
+  }
+};
+
+// src/resources/forms.ts
+var FormsResource = class {
+  http;
+  /**
+   * Create a new FormsResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all forms with optional pagination and filtering.
+   *
+   * @param params - Optional parameters for filtering and pagination
+   * @param params.limit - Maximum number of forms to return
+   * @param params.offset - Number of forms to skip for pagination
+   * @param params.project_id - Filter forms by project ID
+   * @param params.include_inactive - Include inactive forms in the results
+   * @returns Promise resolving to an array of forms
+   *
+   * @example
+   * ```typescript
+   * // Get all forms
+   * const forms = await client.forms.list();
+   *
+   * // Get forms with pagination
+   * const forms = await client.forms.list({ limit: 10, offset: 20 });
+   *
+   * // Get forms for a specific project
+   * const forms = await client.forms.list({ project_id: 'proj_123' });
+   *
+   * // Include inactive forms
+   * const forms = await client.forms.list({ include_inactive: true });
+   * ```
+   *
+   * @see Requirements 4.1
+   */
+  async list(params) {
+    return this.http.get("/forms", {
+      params
+    });
+  }
+  /**
+   * Create a new form.
+   *
+   * @param data - The form data to create
+   * @param data.name - Display name for the form (required)
+   * @param data.project_id - ID of the project to add the form to (optional)
+   * @returns Promise resolving to the created form
+   *
+   * @example
+   * ```typescript
+   * // Create a simple form
+   * const form = await client.forms.create({ name: 'Contact Form' });
+   *
+   * // Create a form in a project
+   * const form = await client.forms.create({
+   *   name: 'Feedback Form',
+   *   project_id: 'proj_123'
+   * });
+   * ```
+   *
+   * @see Requirements 4.2
+   */
+  async create(data) {
+    return this.http.post("/forms", data);
+  }
+  /**
+   * Get a single form by ID.
+   *
+   * @param id - The unique identifier of the form
+   * @returns Promise resolving to the form
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * const form = await client.forms.get('form_123');
+   * console.log(form.name, form.submission_count);
+   * ```
+   *
+   * @see Requirements 4.3
+   */
+  async get(id) {
+    return this.http.get(`/forms/${id}`);
+  }
+  /**
+   * Update a form's properties.
+   *
+   * @param id - The unique identifier of the form to update
+   * @param data - The properties to update
+   * @param data.name - New display name for the form
+   * @param data.project_id - ID of the project to move the form to (or null to remove from project)
+   * @param data.is_active - Whether the form should be active
+   * @returns Promise resolving to the updated form
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * // Update form name
+   * const form = await client.forms.update('form_123', { name: 'New Name' });
+   *
+   * // Deactivate a form
+   * const form = await client.forms.update('form_123', { is_active: false });
+   *
+   * // Move form to a different project
+   * const form = await client.forms.update('form_123', { project_id: 'proj_456' });
+   * ```
+   *
+   * @see Requirements 4.4
+   */
+  async update(id, data) {
+    return this.http.patch(`/forms/${id}`, data);
+  }
+  /**
+   * Delete a form by ID.
+   *
+   * @param id - The unique identifier of the form to delete
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * await client.forms.delete('form_123');
+   * ```
+   *
+   * @see Requirements 4.5
+   */
+  async delete(id) {
+    return this.http.delete(`/forms/${id}`);
+  }
+  /**
+   * Submit data to a form. This is a public endpoint that does not require authentication.
+   *
+   * @param slug - The URL-friendly slug of the form
+   * @param data - The form data to submit as key-value pairs
+   * @returns Promise resolving to the submission response
+   * @throws NotFoundError if the form does not exist
+   * @throws ValidationError if the form is inactive or data is invalid
+   *
+   * @example
+   * ```typescript
+   * // Submit to a contact form
+   * const result = await client.forms.submit('contact-form', {
+   *   name: 'John Doe',
+   *   email: 'john@example.com',
+   *   message: 'Hello!'
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Submission ID:', result.submission_id);
+   * }
+   * ```
+   *
+   * @see Requirements 4.6
+   */
+  async submit(slug, data) {
+    return this.http.postPublic(`/f/${slug}`, data);
+  }
+  /**
+   * Get the HTML template for a form.
+   *
+   * Returns the stored HTML from S3 or a default template if none exists.
+   *
+   * @param id - The unique identifier of the form
+   * @returns Promise resolving to the HTML content
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * const { html } = await client.forms.getHtml('form_123');
+   * console.log(html);
+   * ```
+   */
+  async getHtml(id) {
+    return this.http.get(`/forms/${id}/html`);
+  }
+  /**
+   * Save HTML template for a form to S3 storage.
+   *
+   * @param id - The unique identifier of the form
+   * @param html - The HTML content to save
+   * @returns Promise resolving to the save response with the S3 URL
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * const result = await client.forms.saveHtml('form_123', '<html>...</html>');
+   * if (result.success) {
+   *   console.log('Saved to:', result.html_url);
+   * }
+   * ```
+   */
+  async saveHtml(id, html) {
+    return this.http.put(`/forms/${id}/html`, { html });
+  }
+};
+
+// src/resources/submissions.ts
+var SubmissionsResource = class {
+  http;
+  /**
+   * Create a new SubmissionsResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List submissions for a form with optional filtering and pagination.
+   *
+   * @param formId - The unique identifier of the form
+   * @param params - Optional parameters for filtering and pagination
+   * @param params.limit - Maximum number of submissions to return
+   * @param params.offset - Number of submissions to skip for pagination
+   * @param params.since - Only return submissions created after this ISO 8601 timestamp
+   * @param params.order - Sort order for submissions ('asc' or 'desc')
+   * @param params.filter - Filter string for searching submissions
+   * @param params.is_spam - Filter by spam status
+   * @param params.is_read - Filter by read status
+   * @returns Promise resolving to an array of submissions
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * // Get all submissions for a form
+   * const submissions = await client.submissions.list('form_123');
+   *
+   * // Get submissions with pagination
+   * const submissions = await client.submissions.list('form_123', {
+   *   limit: 10,
+   *   offset: 20
+   * });
+   *
+   * // Get unread submissions
+   * const unread = await client.submissions.list('form_123', {
+   *   is_read: false
+   * });
+   *
+   * // Get non-spam submissions since a date
+   * const recent = await client.submissions.list('form_123', {
+   *   since: '2024-01-01T00:00:00Z',
+   *   is_spam: false,
+   *   order: 'desc'
+   * });
+   *
+   * // Search submissions
+   * const filtered = await client.submissions.list('form_123', {
+   *   filter: 'john@example.com'
+   * });
+   * ```
+   *
+   * @see Requirements 5.1
+   */
+  async list(formId, params) {
+    return this.http.get(`/forms/${formId}/submissions`, {
+      params
+    });
+  }
+  /**
+   * Get submission statistics for a form.
+   *
+   * @param formId - The unique identifier of the form
+   * @returns Promise resolving to submission statistics
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.submissions.getStats('form_123');
+   * console.log(`Total: ${stats.total}, Unread: ${stats.unread}, Spam: ${stats.spam}`);
+   * console.log(`Today: ${stats.today}, This week: ${stats.this_week}`);
+   * ```
+   *
+   * @see Requirements 5.2
+   */
+  async getStats(formId) {
+    return this.http.get(`/forms/${formId}/submissions/stats`);
+  }
+  /**
+   * Export all submissions for a form as JSON.
+   *
+   * @param formId - The unique identifier of the form
+   * @returns Promise resolving to an array of all submissions
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * // Export all submissions
+   * const allSubmissions = await client.submissions.export('form_123');
+   *
+   * // Process exported data
+   * for (const submission of allSubmissions) {
+   *   console.log(submission.data);
+   * }
+   * ```
+   *
+   * @see Requirements 5.3
+   */
+  async export(formId) {
+    return this.http.get(`/forms/${formId}/submissions/export`);
+  }
+  /**
+   * Perform a bulk update operation on multiple submissions.
+   *
+   * @param formId - The unique identifier of the form
+   * @param data - The bulk update request
+   * @param data.action - The action to perform ('markRead', 'markUnread', 'star', 'unstar', 'markSpam', 'notSpam')
+   * @param data.submission_ids - Array of submission IDs to update
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the form does not exist
+   * @throws ValidationError if the action is invalid or submission IDs are empty
+   *
+   * @example
+   * ```typescript
+   * // Mark submissions as read
+   * await client.submissions.bulkUpdate('form_123', {
+   *   action: 'markRead',
+   *   submission_ids: ['sub_1', 'sub_2', 'sub_3']
+   * });
+   *
+   * // Star submissions
+   * await client.submissions.bulkUpdate('form_123', {
+   *   action: 'star',
+   *   submission_ids: ['sub_1']
+   * });
+   *
+   * // Mark submissions as spam
+   * await client.submissions.bulkUpdate('form_123', {
+   *   action: 'markSpam',
+   *   submission_ids: ['sub_4', 'sub_5']
+   * });
+   *
+   * // Mark submissions as not spam
+   * await client.submissions.bulkUpdate('form_123', {
+   *   action: 'notSpam',
+   *   submission_ids: ['sub_6']
+   * });
+   * ```
+   *
+   * @see Requirements 5.4
+   */
+  async bulkUpdate(formId, data) {
+    return this.http.post(`/forms/${formId}/submissions/bulk`, data);
+  }
+  /**
+   * Delete multiple submissions from a form.
+   *
+   * @param formId - The unique identifier of the form
+   * @param submissionIds - Array of submission IDs to delete
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the form does not exist
+   * @throws ValidationError if submission IDs are empty
+   *
+   * @example
+   * ```typescript
+   * // Delete multiple submissions
+   * await client.submissions.bulkDelete('form_123', ['sub_1', 'sub_2', 'sub_3']);
+   * ```
+   *
+   * @see Requirements 5.5
+   */
+  async bulkDelete(formId, submissionIds) {
+    return this.http.delete(`/forms/${formId}/submissions/bulk`, {
+      params: {
+        ids: submissionIds.join(",")
+      }
+    });
+  }
+};
+
+// src/resources/rules.ts
+var RulesResource = class {
+  http;
+  /**
+   * Create a new RulesResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all rules for a form.
+   *
+   * @param formId - The unique identifier of the form
+   * @returns Promise resolving to an array of rules
+   * @throws NotFoundError if the form does not exist
+   *
+   * @example
+   * ```typescript
+   * // Get all rules for a form
+   * const rules = await client.rules.list('form_123');
+   *
+   * // Filter active rules
+   * const activeRules = rules.filter(rule => rule.is_active);
+   *
+   * // Check rule conditions
+   * for (const rule of rules) {
+   *   console.log(`Rule: ${rule.name}, Conditions: ${rule.conditions.length}`);
+   * }
+   * ```
+   *
+   * @see Requirements 6.1
+   */
+  async list(formId) {
+    return this.http.get(`/forms/${formId}/rules`);
+  }
+  /**
+   * Create a new rule for a form.
+   *
+   * @param formId - The unique identifier of the form
+   * @param data - The rule data to create
+   * @param data.name - Display name for the rule (required)
+   * @param data.conditions - Array of conditions that must be met (required)
+   * @param data.actions - Array of actions to take when conditions are met (required)
+   * @param data.is_active - Whether the rule should be active (defaults to true)
+   * @returns Promise resolving to the created rule
+   * @throws NotFoundError if the form does not exist
+   * @throws ValidationError if the rule data is invalid
+   *
+   * @example
+   * ```typescript
+   * // Create a simple email notification rule
+   * const rule = await client.rules.create('form_123', {
+   *   name: 'Notify on VIP submission',
+   *   conditions: [
+   *     { field: 'email', operator: 'ends_with', value: '@vip.com' }
+   *   ],
+   *   actions: [
+   *     { type: 'email', config: { to: 'sales@company.com', subject: 'VIP Lead!' } }
+   *   ]
+   * });
+   *
+   * // Create a webhook rule with multiple conditions
+   * const webhookRule = await client.rules.create('form_123', {
+   *   name: 'Send to CRM',
+   *   conditions: [
+   *     { field: 'type', operator: 'equals', value: 'enterprise' },
+   *     { field: 'budget', operator: 'contains', value: '10000' }
+   *   ],
+   *   actions: [
+   *     { type: 'webhook', config: { url: 'https://crm.example.com/leads' } }
+   *   ],
+   *   is_active: true
+   * });
+   *
+   * // Create an inactive rule (for testing)
+   * const testRule = await client.rules.create('form_123', {
+   *   name: 'Test Rule',
+   *   conditions: [{ field: 'test', operator: 'equals', value: 'true' }],
+   *   actions: [{ type: 'slack', config: { channel: '#test' } }],
+   *   is_active: false
+   * });
+   * ```
+   *
+   * @see Requirements 6.2
+   */
+  async create(formId, data) {
+    return this.http.post(`/forms/${formId}/rules`, data);
+  }
+  /**
+   * Update a rule's properties.
+   *
+   * @param formId - The unique identifier of the form
+   * @param ruleId - The unique identifier of the rule to update
+   * @param data - The properties to update
+   * @param data.name - New display name for the rule
+   * @param data.conditions - New conditions for the rule
+   * @param data.actions - New actions for the rule
+   * @param data.is_active - Whether the rule should be active
+   * @returns Promise resolving to the updated rule
+   * @throws NotFoundError if the form or rule does not exist
+   * @throws ValidationError if the update data is invalid
+   *
+   * @example
+   * ```typescript
+   * // Update rule name
+   * const rule = await client.rules.update('form_123', 'rule_456', {
+   *   name: 'Updated Rule Name'
+   * });
+   *
+   * // Deactivate a rule
+   * const rule = await client.rules.update('form_123', 'rule_456', {
+   *   is_active: false
+   * });
+   *
+   * // Update conditions
+   * const rule = await client.rules.update('form_123', 'rule_456', {
+   *   conditions: [
+   *     { field: 'email', operator: 'contains', value: '@newdomain.com' }
+   *   ]
+   * });
+   *
+   * // Update actions
+   * const rule = await client.rules.update('form_123', 'rule_456', {
+   *   actions: [
+   *     { type: 'discord', config: { webhook_url: 'https://discord.com/api/webhooks/...' } }
+   *   ]
+   * });
+   *
+   * // Update multiple properties at once
+   * const rule = await client.rules.update('form_123', 'rule_456', {
+   *   name: 'New Name',
+   *   is_active: true,
+   *   conditions: [{ field: 'status', operator: 'equals', value: 'urgent' }],
+   *   actions: [{ type: 'email', config: { to: 'urgent@company.com' } }]
+   * });
+   * ```
+   *
+   * @see Requirements 6.3
+   */
+  async update(formId, ruleId, data) {
+    return this.http.patch(`/forms/${formId}/rules/${ruleId}`, data);
+  }
+  /**
+   * Delete a rule by ID.
+   *
+   * @param formId - The unique identifier of the form
+   * @param ruleId - The unique identifier of the rule to delete
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the form or rule does not exist
+   *
+   * @example
+   * ```typescript
+   * // Delete a rule
+   * await client.rules.delete('form_123', 'rule_456');
+   *
+   * // Delete multiple rules
+   * const ruleIds = ['rule_1', 'rule_2', 'rule_3'];
+   * for (const ruleId of ruleIds) {
+   *   await client.rules.delete('form_123', ruleId);
+   * }
+   * ```
+   *
+   * @see Requirements 6.4
+   */
+  async delete(formId, ruleId) {
+    return this.http.delete(`/forms/${formId}/rules/${ruleId}`);
+  }
+};
+
+// src/resources/projects.ts
+var ProjectsResource = class {
+  http;
+  /**
+   * Create a new ProjectsResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all projects.
+   *
+   * @returns Promise resolving to an array of projects
+   *
+   * @example
+   * ```typescript
+   * const projects = await client.projects.list();
+   * console.log(`Found ${projects.length} projects`);
+   * ```
+   *
+   * @see Requirements 7.1
+   */
+  async list() {
+    const response = await this.http.get("/projects");
+    return response.projects;
+  }
+  /**
+   * Create a new project.
+   *
+   * @param data - The project data to create
+   * @param data.name - Display name for the project (required)
+   * @returns Promise resolving to the created project
+   *
+   * @example
+   * ```typescript
+   * const project = await client.projects.create({ name: 'Marketing Forms' });
+   * console.log('Created project:', project.id);
+   * ```
+   *
+   * @see Requirements 7.2
+   */
+  async create(data) {
+    return this.http.post("/projects", data);
+  }
+  /**
+   * Get a single project by ID.
+   *
+   * @param id - The unique identifier of the project
+   * @returns Promise resolving to the project
+   * @throws NotFoundError if the project does not exist
+   *
+   * @example
+   * ```typescript
+   * const project = await client.projects.get('proj_123');
+   * console.log(project.name, project.form_count);
+   * ```
+   *
+   * @see Requirements 7.3
+   */
+  async get(id) {
+    return this.http.get(`/projects/${id}`);
+  }
+  /**
+   * Update a project's properties.
+   *
+   * @param id - The unique identifier of the project to update
+   * @param data - The properties to update
+   * @param data.name - New display name for the project
+   * @returns Promise resolving to the updated project
+   * @throws NotFoundError if the project does not exist
+   *
+   * @example
+   * ```typescript
+   * const project = await client.projects.update('proj_123', { name: 'New Name' });
+   * console.log('Updated project:', project.name);
+   * ```
+   *
+   * @see Requirements 7.4
+   */
+  async update(id, data) {
+    return this.http.patch(`/projects/${id}`, data);
+  }
+  /**
+   * Delete a project by ID.
+   *
+   * @param id - The unique identifier of the project to delete
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the project does not exist
+   *
+   * @example
+   * ```typescript
+   * await client.projects.delete('proj_123');
+   * ```
+   *
+   * @see Requirements 7.5
+   */
+  async delete(id) {
+    return this.http.delete(`/projects/${id}`);
+  }
+};
+
+// src/resources/teams.ts
+var TeamsResource = class {
+  http;
+  /**
+   * Create a new TeamsResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all teams.
+   *
+   * @returns Promise resolving to an array of teams
+   *
+   * @example
+   * ```typescript
+   * const teams = await client.teams.list();
+   * console.log(`Found ${teams.length} teams`);
+   * ```
+   *
+   * @see Requirements 8.1
+   */
+  async list() {
+    return this.http.get("/teams");
+  }
+  /**
+   * Create a new team.
+   *
+   * @param data - The team data to create
+   * @param data.name - Display name for the team (required)
+   * @returns Promise resolving to the created team
+   *
+   * @example
+   * ```typescript
+   * const team = await client.teams.create({ name: 'Marketing Team' });
+   * console.log('Created team:', team.id);
+   * ```
+   *
+   * @see Requirements 8.2
+   */
+  async create(data) {
+    return this.http.post("/teams", data);
+  }
+  /**
+   * Get a single team by ID.
+   *
+   * @param id - The unique identifier of the team
+   * @returns Promise resolving to the team
+   * @throws NotFoundError if the team does not exist
+   *
+   * @example
+   * ```typescript
+   * const team = await client.teams.get('team_123');
+   * console.log(team.name, team.member_count);
+   * ```
+   *
+   * @see Requirements 8.3
+   */
+  async get(id) {
+    return this.http.get(`/teams/${id}`);
+  }
+  /**
+   * Update a team's properties.
+   *
+   * @param id - The unique identifier of the team to update
+   * @param data - The properties to update
+   * @param data.name - New display name for the team
+   * @returns Promise resolving to the updated team
+   * @throws NotFoundError if the team does not exist
+   *
+   * @example
+   * ```typescript
+   * const team = await client.teams.update('team_123', { name: 'New Name' });
+   * console.log('Updated team:', team.name);
+   * ```
+   *
+   * @see Requirements 8.4
+   */
+  async update(id, data) {
+    return this.http.patch(`/teams/${id}`, data);
+  }
+  /**
+   * Delete a team by ID.
+   *
+   * @param id - The unique identifier of the team to delete
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the team does not exist
+   *
+   * @example
+   * ```typescript
+   * await client.teams.delete('team_123');
+   * ```
+   *
+   * @see Requirements 8.5
+   */
+  async delete(id) {
+    return this.http.delete(`/teams/${id}`);
+  }
+  /**
+   * List all members of a team.
+   *
+   * @param teamId - The unique identifier of the team
+   * @returns Promise resolving to an array of team members
+   * @throws NotFoundError if the team does not exist
+   *
+   * @example
+   * ```typescript
+   * const members = await client.teams.listMembers('team_123');
+   * members.forEach(member => {
+   *   console.log(`${member.user.name} (${member.role})`);
+   * });
+   * ```
+   *
+   * @see Requirements 8.6
+   */
+  async listMembers(teamId) {
+    return this.http.get(`/teams/${teamId}/members`);
+  }
+  /**
+   * Add a user to a team.
+   *
+   * @param teamId - The unique identifier of the team
+   * @param data - The member data
+   * @param data.email - Email address of the user to add
+   * @param data.role - Role to assign ('admin' or 'member')
+   * @returns Promise resolving to the created team member
+   * @throws NotFoundError if the team does not exist
+   * @throws ValidationError if the user is already a member
+   *
+   * @example
+   * ```typescript
+   * const member = await client.teams.addMember('team_123', {
+   *   email: 'user@example.com',
+   *   role: 'member'
+   * });
+   * console.log('Added member:', member.user.name);
+   * ```
+   *
+   * @see Requirements 8.7
+   */
+  async addMember(teamId, data) {
+    return this.http.post(`/teams/${teamId}/members`, data);
+  }
+  /**
+   * Update a team member's role.
+   *
+   * @param teamId - The unique identifier of the team
+   * @param memberId - The unique identifier of the team member
+   * @param data - The properties to update
+   * @param data.role - New role for the member ('admin' or 'member')
+   * @returns Promise resolving to the updated team member
+   * @throws NotFoundError if the team or member does not exist
+   *
+   * @example
+   * ```typescript
+   * const member = await client.teams.updateMember('team_123', 'member_456', {
+   *   role: 'admin'
+   * });
+   * console.log('Updated role to:', member.role);
+   * ```
+   *
+   * @see Requirements 8.8
+   */
+  async updateMember(teamId, memberId, data) {
+    return this.http.patch(`/teams/${teamId}/members/${memberId}`, data);
+  }
+  /**
+   * Remove a member from a team.
+   *
+   * @param teamId - The unique identifier of the team
+   * @param memberId - The unique identifier of the team member to remove
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the team or member does not exist
+   *
+   * @example
+   * ```typescript
+   * await client.teams.removeMember('team_123', 'member_456');
+   * ```
+   *
+   * @see Requirements 8.9
+   */
+  async removeMember(teamId, memberId) {
+    return this.http.delete(`/teams/${teamId}/members/${memberId}`);
+  }
+  /**
+   * List all pending invitations for a team.
+   *
+   * @param teamId - The unique identifier of the team
+   * @returns Promise resolving to an array of pending invitations
+   * @throws NotFoundError if the team does not exist
+   *
+   * @example
+   * ```typescript
+   * const invitations = await client.teams.listInvitations('team_123');
+   * invitations.forEach(inv => {
+   *   console.log(`${inv.email} invited as ${inv.role}`);
+   * });
+   * ```
+   *
+   * @see Requirements 8.10
+   */
+  async listInvitations(teamId) {
+    return this.http.get(`/teams/${teamId}/invitations`);
+  }
+  /**
+   * Create a new invitation to join a team.
+   *
+   * @param teamId - The unique identifier of the team
+   * @param data - The invitation data
+   * @param data.email - Email address of the person to invite
+   * @param data.role - Role to assign upon acceptance ('admin' or 'member')
+   * @returns Promise resolving to the created invitation
+   * @throws NotFoundError if the team does not exist
+   * @throws ValidationError if an invitation already exists for this email
+   *
+   * @example
+   * ```typescript
+   * const invitation = await client.teams.invite('team_123', {
+   *   email: 'newuser@example.com',
+   *   role: 'member'
+   * });
+   * console.log('Invitation token:', invitation.token);
+   * ```
+   *
+   * @see Requirements 8.11
+   */
+  async invite(teamId, data) {
+    return this.http.post(`/teams/${teamId}/invitations`, data);
+  }
+  /**
+   * Cancel a pending invitation.
+   *
+   * @param teamId - The unique identifier of the team
+   * @param invitationId - The unique identifier of the invitation to cancel
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the team or invitation does not exist
+   *
+   * @example
+   * ```typescript
+   * await client.teams.cancelInvitation('team_123', 'inv_456');
+   * ```
+   *
+   * @see Requirements 8.12
+   */
+  async cancelInvitation(teamId, invitationId) {
+    return this.http.delete(`/teams/${teamId}/invitations/${invitationId}`);
+  }
+  /**
+   * Accept a team invitation using the invitation token.
+   *
+   * @param token - The unique invitation token
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the invitation does not exist or has expired
+   *
+   * @example
+   * ```typescript
+   * await client.teams.acceptInvitation('inv_token_abc123');
+   * ```
+   *
+   * @see Requirements 8.13
+   */
+  async acceptInvitation(token) {
+    return this.http.post(`/invitations/${token}/accept`);
+  }
+};
+
+// src/resources/user.ts
+var UserResource = class {
+  http;
+  /**
+   * Create a new UserResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get the current user profile.
+   *
+   * @returns Promise resolving to the current user
+   *
+   * @example
+   * ```typescript
+   * const user = await client.user.get();
+   * console.log(`Hello, ${user.name}!`);
+   * console.log(`2FA enabled: ${user.two_factor_enabled}`);
+   * ```
+   *
+   * @see Requirements 9.1
+   */
+  async get() {
+    return this.http.get("/user");
+  }
+  /**
+   * Update the current user's profile properties.
+   *
+   * @param data - The properties to update
+   * @param data.name - New display name for the user
+   * @param data.email - New email address for the user
+   * @returns Promise resolving to the updated user
+   *
+   * @example
+   * ```typescript
+   * const user = await client.user.update({ name: 'New Name' });
+   * console.log('Updated name:', user.name);
+   * ```
+   *
+   * @see Requirements 9.2
+   */
+  async update(data) {
+    return this.http.patch("/user", data);
+  }
+  /**
+   * Delete the current user's account.
+   *
+   * This action is irreversible and will delete all associated data.
+   *
+   * @returns Promise resolving to a success response
+   *
+   * @example
+   * ```typescript
+   * await client.user.delete();
+   * console.log('Account deleted');
+   * ```
+   *
+   * @see Requirements 9.3
+   */
+  async delete() {
+    return this.http.delete("/user");
+  }
+  /**
+   * Initiate two-factor authentication setup.
+   *
+   * Returns a secret and QR code for configuring an authenticator app.
+   *
+   * @returns Promise resolving to the 2FA setup response with secret and QR code
+   *
+   * @example
+   * ```typescript
+   * const setup = await client.user.setup2FA();
+   * console.log('Secret:', setup.secret);
+   * console.log('QR Code:', setup.qr_code);
+   * // Display QR code to user for scanning with authenticator app
+   * ```
+   *
+   * @see Requirements 9.4
+   */
+  async setup2FA() {
+    return this.http.post("/user/2fa/setup");
+  }
+  /**
+   * Enable two-factor authentication with a verification code.
+   *
+   * Call this after setup2FA to confirm the user has configured their
+   * authenticator app correctly.
+   *
+   * @param code - The 6-digit verification code from the authenticator app
+   * @returns Promise resolving to a success response
+   * @throws ValidationError if the code is invalid
+   *
+   * @example
+   * ```typescript
+   * await client.user.enable2FA('123456');
+   * console.log('2FA enabled successfully');
+   * ```
+   *
+   * @see Requirements 9.5
+   */
+  async enable2FA(code) {
+    return this.http.post("/user/2fa/enable", { code });
+  }
+  /**
+   * Disable two-factor authentication.
+   *
+   * Requires a valid verification code to confirm the user's identity.
+   *
+   * @param code - The 6-digit verification code from the authenticator app
+   * @returns Promise resolving to a success response
+   * @throws ValidationError if the code is invalid
+   *
+   * @example
+   * ```typescript
+   * await client.user.disable2FA('123456');
+   * console.log('2FA disabled');
+   * ```
+   *
+   * @see Requirements 9.6
+   */
+  async disable2FA(code) {
+    return this.http.post("/user/2fa/disable", { code });
+  }
+  /**
+   * Verify a two-factor authentication code.
+   *
+   * Use this to verify a 2FA code during login or sensitive operations.
+   *
+   * @param code - The 6-digit verification code from the authenticator app
+   * @returns Promise resolving to a success response
+   * @throws ValidationError if the code is invalid
+   *
+   * @example
+   * ```typescript
+   * await client.user.verify2FA('123456');
+   * console.log('2FA code verified');
+   * ```
+   *
+   * @see Requirements 9.7
+   */
+  async verify2FA(code) {
+    return this.http.post("/user/2fa/verify", { code });
+  }
+  /**
+   * List all API keys for the current user.
+   *
+   * Note: The `key` field will only contain the full key value when
+   * the key is first created. For existing keys, it may be masked.
+   *
+   * @returns Promise resolving to an array of API keys
+   *
+   * @example
+   * ```typescript
+   * const keys = await client.user.listApiKeys();
+   * keys.forEach(key => {
+   *   console.log(`${key.name}: last used ${key.last_used_at || 'never'}`);
+   * });
+   * ```
+   *
+   * @see Requirements 9.8
+   */
+  async listApiKeys() {
+    const response = await this.http.get("/user/api-keys");
+    return response.apiKeys;
+  }
+  /**
+   * Create a new API key.
+   *
+   * The returned API key will include the full key value in the `key` field.
+   * This is the only time the full key is available - store it securely.
+   *
+   * @param data - The API key data
+   * @param data.name - Display name for the API key (required)
+   * @returns Promise resolving to the created API key with full key value
+   *
+   * @example
+   * ```typescript
+   * const apiKey = await client.user.createApiKey({ name: 'My Application' });
+   * console.log('API Key created:', apiKey.key);
+   * // Store this key securely - it won't be shown again!
+   * ```
+   *
+   * @see Requirements 9.9
+   */
+  async createApiKey(data) {
+    const response = await this.http.post("/user/api-keys", data);
+    return response.apiKey;
+  }
+  /**
+   * Delete an API key by ID.
+   *
+   * @param id - The unique identifier of the API key to delete
+   * @returns Promise resolving to a success response
+   * @throws NotFoundError if the API key does not exist
+   *
+   * @example
+   * ```typescript
+   * await client.user.deleteApiKey('key_123');
+   * console.log('API key deleted');
+   * ```
+   *
+   * @see Requirements 9.10
+   */
+  async deleteApiKey(id) {
+    return this.http.delete(`/user/api-keys/${id}`);
+  }
+};
+
+// src/resources/billing.ts
+var BillingResource = class {
+  http;
+  /**
+   * Create a new BillingResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a Stripe checkout session for starting a new subscription.
+   *
+   * Returns a URL that the user should be redirected to in order to
+   * complete the checkout process on Stripe's hosted checkout page.
+   *
+   * @param data - The checkout session configuration
+   * @param data.price_id - The Stripe price ID for the subscription plan
+   * @param data.success_url - URL to redirect to after successful checkout
+   * @param data.cancel_url - URL to redirect to if checkout is cancelled
+   * @returns Promise resolving to the checkout response with redirect URL
+   *
+   * @example
+   * ```typescript
+   * const checkout = await client.billing.createCheckout({
+   *   price_id: 'price_1234567890',
+   *   success_url: 'https://myapp.com/checkout/success',
+   *   cancel_url: 'https://myapp.com/checkout/cancel'
+   * });
+   *
+   * // Redirect the user to complete checkout
+   * window.location.href = checkout.url;
+   * ```
+   *
+   * @see Requirements 10.1
+   */
+  async createCheckout(data) {
+    return this.http.post("/billing/checkout", data);
+  }
+  /**
+   * Create a Stripe billing portal session for managing an existing subscription.
+   *
+   * Returns a URL that the user should be redirected to in order to
+   * access the Stripe billing portal where they can:
+   * - View and update payment methods
+   * - View billing history and invoices
+   * - Upgrade, downgrade, or cancel their subscription
+   *
+   * @returns Promise resolving to the portal response with redirect URL
+   *
+   * @example
+   * ```typescript
+   * const portal = await client.billing.createPortal();
+   *
+   * // Redirect the user to the billing portal
+   * window.location.href = portal.url;
+   * ```
+   *
+   * @see Requirements 10.2
+   */
+  async createPortal() {
+    return this.http.post("/billing/portal");
+  }
+};
+
+// src/resources/files.ts
+var FilesResource = class {
+  http;
+  /**
+   * Create a new FilesResource instance
+   * @param http - The HTTP client to use for API requests
+   */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a signed download URL for a file.
+   *
+   * Returns a temporary signed URL that can be used to download the file.
+   * The URL will expire at the time indicated in the response.
+   *
+   * @param id - The unique identifier of the file
+   * @returns Promise resolving to the download response with signed URL and expiration
+   *
+   * @example
+   * ```typescript
+   * const download = await client.files.getDownloadUrl('file_abc123');
+   *
+   * // Use the signed URL to download the file
+   * const response = await fetch(download.url);
+   * const blob = await response.blob();
+   *
+   * // Check when the URL expires
+   * console.log(`URL expires at: ${download.expires_at}`);
+   * ```
+   *
+   * @see Requirements 11.1
+   */
+  async getDownloadUrl(id) {
+    return this.http.get(`/files/${id}/download`);
+  }
+  /**
+   * Delete a file by ID.
+   *
+   * Permanently removes the file from storage. This action cannot be undone.
+   *
+   * @param id - The unique identifier of the file to delete
+   * @returns Promise resolving to a success response
+   *
+   * @example
+   * ```typescript
+   * const result = await client.files.delete('file_abc123');
+   *
+   * if (result.success) {
+   *   console.log('File deleted successfully');
+   * }
+   * ```
+   *
+   * @see Requirements 11.2
+   */
+  async delete(id) {
+    return this.http.delete(`/files/${id}`);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.spike.ac";
+var DEFAULT_TIMEOUT = 3e4;
+var SpikeClient = class {
+  /**
+   * Resource for managing forms.
+   * @see FormsResource
+   */
+  forms;
+  /**
+   * Resource for managing form submissions.
+   * @see SubmissionsResource
+   */
+  submissions;
+  /**
+   * Resource for managing form rules.
+   * @see RulesResource
+   */
+  rules;
+  /**
+   * Resource for managing projects.
+   * @see ProjectsResource
+   */
+  projects;
+  /**
+   * Resource for managing teams.
+   * @see TeamsResource
+   */
+  teams;
+  /**
+   * Resource for managing user profile and settings.
+   * @see UserResource
+   */
+  user;
+  /**
+   * Resource for managing billing and subscriptions.
+   * @see BillingResource
+   */
+  billing;
+  /**
+   * Resource for managing uploaded files.
+   * @see FilesResource
+   */
+  files;
+  /**
+   * The HTTP client used for API requests.
+   * @internal
+   */
+  http;
+  /**
+   * Create a new Spike client instance.
+   *
+   * @param config - Configuration options for the client
+   * @throws ValidationError if the API key is missing or empty
+   *
+   * @example
+   * ```typescript
+   * // Basic usage with API key
+   * const client = new SpikeClient({ apiKey: 'sk_live_abc123' });
+   *
+   * // With all configuration options
+   * const client = new SpikeClient({
+   *   apiKey: 'sk_live_abc123',
+   *   baseUrl: 'https://spike.ac',
+   *   timeout: 30000
+   * });
+   * ```
+   *
+   * @see Requirements 1.1, 1.2, 1.3, 1.4, 1.5
+   */
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new ValidationError("API key is required. Please provide a valid API key.");
+    }
+    this.http = new HttpClient({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT
+    });
+    this.forms = new FormsResource(this.http);
+    this.submissions = new SubmissionsResource(this.http);
+    this.rules = new RulesResource(this.http);
+    this.projects = new ProjectsResource(this.http);
+    this.teams = new TeamsResource(this.http);
+    this.user = new UserResource(this.http);
+    this.billing = new BillingResource(this.http);
+    this.files = new FilesResource(this.http);
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+exports.AuthenticationError = AuthenticationError;
+exports.BillingResource = BillingResource;
+exports.FilesResource = FilesResource;
+exports.FormsResource = FormsResource;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.ProjectsResource = ProjectsResource;
+exports.RateLimitError = RateLimitError;
+exports.RulesResource = RulesResource;
+exports.SpikeClient = SpikeClient;
+exports.SpikeError = SpikeError;
+exports.SubmissionsResource = SubmissionsResource;
+exports.TeamsResource = TeamsResource;
+exports.UserResource = UserResource;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map