@gpt-platform/client 0.10.4 → 0.11.0

package/dist/namespaces/connectors.d.ts

@@ -0,0 +1,1368 @@
+import type { ConnectorInstance, Credential } from "../_internal/types.gen";
+/** Attributes accepted when creating a new connector instance. */
+export type CreateConnectorInstanceAttributes = {
+    connector_type: string;
+    name: string;
+    workspace_id: string;
+    base_url?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a connector instance (PATCH semantics). */
+export type UpdateConnectorInstanceAttributes = {
+    name?: string;
+    base_url?: string;
+    [key: string]: unknown;
+};
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+/**
+ * Result returned by `oauth.connect()` — contains the URL to redirect the
+ * user to for provider authorization and the CSRF-protection state token.
+ */
+export interface OAuthInitiateResult {
+    auth_url: string;
+    state: string;
+}
+/**
+ * A patient record as represented in Fullscript.
+ * Returned by `fullscript.checkPatient` and `fullscript.createPatient`.
+ */
+export interface FullscriptPatient {
+    id: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    date_of_birth?: string;
+    fullscript_id?: string;
+    [key: string]: unknown;
+}
+/**
+ * A recipe record as returned by the Edamam Recipe API.
+ * Returned by `edamam.recipes.search` (as `hits` items) and
+ * `edamam.recipes.get` (as `recipe`).
+ */
+export interface EdamamRecipe {
+    uri: string;
+    label: string;
+    image?: string;
+    source?: string;
+    url?: string;
+    yield?: number;
+    dietLabels?: string[];
+    healthLabels?: string[];
+    ingredientLines?: string[];
+    calories?: number;
+    totalTime?: number;
+    cuisineType?: string[];
+    mealType?: string[];
+    dishType?: string[];
+}
+/**
+ * Parameters for `edamam.recipes.search()`.
+ */
+export interface EdamamSearchParams {
+    query: string;
+    health?: string[];
+    diet?: string[];
+    from?: number;
+    to?: number;
+}
+/**
+ * Result shape returned by `edamam.recipes.search()`.
+ */
+export interface EdamamSearchResult {
+    hits: EdamamRecipe[];
+    count: number;
+    next_page?: string;
+}
+/**
+ * A short-lived embed session grant for the Fullscript prescribing widget.
+ * Returned by `fullscript.sessionGrant()`.
+ */
+export interface FullscriptSessionGrant {
+    token: string;
+    expires_at: string;
+    patient_id: string;
+}
+export interface FullscriptTreatmentPlan {
+    id: string;
+    state: string;
+    patient_id?: string;
+    created_at?: string;
+    updated_at?: string;
+    invitation_url?: string;
+    message?: string;
+    recommendations?: Array<{
+        product_id?: string;
+        product_name?: string;
+        variant_id?: string;
+        dosage?: string;
+        frequency?: string;
+        units_to_purchase?: number;
+    }>;
+    [key: string]: unknown;
+}
+export interface FullscriptProduct {
+    id: string;
+    name?: string;
+    brand?: string;
+    description?: string;
+    image_url?: string;
+    product_url?: string;
+    variants?: Array<{
+        id?: string;
+        name?: string;
+        dosage_form?: string;
+        size?: string;
+        price?: string;
+        msrp?: string;
+        sku?: string;
+    }>;
+    categories?: string[];
+    allergens?: string[];
+    third_party_certifications?: string[];
+    [key: string]: unknown;
+}
+export interface FullscriptOrder {
+    id: string;
+    state?: string;
+    created_at?: string;
+    updated_at?: string;
+    line_items?: Array<{
+        product_id?: string;
+        product_name?: string;
+        variant_id?: string;
+        quantity?: number;
+        price?: string;
+    }>;
+    item_total?: string;
+    payment_total?: string;
+    msrp_total?: string;
+    shipping_total?: string;
+    patient_id?: string;
+    [key: string]: unknown;
+}
+/**
+ * A patient record from Healthie EHR.
+ * Returned by `healthie.listPatients` and synced via `healthie.syncPatients`.
+ */
+export interface HealthiePatient {
+    id: string;
+    first_name: string;
+    last_name: string;
+    email: string;
+    phone_number?: string;
+    dob?: string;
+    gender?: string;
+    height?: number;
+    weight?: number;
+    diet_type?: string;
+    food_allergies?: string[];
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * An appointment record from Healthie EHR.
+ * Returned by `healthie.listAppointments` and synced via `healthie.syncAppointments`.
+ */
+export interface HealthieAppointment {
+    id: string;
+    date: string;
+    start: string;
+    end: string;
+    notes?: string;
+    location?: string;
+    status: string;
+    appointment_type: {
+        name: string;
+    };
+    user: {
+        id: string;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Sync status for Healthie connector.
+ * Returned by `healthie.getSyncStatus`.
+ */
+export interface HealthieSyncStatus {
+    last_synced_at: string | null;
+    patient_count: number;
+    appointment_count: number;
+    errors: string[];
+    status: "completed" | "failed" | "in_progress" | "never_synced";
+}
+/**
+ * Result returned by `healthie.syncPatients` and `healthie.syncAppointments`.
+ */
+export interface HealthieSyncResult {
+    synced: number;
+    errors: string[];
+}
+/**
+ * Result returned by `healthie.syncAll`.
+ */
+export interface HealthieSyncAllResult {
+    patients_synced: number;
+    appointments_synced: number;
+    errors: string[];
+}
+/**
+ * Parameters for listing Healthie records with date filter.
+ */
+export interface HealthieListOptions {
+    since?: Date;
+}
+export interface CreateTreatmentPlanAttributes {
+    patient_id: string;
+    recommendations: Array<{
+        product_id: string;
+        variant_id?: string;
+        dosage?: string;
+        frequency?: string;
+        units_to_purchase?: number;
+    }>;
+    send_invitation?: boolean;
+    message?: string;
+}
+export interface ProductMatchQuery {
+    name: string;
+    form?: string;
+    dosage?: string;
+}
+export interface ProductMatchResult {
+    query: string;
+    matches: FullscriptProduct[];
+}
+/** Attributes for upserting connector credentials. */
+export type UpsertCredentialAttributes = {
+    workspace_id: string;
+    connector_type: string;
+    auth_type: string;
+    auth_data: Record<string, unknown>;
+    scope_level: string;
+};
+/** @public Action-specific parameters passed to the sync engine (e.g., cursor, filter criteria). */
+export interface SyncActionParams {
+    [key: string]: unknown;
+}
+/** Parameters for triggering a connector sync. */
+export type TriggerSyncParams = {
+    workspace_id: string;
+    action_name: "full" | "incremental" | "webhook" | "manual";
+    params?: SyncActionParams;
+};
+/** Result returned by sync trigger. */
+export interface SyncTriggerResult {
+    sync_log_id: string;
+    status: string;
+}
+/** A sync execution log record. */
+export interface SyncLog {
+    id: string;
+    type: string;
+    attributes?: {
+        connector_instance_id?: string;
+        sync_type?: string;
+        status?: string;
+        started_at?: string;
+        completed_at?: string;
+        records_processed?: number;
+        records_created?: number;
+        records_updated?: number;
+        records_failed?: number;
+        error_message?: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+/** Parameters for pushing a note to Practice Better. */
+export type PBPushNoteParams = {
+    workspace_id: string;
+    contact_id: string;
+    note_content: string;
+    note_type?: string;
+    title?: string;
+};
+/**
+ * Healthie EHR connector namespace methods.
+ *
+ * All methods require valid `connectorId` and `workspaceId` from an active Healthie connector.
+ */
+export interface HealthieNamespace {
+    /**
+     * List all patients from Healthie.
+     *
+     * @param connectorId - The UUID of the Healthie connector instance.
+     * @param workspaceId - The workspace ID for scoping.
+     * @param options - Optional filters including `since` date for incremental sync.
+     * @returns Array of Healthie patient records.
+     */
+    listPatients(connectorId: string, workspaceId: string, options?: HealthieListOptions & RequestOptions): Promise<HealthiePatient[]>;
+    /**
+     * Sync patients from Healthie to platform.
+     *
+     * Creates/updates: Contact, DietaryProfile, HealthMetric, Patient records.
+     * Returns sync summary with count and errors.
+     *
+     * @param connectorId - The UUID of the Healthie connector instance.
+     * @param workspaceId - The workspace ID for scoping.
+     * @param options - Optional request options.
+     * @returns Sync summary with `synced` count and `errors` array.
+     */
+    syncPatients(connectorId: string, workspaceId: string, options?: RequestOptions): Promise<HealthieSyncResult>;
+    /**
+     * List all appointments from Healthie.
+     *
+     * @param connectorId - The UUID of the Healthie connector instance.
+     * @param workspaceId - The workspace ID for scoping.
+     * @param options - Optional filters including `since` date for incremental sync.
+     * @returns Array of Healthie appointment records.
+     */
+    listAppointments(connectorId: string, workspaceId: string, options?: HealthieListOptions & RequestOptions): Promise<HealthieAppointment[]>;
+    /**
+     * Sync appointments from Healthie to platform.
+     *
+     * Creates ClinicalSession records linked to Patients.
+     * Returns sync summary with count and errors.
+     *
+     * @param connectorId - The UUID of the Healthie connector instance.
+     * @param workspaceId - The workspace ID for scoping.
+     * @param options - Optional request options.
+     * @returns Sync summary with `synced` count and `errors` array.
+     */
+    syncAppointments(connectorId: string, workspaceId: string, options?: RequestOptions): Promise<HealthieSyncResult>;
+    /**
+     * Sync all Healthie data (patients + appointments).
+     *
+     * Combined sync operation that processes both patients and appointments.
+     * Returns combined sync summary.
+     *
+     * @param connectorId - The UUID of the Healthie connector instance.
+     * @param workspaceId - The workspace ID for scoping.
+     * @param options - Optional request options.
+     * @returns Combined sync summary with both patient and appointment counts.
+     */
+    syncAll(connectorId: string, workspaceId: string, options?: RequestOptions): Promise<HealthieSyncAllResult>;
+    /**
+     * Get current sync status for Healthie connector.
+     *
+     * Returns status from most recent sync operation including timestamps,
+     * record counts, and any errors.
+     *
+     * @param connectorId - The UUID of the Healthie connector instance.
+     * @param workspaceId - The workspace ID for scoping.
+     * @param options - Optional request options.
+     * @returns Sync status with last sync time and record counts.
+     */
+    getStatus(connectorId: string, workspaceId: string, options?: RequestOptions): Promise<HealthieSyncStatus>;
+}
+/**
+ * Connectors namespace for external system integrations (Salesforce, SharePoint,
+ * Slack, HubSpot, Edamam, Fullscript, and more).
+ *
+ * Access via `client.connectors`.
+ *
+ * The connectors system is organized into three layers:
+ * 1. **Instances** — configured connections to external systems.
+ * 2. **Credentials** — OAuth tokens and API keys that authenticate those connections.
+ * 3. **Provider sub-namespaces** — Edamam, Fullscript — typed wrappers for
+ *    provider-specific operations that go beyond generic CRUD.
+ *
+ * @example
+ * ```typescript
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ *
+ * // Initiate OAuth for Salesforce
+ * const { auth_url } = await client.connectors.oauth.connect('salesforce', workspaceId);
+ * window.location.href = auth_url;
+ * ```
+ */
+export declare function createConnectorsNamespace(rb: RequestBuilder): {
+    /**
+     * Connector Instances — configured external system connections in the workspace.
+     *
+     * A `ConnectorInstance` represents a live, configured connection to a specific
+     * external system (e.g., a Salesforce org, a specific SharePoint site). Instances
+     * hold configuration like display name, connector type, and status. Credentials
+     * (OAuth tokens, API keys) are stored separately in `credentials`.
+     */
+    instances: {
+        /**
+         * List all connector instances for the current workspace.
+         *
+         * @param options - Optional request options.
+         * @returns An array of `ConnectorInstance` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const instances = await client.connectors.instances.list();
+         * instances.forEach(i => console.log(i.attributes?.connector_type));
+         * ```
+         */
+        list: (options?: RequestOptions) => Promise<ConnectorInstance[]>;
+        /**
+         * Retrieve a connector instance by its ID.
+         *
+         * @param id - The UUID of the connector instance.
+         * @param options - Optional request options.
+         * @returns The matching `ConnectorInstance`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const instance = await client.connectors.instances.get('ci_abc123');
+         * console.log(instance.attributes?.status);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ConnectorInstance>;
+        /**
+         * Create a new connector instance.
+         *
+         * Typical attributes: `connector_type`, `name`, `workspace_id`, and any
+         * connector-specific configuration (e.g., `base_url` for custom connectors).
+         * For OAuth-based connectors, use `oauth.connect` to initiate the auth flow
+         * instead of creating an instance directly.
+         *
+         * @param attributes - Connector instance attributes.
+         * @param options - Optional request options.
+         * @returns The newly created `ConnectorInstance`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const instance = await client.connectors.instances.create({
+         *   connector_type: 'custom',
+         *   name: 'Internal CRM',
+         *   workspace_id: 'ws_abc123',
+         *   base_url: 'https://api.internal.example.com',
+         * });
+         * ```
+         */
+        create: (attributes: CreateConnectorInstanceAttributes, options?: RequestOptions) => Promise<ConnectorInstance>;
+        /**
+         * Update a connector instance's configuration.
+         *
+         * Use to rename the connector, update its base URL, or change other
+         * non-credential configuration. Does not update OAuth tokens; use
+         * `credentials.refresh` for token renewal.
+         *
+         * @param id - The UUID of the connector instance to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `ConnectorInstance`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const instance = await client.connectors.instances.update('ci_abc123', {
+         *   name: 'Salesforce — Production',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateConnectorInstanceAttributes, options?: RequestOptions) => Promise<ConnectorInstance>;
+        /**
+         * Delete a connector instance.
+         *
+         * Removes the instance and its associated credential records. The external
+         * provider's OAuth tokens are not revoked; if required, revoke them through
+         * the provider's admin console separately.
+         *
+         * @param id - The UUID of the connector instance to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.connectors.instances.delete('ci_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Credentials — OAuth tokens and API keys for external connector systems.
+     *
+     * Credentials are stored encrypted server-side and are associated with a
+     * `ConnectorInstance`. They are never returned with secret values in list/get
+     * responses — only metadata (expiry, scope, provider) is exposed.
+     */
+    credentials: {
+        /**
+         * List all credentials for the current workspace.
+         *
+         * Secret values (tokens, keys) are never included in the response.
+         * Only metadata such as `provider`, `expires_at`, and `scope` are returned.
+         *
+         * @param options - Optional request options.
+         * @returns An array of `Credential` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const creds = await client.connectors.credentials.list();
+         * creds.forEach(c => console.log(c.attributes?.provider, c.attributes?.expires_at));
+         * ```
+         */
+        list: (options?: RequestOptions) => Promise<Credential[]>;
+        /**
+         * Retrieve a single credential record by its ID.
+         *
+         * @param id - The UUID of the credential.
+         * @param options - Optional request options.
+         * @returns The matching `Credential` record (without secret values).
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const cred = await client.connectors.credentials.get('cred_abc123');
+         * console.log(cred.attributes?.expires_at);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<Credential>;
+        /**
+         * Refresh an expired or expiring OAuth credential.
+         *
+         * Triggers the platform's OAuth token refresh flow using the stored
+         * refresh token. The credential record is updated with the new access
+         * token and expiry time. Returns the updated credential metadata.
+         *
+         * @param id - The UUID of the credential to refresh.
+         * @param workspaceId - The workspace that owns the credential.
+         * @param options - Optional request options.
+         * @returns The updated `Credential` record with refreshed expiry.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const refreshed = await client.connectors.credentials.refresh(
+         *   'cred_abc123',
+         *   'ws_abc123',
+         * );
+         * console.log(refreshed.attributes?.expires_at);
+         * ```
+         */
+        refresh: (id: string, workspaceId: string, options?: RequestOptions) => Promise<Credential>;
+        /**
+         * Create or update credentials for a connector at a specific scope level.
+         *
+         * If credentials already exist for the given connector_type + scope_level + workspace,
+         * they are updated. Otherwise, new credentials are created.
+         *
+         * @param attributes - Credential attributes including connector_type, auth_type, auth_data, scope_level, workspace_id.
+         * @param options - Optional request options.
+         * @returns The upserted `Credential` record.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const cred = await client.connectors.credentials.upsert({
+         *   workspace_id: 'ws_abc123',
+         *   connector_type: 'practice_better',
+         *   auth_type: 'client_credentials',
+         *   auth_data: { client_id: 'pb_id', client_secret: 'pb_secret' },
+         *   scope_level: 'workspace',
+         * });
+         * ```
+         */
+        upsert: (attributes: UpsertCredentialAttributes, options?: RequestOptions) => Promise<Credential>;
+        /**
+         * Delete credentials for a connector by type and scope level.
+         *
+         * @param workspaceId - The workspace UUID.
+         * @param connectorType - The connector type (e.g., "practice_better").
+         * @param scopeLevel - The scope level ("workspace", "tenant", or "application").
+         * @param options - Optional request options.
+         * @returns `{ deleted: true }` on success.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.connectors.credentials.deleteByType(
+         *   'ws_abc123',
+         *   'practice_better',
+         *   'workspace',
+         * );
+         * ```
+         */
+        deleteByType: (workspaceId: string, connectorType: string, scopeLevel: string, options?: RequestOptions) => Promise<{
+            deleted: boolean;
+        }>;
+    };
+    /**
+     * OAuth — initiate and complete OAuth authorization flows for any connector type.
+     *
+     * Use `connect` to get the provider authorization URL, redirect the user,
+     * then call `callback` in your redirect handler to exchange the authorization
+     * code for a stored credential.
+     */
+    oauth: {
+        /**
+         * Get the OAuth authorization URL for a connector type.
+         *
+         * Returns the provider's authorization URL that you must redirect the user
+         * to so they can grant access. Also returns a `state` token for CSRF protection
+         * — store it in the session and verify it matches when `callback` is called.
+         *
+         * @param connectorType - The connector type identifier (e.g., `"salesforce"`,
+         *   `"slack"`, `"google_calendar"`). See `available.list()` for all supported types.
+         * @param workspaceId - The workspace UUID to associate the resulting credential with.
+         * @param options - Optional request options.
+         * @returns An `OAuthInitiateResult` with `auth_url` and `state`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const { auth_url, state } = await client.connectors.oauth.connect(
+         *   'slack',
+         *   'ws_abc123',
+         * );
+         * sessionStorage.setItem('oauth_state', state);
+         * window.location.href = auth_url;
+         * ```
+         */
+        connect: (connectorType: string, workspaceId: string, options?: RequestOptions) => Promise<OAuthInitiateResult>;
+        /**
+         * Exchange an OAuth authorization code for a stored credential.
+         *
+         * Called from your OAuth redirect handler after the user has authorized
+         * access at the provider. Verifies the `state` token, exchanges the `code`
+         * for access/refresh tokens, and stores them as a `Credential` record linked
+         * to the workspace. Returns the resulting `ConnectorInstance`.
+         *
+         * Pass `redirectUri` if a custom redirect URI was used in `connect` — it must
+         * exactly match the URI registered with the provider and sent during authorization.
+         *
+         * @param connectorType - The connector type identifier (must match what was
+         *   passed to `connect`).
+         * @param code - The authorization code from the provider redirect query string.
+         * @param state - The CSRF state token from the redirect query string.
+         * @param workspaceId - The workspace UUID (same as passed to `connect`).
+         * @param redirectUri - Optional. The redirect URI used during `connect`, if custom.
+         * @param options - Optional request options.
+         * @returns The `ConnectorInstance` created or updated with the new credential.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * // In your OAuth redirect handler:
+         * const params = new URLSearchParams(window.location.search);
+         * const instance = await client.connectors.oauth.callback(
+         *   'slack',
+         *   params.get('code')!,
+         *   params.get('state')!,
+         *   'ws_abc123',
+         * );
+         * console.log('Connected:', instance.id);
+         * ```
+         */
+        callback: (connectorType: string, code: string, state: string, workspaceId: string, redirectUri?: string, options?: RequestOptions) => Promise<ConnectorInstance>;
+    };
+    /**
+     * Supported Connectors — discover the catalog of available connector types.
+     *
+     * Returns the static list of integration types the platform supports.
+     * Use this to populate connector selection UIs.
+     */
+    available: {
+        /**
+         * List all supported connector type identifiers.
+         *
+         * Returns a static array of strings — no network request is made.
+         * Each identifier can be passed to `oauth.connect` or used as the
+         * `connector_type` when creating a `ConnectorInstance`.
+         *
+         * @returns An array of connector type identifier strings.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const types = client.connectors.available.list();
+         * console.log(types);
+         * // ["salesforce", "sharepoint", "slack", "edamam", "fullscript", ...]
+         * ```
+         */
+        list: () => string[];
+    };
+    /**
+     * Sync — trigger and monitor sync operations for connector instances.
+     */
+    sync: {
+        /**
+         * Trigger a sync operation for a connector instance.
+         *
+         * @param connectorInstanceId - UUID of the connector instance to sync.
+         * @param params - Sync parameters including workspace_id and action_name.
+         * @param options - Optional request options.
+         * @returns A `SyncTriggerResult` with `sync_log_id` and `status`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const result = await client.connectors.sync.trigger('ci_abc123', {
+         *   workspace_id: 'ws_abc123',
+         *   action_name: 'full',
+         * });
+         * console.log('Sync started:', result.sync_log_id);
+         * ```
+         */
+        trigger: (connectorInstanceId: string, params: TriggerSyncParams, options?: RequestOptions) => Promise<SyncTriggerResult>;
+        /**
+         * List sync logs, optionally filtered by connector instance.
+         *
+         * @param options - Optional request options.
+         * @returns An array of sync log records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const logs = await client.connectors.sync.logs();
+         * logs.forEach(l => console.log(l.attributes?.status));
+         * ```
+         */
+        logs: (options?: RequestOptions) => Promise<SyncLog[]>;
+        /**
+         * Get a single sync log by ID.
+         *
+         * @param id - The UUID of the sync log.
+         * @param options - Optional request options.
+         * @returns The sync log record.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const log = await client.connectors.sync.log('sl_abc123');
+         * console.log(log.attributes?.records_processed);
+         * ```
+         */
+        log: (id: string, options?: RequestOptions) => Promise<SyncLog>;
+    };
+    /**
+     * Edamam — recipe search and nutrition data via the Edamam Recipe API.
+     *
+     * Requires an active `ConnectorInstance` with `connector_type: "edamam"`.
+     * ISVs can supply their own Edamam App ID and App Key via a `Credential`
+     * record; the platform falls back to its own environment-variable keys
+     * when no ISV credential is present.
+     */
+    edamam: {
+        /**
+         * Recipe operations — search and retrieve individual recipes from Edamam.
+         */
+        recipes: {
+            /**
+             * Search for recipes matching a query string and optional dietary filters.
+             *
+             * Proxies the Edamam Recipe Search API. Results are returned as
+             * `EdamamRecipe` objects inside a `hits` array. Use `from`/`to` for
+             * pagination (Edamam uses numeric offset-based pagination, not cursors).
+             *
+             * @param connectorInstanceId - UUID of the Edamam `ConnectorInstance`.
+             * @param workspaceId - UUID of the current workspace.
+             * @param params - Search parameters: required `query`, optional `health`
+             *   labels (e.g., `["vegan"]`), `diet` labels (e.g., `["balanced"]`),
+             *   and pagination offsets `from` / `to`.
+             * @param options - Optional request options.
+             * @returns An `EdamamSearchResult` with `hits`, `count`, and optional `next_page`.
+             *
+             * @example
+             * ```typescript
+             * const client = new GptClient({ apiKey: 'sk_app_...' });
+             * const results = await client.connectors.edamam.recipes.search(
+             *   'ci_edamam_123',
+             *   'ws_abc123',
+             *   {
+             *     query: 'chicken salad',
+             *     health: ['gluten-free'],
+             *     diet: ['balanced'],
+             *     from: 0,
+             *     to: 10,
+             *   },
+             * );
+             * console.log(`${results.count} recipes found`);
+             * results.hits.forEach(r => console.log(r.label, r.calories));
+             * ```
+             */
+            search: (connectorInstanceId: string, workspaceId: string, params: EdamamSearchParams, options?: RequestOptions) => Promise<EdamamSearchResult>;
+            /**
+             * Fetch full details for a single recipe by its Edamam recipe ID.
+             *
+             * The Edamam recipe ID is the URI returned in `EdamamRecipe.uri`
+             * (e.g., `"recipe_abc123"`). Returns the complete recipe object
+             * including full ingredient list and nutritional breakdown.
+             *
+             * @param connectorInstanceId - UUID of the Edamam `ConnectorInstance`.
+             * @param workspaceId - UUID of the current workspace.
+             * @param recipeId - The Edamam recipe identifier (from `EdamamRecipe.uri`).
+             * @param options - Optional request options.
+             * @returns An object with a `recipe` property containing the full `EdamamRecipe`.
+             *
+             * @example
+             * ```typescript
+             * const client = new GptClient({ apiKey: 'sk_app_...' });
+             * const { recipe } = await client.connectors.edamam.recipes.get(
+             *   'ci_edamam_123',
+             *   'ws_abc123',
+             *   'recipe_abc123',
+             * );
+             * console.log(recipe.label, recipe.ingredientLines);
+             * ```
+             */
+            get: (connectorInstanceId: string, workspaceId: string, recipeId: string, options?: RequestOptions) => Promise<{
+                recipe: EdamamRecipe;
+            }>;
+        };
+    };
+    /**
+     * Fullscript — supplement prescribing platform integration.
+     *
+     * Requires an active `ConnectorInstance` with `connector_type: "fullscript"`
+     * and a linked OAuth `Credential`. Use `fullscript.oauth.connect` to authorize.
+     *
+     * Typical flow:
+     * 1. `fullscript.oauth.connect(workspaceId)` — redirect user to Fullscript.
+     * 2. `fullscript.oauth.callback(code, state, workspaceId)` — store credential.
+     * 3. `fullscript.checkPatient(connectorId, workspaceId, email)` — look up patient.
+     * 4. `fullscript.sessionGrant(connectorId, workspaceId, patientId)` — get embed token.
+     */
+    fullscript: {
+        /**
+         * Check whether a patient record exists in Fullscript by email address.
+         *
+         * Returns the patient object if found in the Fullscript account linked
+         * to the connector, or `null` if no patient with that email exists.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param email - The patient's email address to look up.
+         * @param options - Optional request options.
+         * @returns A `FullscriptPatient` if found, or `null` if not found.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const patient = await client.connectors.fullscript.checkPatient(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'jane@example.com',
+         * );
+         * if (patient) {
+         *   console.log('Found:', patient.fullscript_id);
+         * } else {
+         *   console.log('Patient not in Fullscript yet');
+         * }
+         * ```
+         */
+        checkPatient: (connectorId: string, workspaceId: string, email: string, options?: RequestOptions) => Promise<FullscriptPatient | null>;
+        /**
+         * Create a new patient record in Fullscript.
+         *
+         * Creates the patient in the Fullscript account linked to the connector
+         * and returns the resulting patient object including the assigned
+         * `fullscript_id`. Use this when a patient does not yet have a Fullscript
+         * account (confirmed via `checkPatient`).
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param attrs - Patient attributes: `first_name`, `last_name`, `email`
+         *   (all required), and optional `date_of_birth` (ISO 8601 date string).
+         * @param options - Optional request options.
+         * @returns The newly created `FullscriptPatient`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const patient = await client.connectors.fullscript.createPatient(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   {
+         *     first_name: 'Jane',
+         *     last_name: 'Smith',
+         *     email: 'jane@example.com',
+         *     date_of_birth: '1985-04-12',
+         *   },
+         * );
+         * console.log('Created Fullscript patient:', patient.fullscript_id);
+         * ```
+         */
+        createPatient: (connectorId: string, workspaceId: string, attrs: {
+            first_name: string;
+            last_name: string;
+            email: string;
+            date_of_birth?: string;
+        }, options?: RequestOptions) => Promise<FullscriptPatient>;
+        /**
+         * Obtain a short-lived embed session grant for the Fullscript prescribing widget.
+         *
+         * The returned `token` is used to embed the Fullscript prescribing UI for a
+         * specific patient within your application. Tokens are valid for 5–15 minutes
+         * and are cached server-side for up to 2 minutes to avoid token proliferation
+         * on repeated calls.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param patientId - The Fullscript patient ID (from `FullscriptPatient.fullscript_id`).
+         * @param options - Optional request options.
+         * @returns A `FullscriptSessionGrant` with `token`, `expires_at`, and `patient_id`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const grant = await client.connectors.fullscript.sessionGrant(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'fs_patient_456',
+         * );
+         * // Embed: `https://app.fullscript.com/embed?token=${grant.token}`
+         * console.log('Token expires:', grant.expires_at);
+         * ```
+         */
+        sessionGrant: (connectorId: string, workspaceId: string, patientId: string, options?: RequestOptions) => Promise<FullscriptSessionGrant>;
+        /**
+         * List treatment plans for a patient.
+         * @param connectorId - The Fullscript connector instance ID
+         * @param workspaceId - The workspace ID
+         * @param patientId - The Fullscript patient ID
+         * @returns Array of treatment plans
+         */
+        listTreatmentPlans: (connectorId: string, workspaceId: string, patientId: string, options?: RequestOptions) => Promise<FullscriptTreatmentPlan[]>;
+        /**
+         * Get treatment plan details including recommendations.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param treatmentPlanId - The Fullscript treatment plan ID.
+         * @param options - Optional request options.
+         * @returns The `FullscriptTreatmentPlan` with recommendation details.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const plan = await client.connectors.fullscript.getTreatmentPlan(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'tp_456',
+         * );
+         * console.log(plan.state, plan.recommendations);
+         * ```
+         */
+        getTreatmentPlan: (connectorId: string, workspaceId: string, treatmentPlanId: string, options?: RequestOptions) => Promise<FullscriptTreatmentPlan>;
+        /**
+         * Cancel an active treatment plan.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param treatmentPlanId - The Fullscript treatment plan ID to cancel.
+         * @param options - Optional request options.
+         * @returns The cancelled `FullscriptTreatmentPlan` with updated state.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const cancelled = await client.connectors.fullscript.cancelTreatmentPlan(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'tp_456',
+         * );
+         * console.log(cancelled.state); // "cancelled"
+         * ```
+         */
+        cancelTreatmentPlan: (connectorId: string, workspaceId: string, treatmentPlanId: string, options?: RequestOptions) => Promise<FullscriptTreatmentPlan>;
+        /**
+         * Create a treatment plan in Fullscript with product recommendations.
+         *
+         * @param connectorId - The Fullscript connector instance ID
+         * @param workspaceId - The workspace ID
+         * @param attrs - Treatment plan creation attributes
+         * @param options - Optional request options.
+         * @returns The created {@link FullscriptTreatmentPlan}.
+         *
+         * @example
+         * ```typescript
+         * const plan = await client.connectors.fullscript.createTreatmentPlan(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   {
+         *     patient_id: 'fs_pat_456',
+         *     recommendations: [{ product_id: 'prod_1', dosage: '1 cap daily' }],
+         *     send_invitation: true,
+         *     message: 'Please take as directed',
+         *   },
+         * );
+         * ```
+         */
+        createTreatmentPlan: (connectorId: string, workspaceId: string, attrs: CreateTreatmentPlanAttributes, options?: RequestOptions) => Promise<FullscriptTreatmentPlan>;
+        /**
+         * Match AI-generated supplement names to Fullscript products.
+         *
+         * @param connectorId - The Fullscript connector instance ID
+         * @param workspaceId - The workspace ID
+         * @param queries - Array of product match queries
+         * @param options - Optional request options.
+         * @returns Array of {@link ProductMatchResult} with matched products per query.
+         *
+         * @example
+         * ```typescript
+         * const results = await client.connectors.fullscript.matchProducts(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   [{ name: 'Vitamin D3 2000 IU', form: 'capsule' }],
+         * );
+         * ```
+         */
+        matchProducts: (connectorId: string, workspaceId: string, queries: ProductMatchQuery[], options?: RequestOptions) => Promise<ProductMatchResult[]>;
+        /**
+         * Search the Fullscript product catalog by keyword query.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param query - Search keyword (e.g., `"vitamin D"`, `"omega 3"`).
+         * @param options - Optional request options.
+         * @returns An array of matching `FullscriptProduct` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const products = await client.connectors.fullscript.searchProducts(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'vitamin D',
+         * );
+         * products.forEach(p => console.log(p.name, p.brand));
+         * ```
+         */
+        searchProducts: (connectorId: string, workspaceId: string, query: string, options?: RequestOptions) => Promise<FullscriptProduct[]>;
+        /**
+         * Get full product details from the Fullscript catalog by product ID.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param productId - The Fullscript product ID.
+         * @param options - Optional request options.
+         * @returns The `FullscriptProduct` with full details.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const product = await client.connectors.fullscript.getProduct(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'prod_789',
+         * );
+         * console.log(product.name, product.brand);
+         * ```
+         */
+        getProduct: (connectorId: string, workspaceId: string, productId: string, options?: RequestOptions) => Promise<FullscriptProduct>;
+        /**
+         * List similar products curated by Fullscript's health professionals.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param productId - The Fullscript product ID to find similar products for.
+         * @param options - Optional request options.
+         * @returns An array of similar `FullscriptProduct` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const similar = await client.connectors.fullscript.listSimilarProducts(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'prod_789',
+         * );
+         * similar.forEach(p => console.log(p.name));
+         * ```
+         */
+        listSimilarProducts: (connectorId: string, workspaceId: string, productId: string, options?: RequestOptions) => Promise<FullscriptProduct[]>;
+        /**
+         * List all orders for a patient in Fullscript.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param patientId - The Fullscript patient ID.
+         * @param options - Optional request options.
+         * @returns An array of `FullscriptOrder` records for the patient.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const orders = await client.connectors.fullscript.listPatientOrders(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'fs_patient_456',
+         * );
+         * orders.forEach(o => console.log(o.id, o.payment_total));
+         * ```
+         */
+        listPatientOrders: (connectorId: string, workspaceId: string, patientId: string, options?: RequestOptions) => Promise<FullscriptOrder[]>;
+        /**
+         * Get order details from Fullscript by order ID.
+         *
+         * @param connectorId - UUID of the Fullscript `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param orderId - The Fullscript order ID.
+         * @param options - Optional request options.
+         * @returns The `FullscriptOrder` with line items and totals.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const order = await client.connectors.fullscript.getOrder(
+         *   'ci_fs_123',
+         *   'ws_abc123',
+         *   'ord_789',
+         * );
+         * console.log(order.payment_total, order.line_items);
+         * ```
+         */
+        getOrder: (connectorId: string, workspaceId: string, orderId: string, options?: RequestOptions) => Promise<FullscriptOrder>;
+        /**
+         * Fullscript-specific OAuth helpers.
+         *
+         * Convenience wrappers around the generic `oauth.connect` / `oauth.callback`
+         * flow, pre-configured for `connector_type: "fullscript"`.
+         */
+        oauth: {
+            /**
+             * Get the Fullscript OAuth authorization URL.
+             *
+             * Redirects the user to Fullscript's authorization page where they
+             * grant access to their practitioner account. Store the returned
+             * `state` in the session for CSRF verification.
+             *
+             * @param workspaceId - UUID of the workspace to associate the credential with.
+             * @param options - Optional request options.
+             * @returns An `OAuthInitiateResult` with `auth_url` and `state`.
+             *
+             * @example
+             * ```typescript
+             * const client = new GptClient({ apiKey: 'sk_app_...' });
+             * const { auth_url, state } = await client.connectors.fullscript.oauth.connect(
+             *   'ws_abc123',
+             * );
+             * sessionStorage.setItem('oauth_state', state);
+             * window.location.href = auth_url;
+             * ```
+             */
+            connect: (workspaceId: string, options?: RequestOptions) => Promise<OAuthInitiateResult>;
+            /**
+             * Exchange a Fullscript OAuth authorization code for a stored credential.
+             *
+             * Called from your OAuth redirect handler. Verifies `state`, exchanges
+             * `code` for Fullscript tokens, and creates or updates the `Credential`
+             * record. Returns the resulting `ConnectorInstance`.
+             *
+             * Pass `redirectUri` if a custom redirect URI was used in `connect` — it
+             * must exactly match the URI registered with Fullscript and sent during
+             * authorization.
+             *
+             * @param code - The authorization code from the Fullscript redirect.
+             * @param state - The CSRF state token from the redirect query string.
+             * @param workspaceId - UUID of the workspace (same as passed to `connect`).
+             * @param redirectUri - Optional custom redirect URI, if used during `connect`.
+             * @param options - Optional request options.
+             * @returns The `ConnectorInstance` linked to the new Fullscript credential.
+             *
+             * @example
+             * ```typescript
+             * const client = new GptClient({ apiKey: 'sk_app_...' });
+             * const params = new URLSearchParams(window.location.search);
+             * const instance = await client.connectors.fullscript.oauth.callback(
+             *   params.get('code')!,
+             *   params.get('state')!,
+             *   'ws_abc123',
+             * );
+             * console.log('Fullscript connected:', instance.id);
+             * ```
+             */
+            callback: (code: string, state: string, workspaceId: string, redirectUri?: string, options?: RequestOptions) => Promise<ConnectorInstance>;
+        };
+    };
+    /**
+     * Practice Better — clinical note push for linked PB contacts.
+     *
+     * Requires an active `ConnectorInstance` with `connector_type: "practice-better"`
+     * and stored credentials. The contact must have an `integration_link` custom entity
+     * linking them to a PB client record.
+     */
+    practiceBetter: {
+        /**
+         * Push an AI-generated clinical note to Practice Better for a linked contact.
+         *
+         * @param connectorInstanceId - UUID of the PB `ConnectorInstance`.
+         * @param params - Note parameters including workspace_id, contact_id, note_content.
+         * @param options - Optional request options.
+         * @returns The PB API response map.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const result = await client.connectors.practiceBetter.pushNote(
+         *   'ci_pb_123',
+         *   {
+         *     workspace_id: 'ws_abc123',
+         *     contact_id: 'contact_456',
+         *     note_content: 'Session notes: Patient reported improved energy...',
+         *     note_type: 'clinical',
+         *   },
+         * );
+         * ```
+         */
+        pushNote: (connectorInstanceId: string, params: PBPushNoteParams, options?: RequestOptions) => Promise<Record<string, unknown>>;
+    };
+    /**
+     * Healthie EHR connector — patient and appointment sync.
+     *
+     * Provides typed methods for listing and syncing patient records and appointments
+     * from Healthie EHR. Requires an active `ConnectorInstance` with `connector_type:
+     * "healthie"` and a linked OAuth `Credential`.
+     *
+     * Typical flow:
+     * 1. Authorize via OAuth using `oauth.connect('healthie', workspaceId)`.
+     * 2. Check sync status with `healthie.getStatus(connectorId, workspaceId)`.
+     * 3. List patients or appointments, optionally filtering by date.
+     * 4. Trigger incremental or full syncs as needed.
+     */
+    healthie: {
+        /**
+         * List patient records from Healthie EHR.
+         *
+         * Returns all patients from the Healthie account linked to the connector.
+         * Optionally filter by `since` date to only get patients modified since
+         * a given timestamp.
+         *
+         * @param connectorId - UUID of the Healthie `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param options - Optional list parameters including `since` (Date) filter.
+         * @param requestOptions - Optional request options.
+         * @returns An array of `HealthiePatient` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const patients = await client.connectors.healthie.listPatients(
+         *   'ci_healthie_123',
+         *   'ws_abc123',
+         *   { since: new Date('2025-01-01') },
+         * );
+         * patients.forEach(p => console.log(p.first_name, p.last_name));
+         * ```
+         */
+        listPatients: (connectorId: string, workspaceId: string, options?: HealthieListOptions & RequestOptions) => Promise<HealthiePatient[]>;
+        /**
+         * Trigger a patient sync from Healthie EHR.
+         *
+         * Fetches patient records from Healthie and updates the local cache.
+         * Returns a summary of sync statistics.
+         *
+         * @param connectorId - UUID of the Healthie `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param requestOptions - Optional request options.
+         * @returns A `HealthieSyncResult` with sync count and any errors.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const result = await client.connectors.healthie.syncPatients(
+         *   'ci_healthie_123',
+         *   'ws_abc123',
+         * );
+         * console.log(`Synced ${result.synced} patients`);
+         * ```
+         */
+        syncPatients: (connectorId: string, workspaceId: string, requestOptions?: RequestOptions) => Promise<HealthieSyncResult>;
+        /**
+         * List appointment records from Healthie EHR.
+         *
+         * Returns all appointments from the Healthie account linked to the connector.
+         * Optionally filter by `since` date to only get appointments modified since
+         * a given timestamp.
+         *
+         * @param connectorId - UUID of the Healthie `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param options - Optional list parameters including `since` (Date) filter.
+         * @param requestOptions - Optional request options.
+         * @returns An array of `HealthieAppointment` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const appointments = await client.connectors.healthie.listAppointments(
+         *   'ci_healthie_123',
+         *   'ws_abc123',
+         *   { since: new Date('2025-01-01') },
+         * );
+         * appointments.forEach(a => console.log(a.date, a.status));
+         * ```
+         */
+        listAppointments: (connectorId: string, workspaceId: string, options?: HealthieListOptions & RequestOptions) => Promise<HealthieAppointment[]>;
+        /**
+         * Trigger an appointment sync from Healthie EHR.
+         *
+         * Fetches appointment records from Healthie and updates the local cache.
+         * Returns a summary of sync statistics.
+         *
+         * @param connectorId - UUID of the Healthie `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param requestOptions - Optional request options.
+         * @returns A `HealthieSyncResult` with sync count and any errors.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const result = await client.connectors.healthie.syncAppointments(
+         *   'ci_healthie_123',
+         *   'ws_abc123',
+         * );
+         * console.log(`Synced ${result.synced} appointments`);
+         * ```
+         */
+        syncAppointments: (connectorId: string, workspaceId: string, requestOptions?: RequestOptions) => Promise<HealthieSyncResult>;
+        /**
+         * Trigger a full sync of both patients and appointments from Healthie EHR.
+         *
+         * Fetches all patient and appointment records from Healthie and updates
+         * the local cache. Returns a summary of sync statistics for both types.
+         *
+         * @param connectorId - UUID of the Healthie `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param requestOptions - Optional request options.
+         * @returns A `HealthieSyncAllResult` with patient and appointment sync counts.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const result = await client.connectors.healthie.syncAll(
+         *   'ci_healthie_123',
+         *   'ws_abc123',
+         * );
+         * console.log(`Synced ${result.patients_synced} patients, ${result.appointments_synced} appointments`);
+         * ```
+         */
+        syncAll: (connectorId: string, workspaceId: string, requestOptions?: RequestOptions) => Promise<HealthieSyncAllResult>;
+        /**
+         * Get the current sync status for the Healthie connector.
+         *
+         * Returns summary statistics about the last sync, including patient
+         * and appointment counts, last sync timestamp, and any errors.
+         *
+         * @param connectorId - UUID of the Healthie `ConnectorInstance`.
+         * @param workspaceId - UUID of the current workspace.
+         * @param requestOptions - Optional request options.
+         * @returns A `HealthieSyncStatus` object with sync statistics.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const status = await client.connectors.healthie.getStatus(
+         *   'ci_healthie_123',
+         *   'ws_abc123',
+         * );
+         * console.log(`Last synced: ${status.last_synced_at}`);
+         * console.log(`Patients: ${status.patient_count}, Appointments: ${status.appointment_count}`);
+         * ```
+         */
+        getStatus: (connectorId: string, workspaceId: string, requestOptions?: RequestOptions) => Promise<HealthieSyncStatus>;
+    };
+};
+//# sourceMappingURL=connectors.d.ts.map