@yannelli/nextvisit-sdk 1.0.1

package/dist/index.js

@@ -0,0 +1,953 @@
+'use strict';
+
+// src/errors.ts
+var NextvisitError = class _NextvisitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NextvisitError";
+    Object.setPrototypeOf(this, _NextvisitError.prototype);
+  }
+};
+var NextvisitApiError = class _NextvisitApiError extends NextvisitError {
+  constructor(status, error) {
+    super(error.message);
+    this.name = "NextvisitApiError";
+    this.status = status;
+    this.errors = error.errors;
+    Object.setPrototypeOf(this, _NextvisitApiError.prototype);
+  }
+};
+var UnauthorizedError = class _UnauthorizedError extends NextvisitApiError {
+  constructor(error) {
+    super(401, error);
+    this.name = "UnauthorizedError";
+    Object.setPrototypeOf(this, _UnauthorizedError.prototype);
+  }
+};
+var ForbiddenError = class _ForbiddenError extends NextvisitApiError {
+  constructor(error) {
+    super(403, error);
+    this.name = "ForbiddenError";
+    Object.setPrototypeOf(this, _ForbiddenError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends NextvisitApiError {
+  constructor(error) {
+    super(404, error);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends NextvisitApiError {
+  constructor(error) {
+    super(422, error);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends NextvisitError {
+  constructor(message, cause) {
+    super(message);
+    this.name = "NetworkError";
+    this.cause = cause;
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.token = config.token;
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.timeout = config.timeout ?? 3e4;
+  }
+  /**
+   * Set the authentication token
+   */
+  setToken(token) {
+    this.token = token;
+  }
+  /**
+   * Get the current authentication token
+   */
+  getToken() {
+    return this.token;
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Build request headers
+   */
+  buildHeaders(options, contentType) {
+    const headers = {
+      Accept: "application/json",
+      ...options?.headers
+    };
+    if (contentType) {
+      headers["Content-Type"] = contentType;
+    }
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
+  /**
+   * Handle API error responses
+   */
+  async handleError(response) {
+    let error;
+    try {
+      error = await response.json();
+    } catch {
+      error = { message: response.statusText || "Unknown error" };
+    }
+    switch (response.status) {
+      case 401:
+        throw new UnauthorizedError(error);
+      case 403:
+        throw new ForbiddenError(error);
+      case 404:
+        throw new NotFoundError(error);
+      case 422:
+        throw new ValidationError(error);
+      default:
+        throw new NextvisitApiError(response.status, error);
+    }
+  }
+  /**
+   * Execute a fetch request with timeout
+   */
+  async executeFetch(url, init, signal) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const combinedSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+    try {
+      const response = await this.fetchFn(url, {
+        ...init,
+        signal: combinedSignal
+      });
+      clearTimeout(timeoutId);
+      return response;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error) {
+        if (err.name === "AbortError") {
+          throw new NetworkError("Request was aborted or timed out", err);
+        }
+        throw new NetworkError(`Network request failed: ${err.message}`, err);
+      }
+      throw new NetworkError("Network request failed");
+    }
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = this.buildHeaders(options);
+    const response = await this.executeFetch(
+      url,
+      { method: "GET", headers },
+      options?.signal
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    return await response.json();
+  }
+  /**
+   * Make a POST request with JSON body
+   */
+  async post(path, body, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = this.buildHeaders(options, "application/json");
+    const response = await this.executeFetch(
+      url,
+      {
+        method: "POST",
+        headers,
+        body: body ? JSON.stringify(body) : void 0
+      },
+      options?.signal
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    return await response.json();
+  }
+  /**
+   * Make a POST request with FormData body (for file uploads)
+   */
+  async postForm(path, formData, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = this.buildHeaders(options);
+    const response = await this.executeFetch(
+      url,
+      {
+        method: "POST",
+        headers,
+        body: formData
+      },
+      options?.signal
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    return await response.json();
+  }
+  /**
+   * Make a PUT request with JSON body
+   */
+  async put(path, body, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = this.buildHeaders(options, "application/json");
+    const response = await this.executeFetch(
+      url,
+      {
+        method: "PUT",
+        headers,
+        body: body ? JSON.stringify(body) : void 0
+      },
+      options?.signal
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    return await response.json();
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = this.buildHeaders(options);
+    const response = await this.executeFetch(
+      url,
+      { method: "DELETE", headers },
+      options?.signal
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    return await response.json();
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class extends BaseResource {
+  /**
+   * Create a new access token (login)
+   *
+   * Authenticates a user with email and password, returning an access token
+   * that can be used for subsequent API requests.
+   *
+   * @param credentials - Login credentials
+   * @returns Token response with access token and user info
+   *
+   * @example
+   * ```typescript
+   * const response = await client.auth.createToken({
+   *   email: "user@example.com",
+   *   password: "password123",
+   *   device_name: "My App"
+   * });
+   *
+   * console.log(response.token); // Use this token for authentication
+   * ```
+   */
+  async createToken(credentials) {
+    return this.http.post("/v1/auth/tokens", credentials);
+  }
+  /**
+   * Authenticate with Google Sign-In
+   *
+   * Authenticates a user using a Google ID token obtained from Google Sign-In SDK.
+   * Supports tokens from web applications, Chrome extensions, iOS apps, and Android apps.
+   * If the user doesn't exist, a new account is automatically created.
+   *
+   * @param params - Google authentication parameters
+   * @returns Authentication response with access token and user info
+   *
+   * @example
+   * ```typescript
+   * // Web application
+   * const response = await client.auth.googleAuth({
+   *   id_token: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
+   *   device_name: "Web Browser"
+   * });
+   *
+   * if (response.is_new_user) {
+   *   console.log("Welcome! Your account has been created.");
+   * }
+   *
+   * // Use response.token for subsequent requests
+   * client.setToken(response.token);
+   * ```
+   */
+  async googleAuth(params) {
+    return this.http.post("/v1/auth/google", params);
+  }
+  /**
+   * Revoke the current access token (logout)
+   *
+   * Invalidates the current authentication token. After calling this method,
+   * the token can no longer be used for API requests.
+   *
+   * @returns Confirmation message
+   *
+   * @example
+   * ```typescript
+   * await client.auth.revokeCurrentToken();
+   * // Token is now invalid
+   * ```
+   */
+  async revokeCurrentToken() {
+    return this.http.delete("/v1/auth/tokens/current");
+  }
+  /**
+   * List all tokens for the authenticated user
+   *
+   * Returns a list of all active tokens associated with the current user,
+   * including information about when each token was created and last used.
+   *
+   * @returns List of tokens
+   *
+   * @example
+   * ```typescript
+   * const response = await client.auth.listTokens();
+   *
+   * for (const token of response.tokens) {
+   *   console.log(`${token.name} - Created: ${token.created_at}`);
+   * }
+   * ```
+   */
+  async listTokens() {
+    return this.http.get("/v1/auth/tokens");
+  }
+  /**
+   * Revoke a specific token by ID
+   *
+   * Invalidates a specific token by its ID. This can be used to revoke
+   * tokens on other devices or applications.
+   *
+   * @param id - The unique identifier of the token to revoke
+   * @returns Confirmation message
+   *
+   * @example
+   * ```typescript
+   * // List tokens and revoke a specific one
+   * const { tokens } = await client.auth.listTokens();
+   * const oldToken = tokens.find(t => t.name === "Old Device");
+   *
+   * if (oldToken) {
+   *   await client.auth.revokeToken(oldToken.id);
+   *   console.log("Token revoked");
+   * }
+   * ```
+   */
+  async revokeToken(id) {
+    return this.http.delete(`/v1/auth/tokens/${id}`);
+  }
+};
+
+// src/resources/users.ts
+var UsersResource = class extends BaseResource {
+  /**
+   * Get the currently authenticated user
+   *
+   * Retrieves the full profile of the user associated with the current
+   * authentication token.
+   *
+   * @returns The authenticated user's details
+   *
+   * @example
+   * ```typescript
+   * const user = await client.users.getCurrentUser();
+   * console.log(`Logged in as ${user.name} (${user.email})`);
+   * ```
+   */
+  async getCurrentUser() {
+    return this.http.get("/user");
+  }
+};
+
+// src/resources/patients.ts
+var PatientsResource = class extends BaseResource {
+  /**
+   * List patients
+   *
+   * Returns a paginated list of patients with optional filtering
+   * and customizable pagination/sorting.
+   *
+   * @param params - Optional filtering and pagination parameters
+   * @returns Paginated list of patients
+   *
+   * @example
+   * ```typescript
+   * // Get all patients
+   * const patients = await client.patients.list();
+   *
+   * // Filter and sort patients
+   * const filtered = await client.patients.list({
+   *   "filter[last_name]": "Smith",
+   *   sort: "-created_at",
+   *   per_page: 25
+   * });
+   *
+   * // Include soft-deleted patients
+   * const withTrashed = await client.patients.list({
+   *   "filter[trashed]": "with"
+   * });
+   * ```
+   */
+  async list(params) {
+    return this.http.get("/v1/patients", {
+      params
+    });
+  }
+  /**
+   * Get a specific patient
+   *
+   * Retrieves detailed information about a single patient by their ID.
+   *
+   * @param id - The patient ID
+   * @returns The patient details wrapped in a response object
+   *
+   * @example
+   * ```typescript
+   * const response = await client.patients.get(123);
+   * console.log(response.data.first_name);
+   * console.log(response.data.date_of_birth);
+   * ```
+   */
+  async get(id) {
+    return this.http.get(`/v1/patients/${id}`);
+  }
+  /**
+   * Create a new patient
+   *
+   * Creates a new patient record with the provided information.
+   *
+   * @param params - The patient data
+   * @returns The created patient wrapped in a response object
+   *
+   * @example
+   * ```typescript
+   * const response = await client.patients.create({
+   *   first_name: "John",
+   *   last_name: "Doe",
+   *   date_of_birth: "1990-05-15",
+   *   notes: "New patient referral",
+   *   allergies: "Penicillin"
+   * });
+   *
+   * console.log(response.data.id);
+   * ```
+   */
+  async create(params) {
+    return this.http.post("/v1/patients", params);
+  }
+  /**
+   * Update a patient
+   *
+   * Updates an existing patient's information.
+   *
+   * @param id - The patient ID
+   * @param params - The fields to update
+   * @returns The updated patient wrapped in a response object
+   *
+   * @example
+   * ```typescript
+   * const response = await client.patients.update(123, {
+   *   first_name: "Jonathan",
+   *   notes: "Updated contact information"
+   * });
+   *
+   * console.log(response.data.first_name); // "Jonathan"
+   * ```
+   */
+  async update(id, params) {
+    return this.http.put(`/v1/patients/${id}`, params);
+  }
+  /**
+   * Delete a patient (soft delete)
+   *
+   * Soft deletes a patient record. The patient can be restored or
+   * permanently deleted later. Use the trashed filter to view deleted patients.
+   *
+   * @param id - The patient ID
+   * @returns Confirmation message
+   *
+   * @example
+   * ```typescript
+   * await client.patients.delete(123);
+   * console.log("Patient soft deleted successfully");
+   *
+   * // View deleted patients
+   * const deleted = await client.patients.list({
+   *   "filter[trashed]": "only"
+   * });
+   * ```
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/patients/${id}`);
+  }
+  /**
+   * Search patients
+   *
+   * Searches for patients matching the query string within the authenticated
+   * user's current team.
+   *
+   * @param params - Search parameters including query string
+   * @returns Paginated list of matching patients
+   *
+   * @example
+   * ```typescript
+   * // Search for patients by name
+   * const results = await client.patients.search({
+   *   query: "John",
+   *   per_page: 10,
+   *   sort_by: "desc"
+   * });
+   *
+   * console.log(`Found ${results.meta.total} patients`);
+   * results.data.forEach(patient => {
+   *   console.log(`${patient.first_name} ${patient.last_name}`);
+   * });
+   * ```
+   */
+  async search(params) {
+    return this.http.get(
+      `/v1/patients/search`,
+      {
+        params
+      }
+    );
+  }
+};
+
+// src/resources/progress-notes.ts
+var ProgressNotesResource = class extends BaseResource {
+  /**
+   * List progress notes
+   *
+   * Returns a paginated list of progress notes with optional filtering
+   * by patient and customizable pagination/sorting.
+   *
+   * @param params - Optional filtering and pagination parameters
+   * @returns Paginated list of progress notes
+   *
+   * @example
+   * ```typescript
+   * // Get latest notes
+   * const notes = await client.progressNotes.list();
+   *
+   * // Filter by patient
+   * const patientNotes = await client.progressNotes.list({
+   *   patient_id: 123,
+   *   per_page: 25,
+   *   sort_by: "oldest"
+   * });
+   * ```
+   */
+  async list(params) {
+    return this.http.get("/v1/progress-notes", {
+      params
+    });
+  }
+  /**
+   * Get a specific progress note
+   *
+   * Retrieves detailed information about a single progress note by its ID.
+   *
+   * @param id - The progress note ID
+   * @returns The progress note details
+   *
+   * @example
+   * ```typescript
+   * const note = await client.progressNotes.get(123);
+   * console.log(note.name);
+   * console.log(note.transcription);
+   * ```
+   */
+  async get(id) {
+    return this.http.get(`/v1/progress-notes/${id}`);
+  }
+  /**
+   * Get audio URL for a progress note
+   *
+   * Retrieves a temporary URL to access the audio file associated with
+   * a progress note. The URL is time-limited and will expire.
+   *
+   * @param id - The progress note ID
+   * @returns Object containing the temporary audio URL
+   *
+   * @example
+   * ```typescript
+   * const response = await client.progressNotes.getAudioUrl(123);
+   * console.log(response.url); // Temporary URL to audio file
+   * ```
+   */
+  async getAudioUrl(id) {
+    return this.http.get(`/v1/progress-notes/${id}/audio-url`);
+  }
+  /**
+   * Create a new progress note
+   *
+   * Creates a new progress note with either an audio file or text content.
+   * For audio files, the audio will be transcribed and analyzed asynchronously.
+   * For text-only notes, provide the note content directly.
+   *
+   * @param params - The progress note data (audio file or text-only)
+   * @returns The created progress note
+   *
+   * @example
+   * ```typescript
+   * // With audio file
+   * const audioFile = new File([audioBlob], "recording.mp3", {
+   *   type: "audio/mpeg"
+   * });
+   *
+   * const note = await client.progressNotes.create({
+   *   name: "Follow-up Visit - John Doe",
+   *   patient_id: 456,
+   *   file: audioFile,
+   *   model_id: 1 // Optional template
+   * });
+   *
+   * // Text-only note
+   * const textNote = await client.progressNotes.create({
+   *   name: "Patient Consultation",
+   *   note: "Patient presented with symptoms of...",
+   *   model_id: 1,
+   *   patient_id: 456
+   * });
+   * ```
+   */
+  async create(params) {
+    const formData = new FormData();
+    formData.append("name", params.name);
+    if (params.patient_id !== void 0) {
+      formData.append("patient_id", String(params.patient_id));
+    }
+    if (params.context !== void 0) {
+      formData.append("context", params.context);
+    }
+    if ("file" in params) {
+      const fileParams = params;
+      formData.append("file", fileParams.file);
+      if (fileParams.model_id !== void 0) {
+        formData.append("model_id", String(fileParams.model_id));
+      }
+    } else {
+      const textParams = params;
+      formData.append("note", textParams.note);
+      formData.append("model_id", String(textParams.model_id));
+      if (textParams.documents !== void 0 && textParams.documents.length > 0) {
+        for (const docId of textParams.documents) {
+          formData.append("documents[]", String(docId));
+        }
+      }
+    }
+    return this.http.postForm("/v1/progress-notes", formData);
+  }
+  /**
+   * Update a progress note
+   *
+   * Updates an existing progress note's metadata, transcription, or analysis.
+   *
+   * @param id - The progress note ID
+   * @param params - The fields to update
+   * @returns The updated progress note
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.progressNotes.update(123, {
+   *   name: "Updated Visit Name",
+   *   transcription: "Corrected transcription text..."
+   * });
+   * ```
+   */
+  async update(id, params) {
+    return this.http.put(`/v1/progress-notes/${id}`, params);
+  }
+  /**
+   * Delete a progress note
+   *
+   * Permanently deletes a progress note and its associated audio files.
+   * This action cannot be undone.
+   *
+   * @param id - The progress note ID
+   * @returns Confirmation message
+   *
+   * @example
+   * ```typescript
+   * await client.progressNotes.delete(123);
+   * console.log("Note deleted successfully");
+   * ```
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/progress-notes/${id}`);
+  }
+  /**
+   * Sign a progress note
+   *
+   * Marks a progress note as reviewed and signed. A note can only be signed
+   * after transcription and analysis have been completed.
+   *
+   * @param id - The progress note ID
+   * @returns The signed progress note
+   *
+   * @example
+   * ```typescript
+   * const signedNote = await client.progressNotes.sign(123);
+   * console.log(signedNote.has?.signed); // true
+   * ```
+   */
+  async sign(id) {
+    return this.http.put(`/v1/progress-notes/${id}/sign`);
+  }
+};
+
+// src/resources/billing.ts
+var BillingResource = class extends BaseResource {
+  /**
+   * List available billing plans
+   *
+   * Retrieves all available billing plans that can be subscribed to,
+   * including pricing information and features.
+   *
+   * @returns List of available billing plans
+   *
+   * @example
+   * ```typescript
+   * const response = await client.billing.listPlans();
+   *
+   * for (const plan of response.plans) {
+   *   console.log(`${plan.name}: ${plan.price_prefix}${plan.price}${plan.price_suffix}`);
+   *   if (plan.features) {
+   *     plan.features.forEach(feature => console.log(`  - ${feature}`));
+   *   }
+   * }
+   * ```
+   */
+  async listPlans() {
+    return this.http.get("/v1/billing/plans");
+  }
+  /**
+   * Get billing cost estimate
+   *
+   * Calculates the estimated billing cost based on the current number
+   * of users in the team and any child teams.
+   *
+   * @returns Billing cost estimate with user count and formatted total
+   *
+   * @example
+   * ```typescript
+   * const estimate = await client.billing.getEstimate();
+   *
+   * console.log(`Users: ${estimate.users}`);
+   * console.log(`Estimated cost: ${estimate.total_formatted}`);
+   * console.log(`Next renewal: ${estimate.renewal_date}`);
+   * ```
+   */
+  async getEstimate() {
+    return this.http.get("/v1/billing/estimate");
+  }
+  /**
+   * Get billing usage statistics
+   *
+   * Retrieves usage statistics for a specific billing module, including
+   * the current subscription plan status and detailed usage metrics.
+   *
+   * @param module - The billing module to get usage for (e.g., 'notes')
+   * @returns Billing usage with plan status and usage statistics
+   *
+   * @example
+   * ```typescript
+   * const usage = await client.billing.getUsage("notes");
+   *
+   * console.log(`Plan: ${usage.plan.name} (${usage.plan.status})`);
+   * console.log(`Usage: ${usage.usage.used} / ${usage.usage.limit}`);
+   * console.log(`Period: ${usage.usage.period_start} to ${usage.usage.period_end}`);
+   *
+   * if (usage.plan.trial.on_trial) {
+   *   console.log(`Trial ends: ${usage.plan.trial.trial_ends_at}`);
+   * }
+   * ```
+   */
+  async getUsage(module) {
+    return this.http.get(`/v1/billing/usage/${module}`);
+  }
+};
+
+// src/resources/transcription.ts
+var TranscriptionResource = class extends BaseResource {
+  /**
+   * Transcribe an audio file
+   *
+   * Uploads an audio file and returns the transcribed text using AI-powered speech recognition.
+   * Supported formats: mp3, mp4, m4a, wav, ogg, webm, flac, aac, pcm, opus
+   * Maximum file size: 200MB
+   *
+   * @param params - The transcription parameters including the audio file
+   * @returns Transcription response with the transcribed text
+   *
+   * @example
+   * ```typescript
+   * // Transcribe an audio file from a file input
+   * const fileInput = document.querySelector('input[type="file"]');
+   * const file = fileInput.files[0];
+   *
+   * const response = await client.transcription.transcribeFile({ file });
+   *
+   * if (response.success) {
+   *   console.log(response.text); // The transcribed text
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Transcribe a Blob from recorded audio
+   * const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
+   *
+   * const response = await client.transcription.transcribeFile({
+   *   file: audioBlob
+   * });
+   *
+   * console.log(response.message); // Status message
+   * ```
+   */
+  async transcribeFile(params) {
+    const formData = new FormData();
+    formData.append("file", params.file);
+    return this.http.postForm(
+      "/v1/transcribe/file",
+      formData
+    );
+  }
+  /**
+   * Get a temporary transcription token
+   *
+   * Returns a temporary Deepgram API token for client-side audio transcription.
+   * The token is short-lived and should be used immediately.
+   *
+   * @returns Token response with the temporary API token
+   *
+   * @example
+   * ```typescript
+   * const response = await client.transcription.getToken();
+   *
+   * if (response.success && response.token) {
+   *   // Use the token for client-side Deepgram SDK
+   *   const deepgram = createClient(response.token);
+   * }
+   * ```
+   */
+  async getToken() {
+    return this.http.get("/v1/transcribe/token");
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://nextvisit.app/api";
+var NextvisitClient = class {
+  /**
+   * Create a new Nextvisit API client
+   *
+   * @param config - Client configuration options
+   */
+  constructor(config = {}) {
+    const httpConfig = {
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      token: config.token,
+      fetch: config.fetch,
+      timeout: config.timeout
+    };
+    this.http = new HttpClient(httpConfig);
+    this.auth = new AuthResource(this.http);
+    this.users = new UsersResource(this.http);
+    this.progressNotes = new ProgressNotesResource(this.http);
+    this.billing = new BillingResource(this.http);
+    this.transcription = new TranscriptionResource(this.http);
+    this.patients = new PatientsResource(this.http);
+  }
+  /**
+   * Set the authentication token
+   *
+   * Updates the token used for API requests. Call this after
+   * authenticating with `auth.createToken()`.
+   *
+   * @param token - The authentication token
+   *
+   * @example
+   * ```typescript
+   * const { token } = await client.auth.createToken(credentials);
+   * client.setToken(token);
+   * ```
+   */
+  setToken(token) {
+    this.http.setToken(token);
+  }
+  /**
+   * Clear the authentication token
+   *
+   * Removes the current token. Subsequent requests will be
+   * unauthenticated.
+   *
+   * @example
+   * ```typescript
+   * await client.auth.revokeCurrentToken();
+   * client.clearToken();
+   * ```
+   */
+  clearToken() {
+    this.http.setToken(void 0);
+  }
+  /**
+   * Check if the client has an authentication token set
+   *
+   * @returns `true` if a token is set, `false` otherwise
+   */
+  hasToken() {
+    return this.http.getToken() !== void 0;
+  }
+};
+
+exports.AuthResource = AuthResource;
+exports.BillingResource = BillingResource;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.ForbiddenError = ForbiddenError;
+exports.NetworkError = NetworkError;
+exports.NextvisitApiError = NextvisitApiError;
+exports.NextvisitClient = NextvisitClient;
+exports.NextvisitError = NextvisitError;
+exports.NotFoundError = NotFoundError;
+exports.PatientsResource = PatientsResource;
+exports.ProgressNotesResource = ProgressNotesResource;
+exports.TranscriptionResource = TranscriptionResource;
+exports.UnauthorizedError = UnauthorizedError;
+exports.UsersResource = UsersResource;
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map