@yannelli/nextvisit-sdk 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,1416 @@
+/**
+ * HTTP client configuration options
+ */
+interface HttpClientConfig {
+    /** Base URL for API requests */
+    baseUrl: string;
+    /** Authentication token */
+    token?: string;
+    /** Custom fetch implementation (for testing or custom environments) */
+    fetch?: typeof fetch;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Request options for HTTP methods
+ */
+interface RequestOptions {
+    /** Query parameters */
+    params?: Record<string, string | number | boolean | undefined>;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Abort signal for request cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Internal HTTP client for making API requests
+ */
+declare class HttpClient {
+    private readonly baseUrl;
+    private token?;
+    private readonly fetchFn;
+    private readonly timeout;
+    constructor(config: HttpClientConfig);
+    /**
+     * Set the authentication token
+     */
+    setToken(token: string | undefined): void;
+    /**
+     * Get the current authentication token
+     */
+    getToken(): string | undefined;
+    /**
+     * Build URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Build request headers
+     */
+    private buildHeaders;
+    /**
+     * Handle API error responses
+     */
+    private handleError;
+    /**
+     * Execute a fetch request with timeout
+     */
+    private executeFetch;
+    /**
+     * Make a GET request
+     */
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Make a POST request with JSON body
+     */
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * Make a POST request with FormData body (for file uploads)
+     */
+    postForm<T>(path: string, formData: FormData, options?: RequestOptions): Promise<T>;
+    /**
+     * Make a PUT request with JSON body
+     */
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * Make a DELETE request
+     */
+    delete<T>(path: string, options?: RequestOptions): Promise<T>;
+}
+
+/**
+ * Base class for API resources
+ */
+declare abstract class BaseResource {
+    protected readonly http: HttpClient;
+    constructor(http: HttpClient);
+}
+
+/**
+ * API error response structure
+ */
+interface ApiError {
+    /** Error message */
+    message: string;
+    /** Detailed validation errors by field */
+    errors?: Record<string, string[]>;
+}
+/**
+ * Pagination links for list responses
+ */
+interface PaginationLinks {
+    first?: string;
+    last?: string;
+    prev?: string | null;
+    next?: string | null;
+}
+/**
+ * Pagination metadata for list responses
+ */
+interface PaginationMeta {
+    current_page: number;
+    from: number | null;
+    last_page: number;
+    path: string;
+    per_page: number;
+    to: number | null;
+    total: number;
+}
+/**
+ * Paginated response wrapper
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    links: PaginationLinks;
+    meta: PaginationMeta;
+}
+/**
+ * Simple message response
+ */
+interface MessageResponse {
+    message: string;
+}
+
+/**
+ * Login request payload
+ */
+interface LoginRequest {
+    /** User's email address */
+    email: string;
+    /** User's password */
+    password: string;
+    /** Name of the device requesting the token */
+    device_name: string;
+    /** Two-factor authentication code (if 2FA is enabled) */
+    two_factor_code?: string;
+    /** Email OTP verification code (for users with linked social providers) */
+    otp_code?: string;
+}
+/**
+ * Google Sign-In authentication request
+ */
+interface GoogleAuthRequest {
+    /** Google ID token obtained from Google Sign-In SDK */
+    id_token: string;
+    /** Name of the device or application (max 255 chars) */
+    device_name: string;
+}
+/**
+ * Basic user info returned with token
+ */
+interface TokenUser {
+    /** User's unique identifier */
+    id: number;
+    /** User's full name */
+    name: string;
+    /** ID of the user's current team */
+    current_team_id: number;
+    /** User's email address */
+    email: string;
+}
+/**
+ * Basic team info returned with token
+ */
+interface TokenTeam {
+    /** Team's unique identifier */
+    id: number;
+    /** Name of the team */
+    name: string;
+}
+/**
+ * Verification type for enhanced security authentication
+ */
+type VerificationType = "two_factor" | "email_otp";
+/**
+ * Response when verification is required (2FA or email OTP)
+ */
+interface VerificationRequiredResponse {
+    /** Status indicating verification is required */
+    status: "verification_required";
+    /** Type of verification required */
+    verification_type: VerificationType;
+    /** Human-readable message for the user */
+    message: string;
+}
+/**
+ * Successful token creation response
+ */
+interface TokenSuccessResponse {
+    /** Status of the token request */
+    status: "success";
+    /** Authentication token value */
+    token: string;
+    /** Unique identifier for the token */
+    token_id: number;
+    /** Basic information about the authenticated user */
+    user: TokenUser;
+    /** Basic information about the user's current team */
+    team: TokenTeam;
+}
+/**
+ * Token creation response (can be success or require verification)
+ */
+type TokenResponse = TokenSuccessResponse | VerificationRequiredResponse;
+/**
+ * Google Sign-In authentication response
+ */
+interface GoogleAuthResponse {
+    /** Status of the authentication request */
+    status: "success";
+    /** Authentication token value */
+    token: string;
+    /** Unique identifier for the token */
+    token_id: number;
+    /** Basic information about the authenticated user */
+    user: TokenUser;
+    /** Basic information about the user's current team */
+    team: TokenTeam;
+    /** Whether this is a newly created user account */
+    is_new_user: boolean;
+}
+/**
+ * Token revocation response
+ */
+interface RevokeTokenResponse {
+    /** Status message */
+    message: string;
+}
+/**
+ * Token information for listing tokens
+ */
+interface TokenInfo {
+    /** Unique identifier for the token */
+    id: number;
+    /** Name of the device or application the token was created for */
+    name: string;
+    /** When the token was created */
+    created_at: string;
+    /** When the token was last used */
+    last_used_at?: string | null;
+}
+/**
+ * Response for listing tokens
+ */
+interface TokensListResponse {
+    /** List of tokens */
+    tokens: TokenInfo[];
+}
+
+/**
+ * Full user object
+ */
+interface User {
+    /** Unique identifier for the user */
+    id: number;
+    /** Full name of the user */
+    name: string;
+    /** Email address of the user */
+    email: string;
+    /** Timestamp when the user was created */
+    created_at: string;
+    /** Timestamp when the user was last updated */
+    updated_at: string;
+}
+
+/**
+ * Template associated with a progress note
+ */
+interface ProgressNoteTemplate {
+    /** Template ID used for this note */
+    id: number;
+    /** Name of the template */
+    name: string;
+    /** Description of the template */
+    description?: string;
+}
+/**
+ * Patient associated with a progress note
+ */
+interface Patient {
+    /** Patient's unique identifier */
+    id: number;
+    /** Patient's name */
+    name?: string;
+}
+/**
+ * Audio metadata for a progress note
+ */
+interface ProgressNoteAudio {
+    /** Duration of the audio in seconds */
+    duration?: number;
+    /** Bitrate of the audio file */
+    bitrate?: number;
+    /** Size of the audio file in bytes */
+    size?: number;
+    /** When the audio was uploaded */
+    uploaded_at?: string;
+    /** When the audio file will expire */
+    expires_at?: string;
+    /** Temporary URL to access the audio file */
+    file_url?: string;
+}
+/**
+ * Status flags for a progress note
+ */
+interface ProgressNoteHas {
+    /** Whether analysis has been completed */
+    content: boolean;
+    /** Whether transcription has been completed */
+    transcription: boolean;
+    /** Whether the note has been reviewed and signed */
+    signed: boolean;
+}
+/**
+ * Full progress note object
+ */
+interface ProgressNote {
+    /** Unique identifier for the progress note */
+    id: number;
+    /** Name or title of the progress note */
+    name: string;
+    /** Transcribed content of the audio recording */
+    transcription?: string;
+    /** AI-generated analysis of the transcription */
+    analysis?: string;
+    /** Template used for this note */
+    template?: ProgressNoteTemplate;
+    /** Associated patient information */
+    patient?: Patient;
+    /** Audio file metadata */
+    audio?: ProgressNoteAudio;
+    /** Status flags */
+    has?: ProgressNoteHas;
+    /** ID of the team this note belongs to */
+    team_id: number;
+    /** ID of the user who created this note */
+    user_id: number;
+    /** Information about the user who created the note */
+    user?: User;
+    /** When transcription process started */
+    transcription_started_at?: string;
+    /** When transcription was completed */
+    transcription_completed_at?: string;
+    /** When analysis process started */
+    analysis_started_at?: string;
+    /** When analysis was completed */
+    analysis_completed_at?: string;
+    /** Any error state during processing */
+    error_state?: string | null;
+    /** When the progress note was created */
+    created_at: string;
+    /** When the progress note was last updated */
+    updated_at: string;
+}
+/**
+ * Sort options for listing progress notes
+ */
+type ProgressNoteSortBy = "latest" | "oldest";
+/**
+ * Query parameters for listing progress notes
+ */
+interface ListProgressNotesParams {
+    /** Filter notes by patient ID */
+    patient_id?: number;
+    /** Number of items per page (1-100) */
+    per_page?: number;
+    /** Sort order for results */
+    sort_by?: ProgressNoteSortBy;
+}
+/**
+ * Response for audio URL request
+ */
+interface AudioUrlResponse {
+    /** Temporary URL to access the audio file */
+    url: string;
+}
+/**
+ * Parameters for creating a progress note with audio file
+ */
+interface CreateProgressNoteWithFileParams {
+    /** Name or title of the progress note */
+    name: string;
+    /** ID of the associated patient (optional) */
+    patient_id?: number;
+    /** Audio file of the encounter */
+    file: File | Blob;
+    /** ID of the prompt/template to use (optional, defaults to 1) */
+    model_id?: number;
+    /** Additional context information for the note (optional) */
+    context?: string;
+}
+/**
+ * Parameters for creating a text-only progress note
+ */
+interface CreateProgressNoteTextParams {
+    /** Name or title of the progress note */
+    name: string;
+    /** Text content of the note (120-40000 characters) */
+    note: string;
+    /** ID of the prompt/template to use */
+    model_id: number;
+    /** ID of the associated patient (optional) */
+    patient_id?: number;
+    /** Additional context information for the note (optional) */
+    context?: string;
+    /** Array of document IDs to link to this note (optional) */
+    documents?: number[];
+}
+/**
+ * Parameters for creating a progress note (audio file or text-only)
+ */
+type CreateProgressNoteParams = CreateProgressNoteWithFileParams | CreateProgressNoteTextParams;
+/**
+ * Parameters for updating a progress note
+ */
+interface UpdateProgressNoteParams {
+    /** Name or title of the progress note */
+    name?: string;
+    /** Transcribed content of the audio recording */
+    transcription?: string;
+    /** AI-generated analysis of the transcription */
+    analysis?: string;
+}
+
+/**
+ * Full patient object
+ */
+interface PatientFull {
+    /** Unique identifier for the patient */
+    id: number;
+    /** UUID for the patient */
+    uuid: string;
+    /** Patient's first name */
+    first_name: string;
+    /** Patient's middle name */
+    middle_name?: string | null;
+    /** Patient's last name */
+    last_name: string;
+    /** Patient's gender (when demographics are loaded) */
+    gender?: string | null;
+    /** Patient's date of birth */
+    date_of_birth: string;
+    /** Clinical notes about the patient */
+    notes?: string | null;
+    /** List of current medications (when loaded) */
+    latest_medications?: string[];
+    /** User who created the patient (when loaded) */
+    user?: User;
+    /** Patient timeline events (when loaded) */
+    timeline?: unknown[];
+    /** Recent encounters/progress notes (when loaded) */
+    encounters?: ProgressNote[];
+    /** Additional metadata */
+    meta?: Record<string, unknown> | null;
+    /** When the patient was created */
+    created_at: string;
+    /** When the patient was last updated */
+    updated_at: string;
+}
+/**
+ * Sort options for listing patients
+ */
+type PatientSortField = "id" | "-id" | "first_name" | "-first_name" | "last_name" | "-last_name" | "date_of_birth" | "-date_of_birth" | "created_at" | "-created_at" | "updated_at" | "-updated_at";
+/**
+ * Trashed filter options
+ */
+type PatientTrashedFilter = "with" | "only";
+/**
+ * Query parameters for listing patients
+ */
+interface ListPatientsParams {
+    /** Number of items per page */
+    per_page?: number;
+    /** Sort field. Prefix with - for descending order */
+    sort?: PatientSortField;
+    /** Filter by first name */
+    "filter[first_name]"?: string;
+    /** Filter by last name */
+    "filter[last_name]"?: string;
+    /** Filter by date of birth */
+    "filter[date_of_birth]"?: string;
+    /** Include soft-deleted patients */
+    "filter[trashed]"?: PatientTrashedFilter;
+    /** Comma-separated list of relationships to include */
+    include?: string;
+}
+/**
+ * Parameters for creating a patient
+ */
+interface CreatePatientParams {
+    /** Patient's first name */
+    first_name: string;
+    /** Patient's middle name */
+    middle_name?: string | null;
+    /** Patient's last name */
+    last_name: string;
+    /** Patient's date of birth (must be before today) */
+    date_of_birth: string;
+    /** Clinical notes about the patient */
+    notes?: string | null;
+    /** Known allergies */
+    allergies?: string | null;
+    /** Insurance information */
+    insurance?: string | null;
+    /** Additional metadata */
+    meta?: Record<string, unknown> | null;
+}
+/**
+ * Parameters for updating a patient
+ */
+interface UpdatePatientParams {
+    /** Patient's first name */
+    first_name?: string;
+    /** Patient's middle name */
+    middle_name?: string | null;
+    /** Patient's last name */
+    last_name?: string;
+    /** Patient's date of birth (must be before today) */
+    date_of_birth?: string;
+    /** Clinical notes about the patient */
+    notes?: string | null;
+    /** Known allergies */
+    allergies?: string | null;
+    /** Additional metadata */
+    meta?: Record<string, unknown> | null;
+}
+/**
+ * Sort options for search
+ */
+type PatientSearchSortBy = "asc" | "desc";
+/**
+ * Query parameters for searching patients
+ */
+interface SearchPatientsParams {
+    /** Search query string */
+    query: string;
+    /** Number of results per page (1-100) */
+    per_page?: number;
+    /** Sort order by updated_at */
+    sort_by?: PatientSearchSortBy;
+}
+/**
+ * Response wrapper for single patient
+ */
+interface PatientResponse {
+    /** Patient data */
+    data: PatientFull;
+}
+
+/**
+ * Billing plan information
+ */
+interface BillingPlan {
+    /** Unique identifier for the plan */
+    id: number;
+    /** Display name of the plan */
+    name: string;
+    /** URL-friendly identifier for the plan */
+    slug: string;
+    /** Price of the plan per user */
+    price: number;
+    /** Currency symbol or prefix for price display */
+    price_prefix?: string;
+    /** Suffix for price display (e.g., per month) */
+    price_suffix?: string;
+    /** Short description of the plan */
+    description?: string;
+    /** List of features included in the plan */
+    features?: string[];
+}
+/**
+ * Response for listing billing plans
+ */
+interface BillingPlansResponse {
+    /** List of available billing plans */
+    plans: BillingPlan[];
+}
+/**
+ * Billing cost estimate
+ */
+interface BillingEstimate {
+    /** Total number of users in the team and child teams */
+    users: number;
+    /** Total estimated cost */
+    total: number;
+    /** Formatted total cost with currency symbol */
+    total_formatted: string;
+    /** Next billing renewal date */
+    renewal_date: string;
+}
+/**
+ * Trial information
+ */
+interface BillingTrial {
+    /** Whether the user had a trial that has expired */
+    has_expired_trial: boolean;
+    /** Whether the user is currently on a trial */
+    on_trial: boolean;
+    /** Date when the trial ends */
+    trial_ends_at?: string | null;
+}
+/**
+ * Subscription plan details in usage response
+ */
+interface BillingPlanStatus {
+    /** Name of the subscribed plan */
+    name: string;
+    /** Current subscription status */
+    status: "active" | "past_due" | "canceled" | "incomplete" | "incomplete_expired" | "trialing" | "paused";
+    /** Date when the subscription ends (if canceled) */
+    ends_at?: string | null;
+    /** Whether the subscription is currently active */
+    active: boolean;
+    /** Whether the subscription has past due payments */
+    past_due: boolean;
+    /** Trial information */
+    trial: BillingTrial;
+}
+/**
+ * Usage statistics
+ */
+interface BillingUsageStats {
+    /** Total usage count (weighted sum of all items) */
+    used: number;
+    /** Weighted count of peer reviews (0.25 per review) */
+    peer_reviews: string;
+    /** Count of encounters (1.0 per encounter) */
+    encounters: string;
+    /** Weighted count of documents (0.5 per document) */
+    documents: string;
+    /** Start date of the current billing period */
+    period_start: string;
+    /** End date of the current billing period */
+    period_end: string;
+    /** Date when usage resets */
+    resets_at: string;
+    /** Maximum allowed usage for the current plan */
+    limit: number;
+    /** Timestamp when usage was last calculated */
+    updated: string;
+}
+/**
+ * Billing usage response
+ */
+interface BillingUsage {
+    /** Current subscription plan details */
+    plan: BillingPlanStatus;
+    /** Usage statistics for the current billing period */
+    usage: BillingUsageStats;
+}
+
+/**
+ * Response for audio transcription
+ */
+interface TranscriptionResponse {
+    /** Status of the transcription request */
+    status: "success" | "error";
+    /** Whether the transcription was successful */
+    success: boolean;
+    /** Human-readable status message */
+    message: string;
+    /** The transcribed text from the audio file */
+    text?: string | null;
+}
+/**
+ * Response for transcription token request
+ */
+interface TranscriptionTokenResponse {
+    /** Whether the token was retrieved successfully */
+    success: boolean;
+    /** Human-readable status message */
+    message: string;
+    /** Temporary Deepgram API token for client-side transcription */
+    token?: string | null;
+}
+/**
+ * Parameters for transcribing an audio file
+ */
+interface TranscribeFileParams {
+    /** Audio file to transcribe. Supported formats: mp3, mp4, m4a, wav, ogg, webm, flac, aac, pcm, opus. Maximum size: 200MB */
+    file: File | Blob;
+}
+
+/**
+ * Authentication resource for managing access tokens
+ */
+declare class AuthResource 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
+     * ```
+     */
+    createToken(credentials: LoginRequest): Promise<TokenResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    googleAuth(params: GoogleAuthRequest): Promise<GoogleAuthResponse>;
+    /**
+     * 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
+     * ```
+     */
+    revokeCurrentToken(): Promise<RevokeTokenResponse>;
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    listTokens(): Promise<TokensListResponse>;
+    /**
+     * 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");
+     * }
+     * ```
+     */
+    revokeToken(id: number): Promise<RevokeTokenResponse>;
+}
+
+/**
+ * Users resource for managing user accounts
+ */
+declare class UsersResource 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})`);
+     * ```
+     */
+    getCurrentUser(): Promise<User>;
+}
+
+/**
+ * Patients resource for managing patient records
+ */
+declare class PatientsResource 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"
+     * });
+     * ```
+     */
+    list(params?: ListPatientsParams): Promise<PaginatedResponse<PatientFull>>;
+    /**
+     * 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);
+     * ```
+     */
+    get(id: number): Promise<PatientResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    create(params: CreatePatientParams): Promise<PatientResponse>;
+    /**
+     * 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"
+     * ```
+     */
+    update(id: number, params: UpdatePatientParams): Promise<PatientResponse>;
+    /**
+     * 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"
+     * });
+     * ```
+     */
+    delete(id: number): Promise<MessageResponse>;
+    /**
+     * 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}`);
+     * });
+     * ```
+     */
+    search(params: SearchPatientsParams): Promise<PaginatedResponse<PatientFull>>;
+}
+
+/**
+ * Progress Notes resource for managing clinical documentation
+ */
+declare class ProgressNotesResource 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"
+     * });
+     * ```
+     */
+    list(params?: ListProgressNotesParams): Promise<PaginatedResponse<ProgressNote>>;
+    /**
+     * 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);
+     * ```
+     */
+    get(id: number): Promise<ProgressNote>;
+    /**
+     * 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
+     * ```
+     */
+    getAudioUrl(id: number): Promise<AudioUrlResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    create(params: CreateProgressNoteParams): Promise<ProgressNote>;
+    /**
+     * 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..."
+     * });
+     * ```
+     */
+    update(id: number, params: UpdateProgressNoteParams): Promise<ProgressNote>;
+    /**
+     * 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");
+     * ```
+     */
+    delete(id: number): Promise<MessageResponse>;
+    /**
+     * 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
+     * ```
+     */
+    sign(id: number): Promise<ProgressNote>;
+}
+
+/**
+ * Billing resource for managing subscription and usage
+ */
+declare class BillingResource 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}`));
+     *   }
+     * }
+     * ```
+     */
+    listPlans(): Promise<BillingPlansResponse>;
+    /**
+     * 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}`);
+     * ```
+     */
+    getEstimate(): Promise<BillingEstimate>;
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    getUsage(module: string): Promise<BillingUsage>;
+}
+
+/**
+ * Transcription resource for audio transcription services
+ */
+declare class TranscriptionResource 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
+     * ```
+     */
+    transcribeFile(params: TranscribeFileParams): Promise<TranscriptionResponse>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    getToken(): Promise<TranscriptionTokenResponse>;
+}
+
+/**
+ * Default production API base URL
+ */
+declare const DEFAULT_BASE_URL = "https://nextvisit.app/api";
+/**
+ * Configuration options for the Nextvisit client
+ */
+interface NextvisitClientConfig {
+    /**
+     * Authentication token for API requests
+     *
+     * Can be obtained by calling `client.auth.createToken()` or from
+     * a previously stored token.
+     */
+    token?: string;
+    /**
+     * Base URL for API requests
+     *
+     * Defaults to the production API (https://nextvisit.app/api).
+     * Use "http://localhost/api" for local development.
+     */
+    baseUrl?: string;
+    /**
+     * Custom fetch implementation
+     *
+     * Useful for testing or custom HTTP handling. If not provided,
+     * the global `fetch` function will be used.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Request timeout in milliseconds
+     *
+     * Defaults to 30000 (30 seconds).
+     */
+    timeout?: number;
+}
+/**
+ * Nextvisit API client
+ *
+ * The main entry point for interacting with the Nextvisit Clinical
+ * Documentation API. Provides access to all API resources through
+ * typed, promise-based methods.
+ *
+ * @example
+ * ```typescript
+ * import { NextvisitClient } from "@yannelli/nextvisit-sdk";
+ *
+ * // Create a client with an existing token
+ * const client = new NextvisitClient({
+ *   token: "nv-sk-..."
+ * });
+ *
+ * // Or authenticate to get a token
+ * const client = new NextvisitClient();
+ * const { token } = await client.auth.createToken({
+ *   email: "user@example.com",
+ *   password: "password",
+ *   device_name: "My App"
+ * });
+ * client.setToken(token);
+ *
+ * // Use the API
+ * const user = await client.users.getCurrentUser();
+ * const notes = await client.progressNotes.list();
+ * ```
+ */
+declare class NextvisitClient {
+    private readonly http;
+    /**
+     * Authentication resource for managing access tokens
+     */
+    readonly auth: AuthResource;
+    /**
+     * Users resource for managing user accounts
+     */
+    readonly users: UsersResource;
+    /**
+     * Progress Notes resource for managing clinical documentation
+     */
+    readonly progressNotes: ProgressNotesResource;
+    /**
+     * Billing resource for managing subscription and usage
+     */
+    readonly billing: BillingResource;
+    /**
+     * Transcription resource for audio transcription services
+     */
+    readonly transcription: TranscriptionResource;
+    /**
+     * Patients resource for managing patient records
+     */
+    readonly patients: PatientsResource;
+    /**
+     * Create a new Nextvisit API client
+     *
+     * @param config - Client configuration options
+     */
+    constructor(config?: NextvisitClientConfig);
+    /**
+     * 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: string): void;
+    /**
+     * Clear the authentication token
+     *
+     * Removes the current token. Subsequent requests will be
+     * unauthenticated.
+     *
+     * @example
+     * ```typescript
+     * await client.auth.revokeCurrentToken();
+     * client.clearToken();
+     * ```
+     */
+    clearToken(): void;
+    /**
+     * Check if the client has an authentication token set
+     *
+     * @returns `true` if a token is set, `false` otherwise
+     */
+    hasToken(): boolean;
+}
+
+/**
+ * Base error class for Nextvisit API errors
+ */
+declare class NextvisitError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when the API returns an error response
+ */
+declare class NextvisitApiError extends NextvisitError {
+    /** HTTP status code */
+    readonly status: number;
+    /** Detailed validation errors by field */
+    readonly errors?: Record<string, string[]>;
+    constructor(status: number, error: ApiError);
+}
+/**
+ * Error thrown when authentication fails (401)
+ */
+declare class UnauthorizedError extends NextvisitApiError {
+    constructor(error: ApiError);
+}
+/**
+ * Error thrown when access is forbidden (403)
+ */
+declare class ForbiddenError extends NextvisitApiError {
+    constructor(error: ApiError);
+}
+/**
+ * Error thrown when a resource is not found (404)
+ */
+declare class NotFoundError extends NextvisitApiError {
+    constructor(error: ApiError);
+}
+/**
+ * Error thrown when validation fails (422)
+ */
+declare class ValidationError extends NextvisitApiError {
+    constructor(error: ApiError);
+}
+/**
+ * Error thrown when a network request fails
+ */
+declare class NetworkError extends NextvisitError {
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+
+export { type ApiError, type AudioUrlResponse, AuthResource, type BillingEstimate, type BillingPlan, type BillingPlanStatus, type BillingPlansResponse, BillingResource, type BillingTrial, type BillingUsage, type BillingUsageStats, type CreatePatientParams, type CreateProgressNoteParams, type CreateProgressNoteTextParams, type CreateProgressNoteWithFileParams, DEFAULT_BASE_URL, ForbiddenError, type GoogleAuthRequest, type GoogleAuthResponse, type ListPatientsParams, type ListProgressNotesParams, type LoginRequest, type MessageResponse, NetworkError, NextvisitApiError, NextvisitClient, type NextvisitClientConfig, NextvisitError, NotFoundError, type PaginatedResponse, type PaginationLinks, type PaginationMeta, type Patient, type PatientFull, type PatientResponse, type PatientSearchSortBy, type PatientSortField, type PatientTrashedFilter, PatientsResource, type ProgressNote, type ProgressNoteAudio, type ProgressNoteHas, type ProgressNoteSortBy, type ProgressNoteTemplate, ProgressNotesResource, type RevokeTokenResponse, type SearchPatientsParams, type TokenInfo, type TokenResponse, type TokenSuccessResponse, type TokenTeam, type TokenUser, type TokensListResponse, type TranscribeFileParams, TranscriptionResource, type TranscriptionResponse, type TranscriptionTokenResponse, UnauthorizedError, type UpdatePatientParams, type UpdateProgressNoteParams, type User, UsersResource, ValidationError, type VerificationRequiredResponse, type VerificationType };