@gpt-platform/client 0.10.4 → 0.11.0

package/dist/namespaces/crm.d.ts

@@ -0,0 +1,1539 @@
+import type { CrmContact, CrmCompany, CrmDeal, CrmActivity, CrmPipeline, CrmPipelineStage, CrmRelationship, CrmRelationshipType, CrmCustomEntity } from "../_internal/types.gen";
+/** Attributes accepted when creating a CRM contact. */
+export type CreateCrmContactAttributes = {
+    workspace_id: string;
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    phone?: string;
+    title?: string;
+    date_of_birth?: string;
+    sex?: "male" | "female" | "other";
+    lifecycle_stage?: string;
+    source?: string;
+    owner_id?: string;
+    avatar_url?: string;
+    properties?: Record<string, unknown>;
+    tags?: string[];
+    portal_user_id?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a CRM contact (PATCH semantics). */
+export type UpdateCrmContactAttributes = {
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    phone?: string;
+    title?: string;
+    date_of_birth?: string;
+    sex?: "male" | "female" | "other";
+    lifecycle_stage?: string;
+    owner_id?: string;
+    avatar_url?: string;
+    properties?: Record<string, unknown>;
+    tags?: string[];
+    portal_user_id?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a CRM company. */
+export type CreateCrmCompanyAttributes = {
+    workspace_id: string;
+    name: string;
+    domain?: string;
+    industry?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a CRM company (PATCH semantics). */
+export type UpdateCrmCompanyAttributes = {
+    name?: string;
+    domain?: string;
+    industry?: string;
+    employee_count?: number;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a CRM deal. */
+export type CreateCrmDealAttributes = {
+    workspace_id: string;
+    name: string;
+    value_cents?: number;
+    pipeline_id?: string;
+    stage_id?: string;
+    close_date?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a CRM deal (PATCH semantics). */
+export type UpdateCrmDealAttributes = {
+    name?: string;
+    value_cents?: number;
+    stage_id?: string;
+    closed_at?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a CRM activity. */
+export type CreateCrmActivityAttributes = {
+    activity_type: string;
+    contact_id?: string;
+    deal_id?: string;
+    note?: string;
+    occurred_at?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a CRM pipeline. */
+export type CreateCrmPipelineAttributes = {
+    workspace_id: string;
+    name: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a CRM pipeline (PATCH semantics). */
+export type UpdateCrmPipelineAttributes = {
+    name?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a pipeline stage. */
+export type CreateCrmPipelineStageAttributes = {
+    pipeline_id: string;
+    name: string;
+    order?: number;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a pipeline stage (PATCH semantics). */
+export type UpdateCrmPipelineStageAttributes = {
+    name?: string;
+    order?: number;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a relationship type. */
+export type CreateCrmRelationshipTypeAttributes = {
+    label: string;
+    inverse_label?: string;
+    from_entity_type: string;
+    to_entity_type: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a relationship type (PATCH semantics). */
+export type UpdateCrmRelationshipTypeAttributes = {
+    label?: string;
+    inverse_label?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a relationship. */
+export type CreateCrmRelationshipAttributes = {
+    relationship_type_id: string;
+    from_entity_type: string;
+    from_entity_id: string;
+    to_entity_type: string;
+    to_entity_id: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a custom entity. */
+export type CreateCrmCustomEntityAttributes = {
+    workspace_id: string;
+    entity_type: string;
+    properties?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a custom entity (PATCH semantics). */
+export type UpdateCrmCustomEntityAttributes = {
+    properties?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+export type CrmEntityType = "contact" | "custom_entity" | "activity";
+export type CrmExportFormat = "json" | "csv";
+export type CrmExportStatus = "pending" | "processing" | "complete" | "failed";
+export interface CrmDataExportJob {
+    id: string;
+    workspace_id: string;
+    entity_type: CrmEntityType;
+    entity_subtype?: string;
+    format: CrmExportFormat;
+    include: string[];
+    status: CrmExportStatus;
+    file_url?: string;
+    url_expires_at?: string;
+    row_count?: number;
+    error?: string;
+    inserted_at: string;
+    updated_at: string;
+}
+export interface CrmExportCreateParams {
+    entityType: CrmEntityType;
+    entitySubtype?: string;
+    format: CrmExportFormat;
+    /**
+     * Relationship types to embed in contact exports. Valid include keys are
+     * determined by your application's CustomEntityType records (via `include_alias`)
+     * and AiConfig `export_activity_includes` mapping.
+     *
+     * Example: if you have a CustomEntityType with `include_alias: "goals"` and
+     * AiConfig with `export_activity_includes: {"health_metric": "metrics"}`,
+     * then `include: ["goals", "metrics"]` embeds both.
+     *
+     * Only supported when `entityType` is `"contact"`.
+     */
+    include?: string[];
+    filters?: AttributeFilter[];
+}
+export type FilterOperator = "eq" | "not_eq" | "contains" | "in" | "lt" | "gt" | "not_null";
+export interface AttributeFilter {
+    field: string;
+    op: FilterOperator;
+    value?: unknown;
+}
+export interface AggregateMetric {
+    fn: "count";
+}
+export interface AggregateFieldMetric {
+    fn: "avg" | "sum";
+    field: string;
+}
+/**
+ * A version snapshot of a CrmCustomEntity.
+ * Field names match the CustomEntityVersion Ash resource attributes exactly.
+ */
+export interface CrmCustomEntityVersion {
+    id: string;
+    version_number: number;
+    /** Snapshot of the entity's properties field at the time of the update. */
+    attributes: Record<string, unknown>;
+    updated_by_user_id?: string;
+    /** ISO 8601 timestamp — the resource uses inserted_at (no updated_at). */
+    inserted_at: string;
+    custom_entity_id: string;
+    workspace_id: string;
+}
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+/**
+ * CRM namespace for contacts, companies, deals, activities, and pipelines.
+ *
+ * Provides sub-namespaces covering the full CRM entity graph: contacts
+ * (people / leads), companies (organisations), deals (opportunities tracked
+ * through pipeline stages), activities (interactions and notes), pipelines
+ * (workflow definitions), pipeline stages, relationship types, relationships
+ * (edges between any two CRM entities), custom entities (ISV-defined entity
+ * types), and async data exports.
+ *
+ * @example
+ * ```typescript
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ *
+ * // Create a contact and immediately associate them with a company
+ * const contact = await client.crm.contacts.create({
+ *   workspace_id: 'ws_abc123',
+ *   first_name: 'Jane',
+ *   last_name: 'Smith',
+ *   email: 'jane@example.com',
+ * });
+ *
+ * const company = await client.crm.companies.get('co_xyz');
+ *
+ * await client.crm.relationships.create({
+ *   workspace_id: 'ws_abc123',
+ *   from_entity_type: 'contact',
+ *   from_entity_id: contact.id,
+ *   to_entity_type: 'company',
+ *   to_entity_id: company.id,
+ *   relationship_type_id: 'reltype_employee',
+ * });
+ * ```
+ */
+export declare function createCrmNamespace(rb: RequestBuilder): {
+    /**
+     * Contacts — people and leads in the CRM.
+     *
+     * Contacts represent individual people tracked through your sales or
+     * marketing funnel. They progress through lifecycle statuses from `lead`
+     * through to `customer` or `churned`. Contacts support soft-delete
+     * semantics via `archive` / `unarchive` in addition to permanent `delete`.
+     */
+    contacts: {
+        /**
+         * Fetch a single contact by their unique ID.
+         *
+         * @param id - The unique identifier of the contact to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmContact}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const contact = await client.crm.contacts.get('con_abc123');
+         * console.log(contact.attributes.email);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmContact>;
+        /**
+         * Create a new contact in the CRM.
+         *
+         * @param attributes - Key/value map of contact attributes. Must include
+         *   `workspace_id`. Common fields include `first_name`, `last_name`,
+         *   `email`, `phone`, and `status`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmContact}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const contact = await client.crm.contacts.create({
+         *   workspace_id: 'ws_abc123',
+         *   first_name: 'Jane',
+         *   last_name: 'Smith',
+         *   email: 'jane@example.com',
+         *   status: 'lead',
+         * });
+         * console.log(contact.id); // 'con_...'
+         * ```
+         */
+        create: (attributes: CreateCrmContactAttributes, options?: RequestOptions) => Promise<CrmContact>;
+        /**
+         * Update an existing contact's attributes.
+         *
+         * Only the fields present in `attributes` are changed (PATCH semantics).
+         *
+         * @param id - The unique identifier of the contact to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmContact}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const contact = await client.crm.contacts.update('con_abc123', {
+         *   status: 'customer',
+         *   tags: ['vip', 'enterprise'],
+         * });
+         * console.log(contact.attributes.status); // 'customer'
+         * ```
+         */
+        update: (id: string, attributes: UpdateCrmContactAttributes, options?: RequestOptions) => Promise<CrmContact>;
+        /**
+         * Permanently delete a contact.
+         *
+         * This is an irreversible hard delete. For recoverable removal, prefer
+         * {@link archive} instead.
+         *
+         * @param id - The unique identifier of the contact to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.contacts.delete('con_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List active (non-archived) contacts in a workspace.
+         *
+         * Supports filtering by lifecycle `status`, arbitrary attribute filters
+         * using {@link AttributeFilter} predicates, and tag-based filtering.
+         * Paginate large result sets with `page` and `pageSize`.
+         *
+         * @param workspaceId - The ID of the workspace to list contacts from.
+         * @param options - Optional filters and pagination:
+         *   - `status` — restrict to a specific lifecycle stage.
+         *   - `filters` — array of {@link AttributeFilter} predicates applied
+         *     server-side to the contact's attribute map.
+         *   - `tags` — return contacts that have ANY of the given tags (overlap match).
+         *   - `page` / `pageSize` — pagination controls.
+         * @returns A promise that resolves to an array of {@link CrmContact} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * // All qualified leads tagged as 'enterprise'
+         * const leads = await client.crm.contacts.listByWorkspace('ws_abc123', {
+         *   status: 'sales_qualified',
+         *   tags: ['enterprise'],
+         *   pageSize: 50,
+         * });
+         *
+         * // Contacts with a deal value over $10,000
+         * const highValue = await client.crm.contacts.listByWorkspace('ws_abc123', {
+         *   filters: [{ field: 'deal_value', op: 'gt', value: 10000 }],
+         * });
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            name?: string;
+            status?: "lead" | "marketing_qualified" | "sales_qualified" | "opportunity" | "customer" | "evangelist" | "churned";
+            filters?: AttributeFilter[];
+            tags?: string[];
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<CrmContact[]>;
+        /**
+         * Archive a contact (soft-delete with restore semantics).
+         *
+         * Archived contacts are hidden from normal list results but are not
+         * permanently deleted. They can be recovered at any time with
+         * {@link unarchive}. Use this in preference to {@link delete} when you
+         * may need to restore the contact later.
+         *
+         * @param id - The unique identifier of the contact to archive.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmContact} with
+         *   its archived status reflected.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const contact = await client.crm.contacts.archive('con_abc123');
+         * console.log(contact.attributes.archived); // true
+         * ```
+         */
+        archive: (id: string, options?: RequestOptions) => Promise<CrmContact>;
+        /**
+         * Restore a previously archived contact.
+         *
+         * Makes the contact visible in normal list results again and clears the
+         * archived flag.
+         *
+         * @param id - The unique identifier of the archived contact to restore.
+         * @param workspaceId - The workspace that owns the contact. Required to scope the restore
+         *   to the correct workspace and prevent cross-workspace data access.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the restored {@link CrmContact}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const contact = await client.crm.contacts.unarchive('con_abc123', 'ws_xyz789');
+         * console.log(contact.attributes.archived); // false
+         * ```
+         */
+        unarchive: (id: string, workspaceId: string, options?: RequestOptions) => Promise<CrmContact>;
+        /**
+         * List archived (soft-deleted) contacts for a workspace.
+         *
+         * Returns only contacts that have been archived via {@link archive}.
+         * Permanently deleted contacts are not included.
+         *
+         * @param workspaceId - The ID of the workspace to query.
+         * @param options - Optional pagination controls and request-level overrides.
+         * @returns A promise that resolves to an array of archived {@link CrmContact} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const archived = await client.crm.contacts.listArchived('ws_abc123', {
+         *   page: 1,
+         *   pageSize: 25,
+         * });
+         * console.log(`${archived.length} archived contacts`);
+         * ```
+         */
+        listArchived: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<CrmContact[]>;
+    };
+    /**
+     * Companies — organisations in the CRM.
+     *
+     * Companies represent the organisations your contacts belong to. They can
+     * be linked to contacts via the {@link relationships} namespace and
+     * associated with deals through pipeline stages.
+     */
+    companies: {
+        /**
+         * Fetch a single company by its unique ID.
+         *
+         * @param id - The unique identifier of the company to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmCompany}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const company = await client.crm.companies.get('co_abc123');
+         * console.log(company.attributes.name);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmCompany>;
+        /**
+         * Create a new company in the CRM.
+         *
+         * @param attributes - Key/value map of company attributes. Must include
+         *   `workspace_id`. Common fields include `name`, `domain`, `industry`,
+         *   and `employee_count`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmCompany}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const company = await client.crm.companies.create({
+         *   workspace_id: 'ws_abc123',
+         *   name: 'Acme Corp',
+         *   domain: 'acme.com',
+         *   industry: 'Technology',
+         * });
+         * console.log(company.id); // 'co_...'
+         * ```
+         */
+        create: (attributes: CreateCrmCompanyAttributes, options?: RequestOptions) => Promise<CrmCompany>;
+        /**
+         * Update an existing company's attributes.
+         *
+         * Only the fields present in `attributes` are changed (PATCH semantics).
+         *
+         * @param id - The unique identifier of the company to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmCompany}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const company = await client.crm.companies.update('co_abc123', {
+         *   employee_count: 500,
+         *   plan: 'enterprise',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateCrmCompanyAttributes, options?: RequestOptions) => Promise<CrmCompany>;
+        /**
+         * Permanently delete a company.
+         *
+         * @param id - The unique identifier of the company to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.companies.delete('co_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List companies in a workspace with optional pagination.
+         *
+         * @param workspaceId - The ID of the workspace to list companies from.
+         * @param options - Optional pagination controls (`page`, `pageSize`) and
+         *   request-level overrides.
+         * @returns A promise that resolves to an array of {@link CrmCompany} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const companies = await client.crm.companies.listByWorkspace('ws_abc123', {
+         *   pageSize: 100,
+         * });
+         * console.log(companies.map((c) => c.attributes.name));
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<CrmCompany[]>;
+    };
+    /**
+     * Deals — sales opportunities tracked through pipeline stages.
+     *
+     * A deal represents a potential revenue opportunity associated with one or
+     * more contacts or companies. Deals move through the stages of a
+     * {@link pipelines pipeline} (e.g. Prospecting → Proposal → Closed Won).
+     */
+    deals: {
+        /**
+         * Fetch a single deal by its unique ID.
+         *
+         * @param id - The unique identifier of the deal to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmDeal}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const deal = await client.crm.deals.get('deal_abc123');
+         * console.log(deal.attributes.value_cents, deal.attributes.stage_id);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmDeal>;
+        /**
+         * Create a new deal.
+         *
+         * @param attributes - Key/value map of deal attributes. Must include
+         *   `workspace_id`. Common fields include `name`, `value_cents`,
+         *   `pipeline_id`, `stage_id`, and `close_date`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmDeal}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const deal = await client.crm.deals.create({
+         *   workspace_id: 'ws_abc123',
+         *   name: 'Enterprise License — Acme Corp',
+         *   value_cents: 1200000,
+         *   pipeline_id: 'pipe_sales',
+         *   stage_id: 'stage_proposal',
+         *   close_date: '2026-06-30',
+         * });
+         * console.log(deal.id); // 'deal_...'
+         * ```
+         */
+        create: (attributes: CreateCrmDealAttributes, options?: RequestOptions) => Promise<CrmDeal>;
+        /**
+         * Update an existing deal's attributes.
+         *
+         * Commonly used to advance a deal through pipeline stages by updating
+         * `stage_id`, or to record the final outcome via a `status` field.
+         *
+         * @param id - The unique identifier of the deal to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmDeal}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * // Advance to next stage
+         * const deal = await client.crm.deals.update('deal_abc123', {
+         *   stage_id: 'stage_closed_won',
+         *   closed_at: new Date().toISOString(),
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateCrmDealAttributes, options?: RequestOptions) => Promise<CrmDeal>;
+        /**
+         * Move a deal to a different pipeline stage.
+         *
+         * @param id - The unique identifier of the deal to move.
+         * @param attributes - Must include `stage_id` (the target stage).
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmDeal}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const deal = await client.crm.deals.moveStage('deal_abc123', {
+         *   stage_id: 'stage_closed_won',
+         * });
+         * ```
+         */
+        moveStage: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<CrmDeal>;
+        /**
+         * Permanently delete a deal.
+         *
+         * @param id - The unique identifier of the deal to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.deals.delete('deal_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List deals in a workspace with optional pagination.
+         *
+         * @param workspaceId - The ID of the workspace to list deals from.
+         * @param options - Optional pagination controls and request-level overrides.
+         * @returns A promise that resolves to an array of {@link CrmDeal} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const deals = await client.crm.deals.listByWorkspace('ws_abc123', {
+         *   page: 1,
+         *   pageSize: 50,
+         * });
+         * const total = deals.reduce((sum, d) => sum + (d.attributes.value_cents ?? 0), 0);
+         * console.log(`Pipeline value: $${total / 100}`);
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<CrmDeal[]>;
+    };
+    /**
+     * Activities — interactions and notes logged against CRM entities.
+     *
+     * Activities capture touchpoints such as calls, emails, meetings, and
+     * notes. They can be linked to contacts, companies, or deals to build a
+     * chronological engagement timeline.
+     */
+    activities: {
+        /**
+         * Fetch a single activity by its unique ID.
+         *
+         * @param id - The unique identifier of the activity to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmActivity}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const activity = await client.crm.activities.get('act_abc123');
+         * console.log(activity.attributes.type, activity.attributes.note);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmActivity>;
+        /**
+         * Create a new activity.
+         *
+         * @param attributes - Key/value map of activity attributes. Must include
+         *   `workspace_id` and `type` (e.g. `"call"`, `"email"`, `"meeting"`,
+         *   `"note"`). Optionally include `contact_id`, `company_id`, or
+         *   `deal_id` to link the activity to other CRM entities.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmActivity}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const activity = await client.crm.activities.create({
+         *   workspace_id: 'ws_abc123',
+         *   type: 'call',
+         *   contact_id: 'con_xyz',
+         *   deal_id: 'deal_abc123',
+         *   note: 'Discussed pricing. Follow up next week.',
+         *   occurred_at: new Date().toISOString(),
+         * });
+         * ```
+         */
+        create: (attributes: CreateCrmActivityAttributes, options?: RequestOptions) => Promise<CrmActivity>;
+        /**
+         * Update an existing activity's attributes.
+         *
+         * @param id - The unique identifier of the activity to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmActivity}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const activity = await client.crm.activities.update('act_abc123', {
+         *   note: 'Updated notes from follow-up call.',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<CrmActivity>;
+        /**
+         * Permanently delete an activity.
+         *
+         * @param id - The unique identifier of the activity to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.activities.delete('act_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List activities in a workspace with optional pagination.
+         *
+         * @param workspaceId - The ID of the workspace to list activities from.
+         * @param options - Optional pagination controls and request-level overrides.
+         * @returns A promise that resolves to an array of {@link CrmActivity} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const recentActivities = await client.crm.activities.listByWorkspace('ws_abc123', {
+         *   pageSize: 20,
+         * });
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<CrmActivity[]>;
+    };
+    /**
+     * Pipelines — deal workflow stage definitions.
+     *
+     * A pipeline defines the stages that deals progress through (e.g.
+     * "Inbound Sales", "Enterprise Sales"). Each pipeline has an ordered set
+     * of stages managed via {@link pipelineStages}.
+     */
+    pipelines: {
+        /**
+         * Fetch a single pipeline by its unique ID.
+         *
+         * @param id - The unique identifier of the pipeline to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmPipeline}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const pipeline = await client.crm.pipelines.get('pipe_abc123');
+         * console.log(pipeline.attributes.name);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmPipeline>;
+        /**
+         * Create a new pipeline.
+         *
+         * @param attributes - Key/value map of pipeline attributes. Must include
+         *   `workspace_id` and `name`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmPipeline}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const pipeline = await client.crm.pipelines.create({
+         *   workspace_id: 'ws_abc123',
+         *   name: 'Enterprise Sales',
+         * });
+         * console.log(pipeline.id); // 'pipe_...'
+         * ```
+         */
+        create: (attributes: CreateCrmPipelineAttributes, options?: RequestOptions) => Promise<CrmPipeline>;
+        /**
+         * Update an existing pipeline's attributes.
+         *
+         * @param id - The unique identifier of the pipeline to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmPipeline}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const pipeline = await client.crm.pipelines.update('pipe_abc123', {
+         *   name: 'SMB Sales',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateCrmPipelineAttributes, options?: RequestOptions) => Promise<CrmPipeline>;
+        /**
+         * Permanently delete a pipeline.
+         *
+         * @param id - The unique identifier of the pipeline to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.pipelines.delete('pipe_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List all pipelines in a workspace.
+         *
+         * @param workspaceId - The ID of the workspace to list pipelines from.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to an array of {@link CrmPipeline} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const pipelines = await client.crm.pipelines.listByWorkspace('ws_abc123');
+         * console.log(pipelines.map((p) => p.attributes.name));
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: RequestOptions) => Promise<CrmPipeline[]>;
+    };
+    /**
+     * Pipeline Stages — ordered stages within a pipeline.
+     *
+     * Each stage represents one step a deal can occupy within a pipeline
+     * (e.g. "Prospecting", "Proposal Sent", "Closed Won"). Stages have an
+     * `order` that determines their position in the pipeline flow.
+     */
+    pipelineStages: {
+        /**
+         * Fetch a single pipeline stage by its unique ID.
+         *
+         * @param id - The unique identifier of the stage to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmPipelineStage}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const stage = await client.crm.pipelineStages.get('stage_abc123');
+         * console.log(stage.attributes.name, stage.attributes.order);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmPipelineStage>;
+        /**
+         * Create a new stage within a pipeline.
+         *
+         * @param attributes - Key/value map of stage attributes. Must include
+         *   `pipeline_id`, `name`, and `order`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmPipelineStage}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const stage = await client.crm.pipelineStages.create({
+         *   pipeline_id: 'pipe_abc123',
+         *   name: 'Proposal Sent',
+         *   order: 2,
+         * });
+         * console.log(stage.id); // 'stage_...'
+         * ```
+         */
+        create: (attributes: CreateCrmPipelineStageAttributes, options?: RequestOptions) => Promise<CrmPipelineStage>;
+        /**
+         * Update an existing pipeline stage's attributes.
+         *
+         * @param id - The unique identifier of the stage to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmPipelineStage}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const stage = await client.crm.pipelineStages.update('stage_abc123', {
+         *   name: 'Contract Review',
+         *   order: 3,
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateCrmPipelineStageAttributes, options?: RequestOptions) => Promise<CrmPipelineStage>;
+        /**
+         * Permanently delete a pipeline stage.
+         *
+         * @param id - The unique identifier of the stage to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.pipelineStages.delete('stage_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List all stages belonging to a specific pipeline.
+         *
+         * @param pipelineId - The ID of the pipeline whose stages to list.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to an array of {@link CrmPipelineStage} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const stages = await client.crm.pipelineStages.listByPipeline('pipe_abc123');
+         * stages.forEach((s) => console.log(s.attributes.name, s.attributes.order));
+         * ```
+         */
+        listByPipeline: (pipelineId: string, options?: RequestOptions) => Promise<CrmPipelineStage[]>;
+    };
+    /**
+     * Relationship Types — templates that define allowable relationships between CRM entities.
+     *
+     * A relationship type defines the semantic meaning of an edge in the CRM
+     * graph (e.g. "Employee Of", "Referred By", "Reports To"). Once defined,
+     * instances of that relationship type can be created via {@link relationships}.
+     */
+    relationshipTypes: {
+        /**
+         * Fetch a single relationship type by its unique ID.
+         *
+         * @param id - The unique identifier of the relationship type to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmRelationshipType}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const relType = await client.crm.relationshipTypes.get('reltype_abc123');
+         * console.log(relType.attributes.label); // 'Employee Of'
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmRelationshipType>;
+        /**
+         * Create a new relationship type.
+         *
+         * @param attributes - Key/value map of relationship type attributes.
+         *   Must include `label` (human-readable name) and optionally
+         *   `inverse_label` (the name of the reverse direction of the edge).
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmRelationshipType}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const relType = await client.crm.relationshipTypes.create({
+         *   label: 'Employee Of',
+         *   inverse_label: 'Employs',
+         *   from_entity_type: 'contact',
+         *   to_entity_type: 'company',
+         * });
+         * console.log(relType.id); // 'reltype_...'
+         * ```
+         */
+        create: (attributes: CreateCrmRelationshipTypeAttributes, options?: RequestOptions) => Promise<CrmRelationshipType>;
+        /**
+         * Update an existing relationship type.
+         *
+         * @param id - The unique identifier of the relationship type to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmRelationshipType}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const relType = await client.crm.relationshipTypes.update('reltype_abc123', {
+         *   label: 'Works At',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateCrmRelationshipTypeAttributes, options?: RequestOptions) => Promise<CrmRelationshipType>;
+        /**
+         * Permanently delete a relationship type.
+         *
+         * Deleting a relationship type does not automatically delete the
+         * individual relationship instances that use it.
+         *
+         * @param id - The unique identifier of the relationship type to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.relationshipTypes.delete('reltype_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List all relationship types defined for the authenticated application.
+         *
+         * Relationship types are application-scoped (not workspace-scoped) so
+         * the same type definitions are available across all workspaces.
+         *
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to an array of all {@link CrmRelationshipType} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const types = await client.crm.relationshipTypes.list();
+         * console.log(types.map((t) => t.attributes.label));
+         * ```
+         */
+        list: (options?: RequestOptions) => Promise<CrmRelationshipType[]>;
+    };
+    /**
+     * Relationships — directed edges between CRM entities.
+     *
+     * A relationship is a typed, directed connection between two CRM entities
+     * (contacts, companies, deals, or custom entities). The edge type is
+     * determined by a {@link relationshipTypes relationship type}. For example,
+     * a "Employee Of" relationship edge from a contact to a company.
+     */
+    relationships: {
+        /**
+         * Fetch a single relationship by its unique ID.
+         *
+         * @param id - The unique identifier of the relationship to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmRelationship}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const rel = await client.crm.relationships.get('rel_abc123');
+         * console.log(rel.attributes.from_entity_id, '→', rel.attributes.to_entity_id);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmRelationship>;
+        /**
+         * Create a new relationship between two CRM entities.
+         *
+         * @param attributes - Key/value map of relationship attributes. Must
+         *   include `workspace_id`, `relationship_type_id`, `from_entity_type`,
+         *   `from_entity_id`, `to_entity_type`, and `to_entity_id`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmRelationship}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const rel = await client.crm.relationships.create({
+         *   workspace_id: 'ws_abc123',
+         *   relationship_type_id: 'reltype_employee',
+         *   from_entity_type: 'contact',
+         *   from_entity_id: 'con_jane',
+         *   to_entity_type: 'company',
+         *   to_entity_id: 'co_acme',
+         * });
+         * console.log(rel.id); // 'rel_...'
+         * ```
+         */
+        create: (attributes: CreateCrmRelationshipAttributes, options?: RequestOptions) => Promise<CrmRelationship>;
+        /**
+         * Permanently delete a relationship edge.
+         *
+         * @param id - The unique identifier of the relationship to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.relationships.delete('rel_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List all relationships in a workspace.
+         *
+         * @param workspaceId - The ID of the workspace to list relationships from.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to an array of {@link CrmRelationship} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const rels = await client.crm.relationships.listByWorkspace('ws_abc123');
+         * for (const r of rels) {
+         *   console.log(r.attributes.from_entity_id, '→', r.attributes.to_entity_id);
+         * }
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: RequestOptions) => Promise<CrmRelationship[]>;
+    };
+    /**
+     * Custom Entities — ISV-defined entity types beyond the built-in CRM entities.
+     *
+     * Custom entities allow ISVs to model domain-specific objects within the
+     * CRM (e.g. "Properties" for a real estate app, "Projects" for a services
+     * firm). Each custom entity has a `type` discriminator, a free-form
+     * `properties` map, and full version history accessible via the nested
+     * `versions` sub-namespace.
+     */
+    customEntities: {
+        /**
+         * Fetch a single custom entity by its unique ID.
+         *
+         * @param id - The unique identifier of the custom entity to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link CrmCustomEntity}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const entity = await client.crm.customEntities.get('cen_abc123');
+         * console.log(entity.attributes.type, entity.attributes.properties);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CrmCustomEntity>;
+        /**
+         * Create a new custom entity.
+         *
+         * @param attributes - Key/value map of entity attributes. Must include
+         *   `workspace_id` and `type` (the ISV-defined entity discriminator).
+         *   Include `properties` with your domain-specific fields.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link CrmCustomEntity}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const property = await client.crm.customEntities.create({
+         *   workspace_id: 'ws_abc123',
+         *   type: 'property',
+         *   properties: {
+         *     address: '123 Main St',
+         *     bedrooms: 3,
+         *     price_cents: 49900000,
+         *   },
+         * });
+         * console.log(property.id); // 'cen_...'
+         * ```
+         */
+        create: (attributes: CreateCrmCustomEntityAttributes, options?: RequestOptions) => Promise<CrmCustomEntity>;
+        /**
+         * Update an existing custom entity's attributes.
+         *
+         * Only the fields present in `attributes` are changed (PATCH semantics).
+         * Each update automatically creates a new version snapshot accessible
+         * via {@link customEntities.versions.list}.
+         *
+         * @param id - The unique identifier of the custom entity to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link CrmCustomEntity}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const entity = await client.crm.customEntities.update('cen_abc123', {
+         *   properties: { status: 'under_offer', price_cents: 47500000 },
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateCrmCustomEntityAttributes, options?: RequestOptions) => Promise<CrmCustomEntity>;
+        /**
+         * Permanently delete a custom entity.
+         *
+         * @param id - The unique identifier of the custom entity to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.crm.customEntities.delete('cen_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List custom entities in a workspace with optional type and attribute filters.
+         *
+         * Use `type` to restrict results to a specific ISV-defined entity type,
+         * and `filters` to apply server-side attribute predicates.
+         *
+         * @param workspaceId - The ID of the workspace to list entities from.
+         * @param options - Optional filters and pagination:
+         *   - `type` — restrict to entities of this discriminator type.
+         *   - `filters` — array of {@link AttributeFilter} predicates applied to
+         *     the entity's `properties` map.
+         *   - `page` / `pageSize` — pagination controls.
+         * @returns A promise that resolves to an array of {@link CrmCustomEntity} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * // All properties currently listed for sale
+         * const listings = await client.crm.customEntities.listByWorkspace('ws_abc123', {
+         *   type: 'property',
+         *   filters: [{ field: 'status', op: 'eq', value: 'listed' }],
+         *   pageSize: 50,
+         * });
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            type?: string;
+            filters?: AttributeFilter[];
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<CrmCustomEntity[]>;
+        /**
+         * Batch update multiple custom entities in a single atomic transaction.
+         *
+         * More efficient than issuing individual `update` calls when you need to
+         * change many entities at once. All updates succeed or all fail together.
+         *
+         * @param workspaceId - The ID of the workspace that owns the entities.
+         * @param updates - Array of update objects, each containing the entity
+         *   `id` and the `attributes` map to apply.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to an array of the updated {@link CrmCustomEntity} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const updated = await client.crm.customEntities.batchUpdate('ws_abc123', [
+         *   { id: 'cen_001', attributes: { properties: { status: 'sold' } } },
+         *   { id: 'cen_002', attributes: { properties: { status: 'sold' } } },
+         * ]);
+         * console.log(`${updated.length} entities updated`);
+         * ```
+         */
+        batchUpdate: (workspaceId: string, updates: Array<{
+            id: string;
+            attributes: UpdateCrmCustomEntityAttributes;
+        }>, options?: RequestOptions) => Promise<CrmCustomEntity[]>;
+        /**
+         * Run aggregate queries (count / avg / sum) on custom entity properties.
+         *
+         * Returns one row per distinct value of `group_by` (when provided) or a
+         * single summary row. Useful for building dashboards and reports over
+         * ISV-defined entity data without pulling all records client-side.
+         *
+         * @param workspaceId - The ID of the workspace to aggregate over.
+         * @param params - Aggregation parameters:
+         *   - `type` — restrict to a specific entity discriminator type.
+         *   - `metrics` — one or more {@link AggregateMetric} or
+         *     {@link AggregateFieldMetric} definitions (count, avg, sum).
+         *   - `group_by` — optional property name to group results by.
+         *   - `filters` — optional {@link AttributeFilter} predicates to apply
+         *     before aggregation.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to an array of result rows, each a
+         *   plain object whose keys match the requested metric names plus the
+         *   group_by field (if provided).
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * // Count properties by status
+         * const results = await client.crm.customEntities.aggregate('ws_abc123', {
+         *   type: 'property',
+         *   metrics: [{ fn: 'count' }],
+         *   group_by: 'status',
+         * });
+         * // [{ status: 'listed', count: 42 }, { status: 'sold', count: 18 }]
+         * console.log(results);
+         *
+         * // Average sale price of sold properties
+         * const avgPrice = await client.crm.customEntities.aggregate('ws_abc123', {
+         *   type: 'property',
+         *   metrics: [{ fn: 'avg', field: 'price_cents' }],
+         *   filters: [{ field: 'status', op: 'eq', value: 'sold' }],
+         * });
+         * ```
+         */
+        aggregate: (workspaceId: string, params: {
+            type?: string;
+            metrics: Array<AggregateMetric | AggregateFieldMetric>;
+            group_by?: string;
+            filters?: AttributeFilter[];
+        }, options?: RequestOptions) => Promise<Array<Record<string, unknown>>>;
+        /**
+         * Version history sub-namespace for a custom entity.
+         *
+         * Every time a custom entity is updated, a {@link CrmCustomEntityVersion}
+         * snapshot is automatically created. These snapshots allow you to audit
+         * changes over time and roll back to any prior state.
+         */
+        versions: {
+            /**
+             * List all version snapshots for a custom entity, ordered by
+             * `version_number` descending (most recent first).
+             *
+             * @param entityId - The ID of the custom entity whose history to retrieve.
+             * @param options - Optional pagination controls (`page`, `pageSize`) and
+             *   request-level overrides.
+             * @returns A promise that resolves to a paginated response object
+             *   containing a `data` array of {@link CrmCustomEntityVersion} snapshots
+             *   and optional `meta` pagination metadata.
+             *
+             * @example
+             * ```typescript
+             * const client = new GptClient({ apiKey: 'sk_app_...' });
+             *
+             * const history = await client.crm.customEntities.versions.list('cen_abc123');
+             * for (const v of history.data) {
+             *   console.log(`v${v.version_number} — ${v.inserted_at}`);
+             * }
+             * ```
+             */
+            list: (entityId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & RequestOptions) => Promise<{
+                data: CrmCustomEntityVersion[];
+                meta?: unknown;
+            }>;
+            /**
+             * Fetch a single version snapshot by its ID.
+             *
+             * @param entityId - The ID of the custom entity.
+             * @param versionId - The ID of the specific version snapshot to fetch.
+             * @param options - Optional request-level overrides.
+             * @returns A promise that resolves to the {@link CrmCustomEntityVersion} snapshot.
+             *
+             * @example
+             * ```typescript
+             * const client = new GptClient({ apiKey: 'sk_app_...' });
+             *
+             * const snapshot = await client.crm.customEntities.versions.get(
+             *   'cen_abc123',
+             *   'ver_xyz',
+             * );
+             * console.log(snapshot.version_number, snapshot.attributes);
+             * ```
+             */
+            get: (entityId: string, versionId: string, options?: RequestOptions) => Promise<CrmCustomEntityVersion>;
+            /**
+             * Restore a custom entity to the state captured in a prior version snapshot.
+             *
+             * Creates a new version entry reflecting the rollback so the audit trail
+             * is never broken. The entity's `properties` will match those in the
+             * targeted snapshot after the call completes.
+             *
+             * @param entityId - The ID of the custom entity to restore.
+             * @param versionId - The ID of the version snapshot to restore to.
+             * @param options - Optional request-level overrides.
+             * @returns A promise that resolves to the restored {@link CrmCustomEntity}
+             *   with its properties reverted to the snapshot state.
+             *
+             * @example
+             * ```typescript
+             * const client = new GptClient({ apiKey: 'sk_app_...' });
+             *
+             * // Undo the last change by restoring to the previous version
+             * const history = await client.crm.customEntities.versions.list('cen_abc123');
+             * const previousVersion = history.data[1]; // index 0 is current
+             *
+             * const restored = await client.crm.customEntities.versions.restore(
+             *   'cen_abc123',
+             *   previousVersion.id,
+             * );
+             * console.log('Restored to v' + previousVersion.version_number);
+             * ```
+             */
+            restore: (entityId: string, versionId: string, options?: RequestOptions) => Promise<CrmCustomEntity>;
+        };
+    };
+    /**
+     * CRM data export — create async export jobs and poll for completion.
+     *
+     * Exports are asynchronous. Call `create` to enqueue the job, then poll
+     * `get` until `status === 'complete'`, at which point `file_url` will be
+     * populated with a pre-signed download URL valid for one hour.
+     */
+    export: {
+        /**
+         * Create a new data export job.
+         *
+         * The job is queued and processed asynchronously. The method returns
+         * immediately with a job record in `pending` status. Poll {@link get}
+         * until `status === 'complete'`, then download from `file_url`.
+         *
+         * @param workspaceId - The ID of the workspace to export data from.
+         * @param params - Export configuration:
+         *   - `entityType` — the CRM entity type to export (`"contact"`,
+         *     `"custom_entity"`, or `"activity"`).
+         *   - `entitySubtype` — optional discriminator for custom entity types.
+         *   - `format` — output format (`"json"` or `"csv"`).
+         *   - `include` — optional list of field names to include in the export.
+         *   - `filters` — optional {@link AttributeFilter} predicates to restrict
+         *     which records are exported.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to a {@link CrmDataExportJob} in `pending` status.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const job = await client.crm.export.create('ws_abc123', {
+         *   entityType: 'contact',
+         *   format: 'csv',
+         *   include: ['first_name', 'last_name', 'email', 'status'],
+         *   filters: [{ field: 'status', op: 'eq', value: 'customer' }],
+         * });
+         * console.log(job.id, job.status); // 'export_...', 'pending'
+         * ```
+         */
+        create: (workspaceId: string, params: CrmExportCreateParams, options?: RequestOptions) => Promise<CrmDataExportJob>;
+        /**
+         * Get the current status of an export job by its ID.
+         *
+         * When `status === 'complete'`, the `file_url` field is populated with
+         * a pre-signed download link valid for one hour. When `status === 'failed'`,
+         * the `error` field contains a human-readable description of the failure.
+         *
+         * @param jobId - The ID of the export job to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the {@link CrmDataExportJob} with the latest status.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * // Poll until complete
+         * let job = await client.crm.export.get('export_abc123');
+         * while (job.status === 'pending' || job.status === 'processing') {
+         *   await new Promise((r) => setTimeout(r, 2000));
+         *   job = await client.crm.export.get(job.id);
+         * }
+         *
+         * if (job.status === 'complete' && job.file_url) {
+         *   console.log('Download:', job.file_url);
+         * }
+         * ```
+         */
+        get: (jobId: string, options?: RequestOptions) => Promise<CrmDataExportJob>;
+        /**
+         * List all export jobs for a workspace, most recent first.
+         *
+         * @param workspaceId - The ID of the workspace to list export jobs from.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to an array of {@link CrmDataExportJob} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const jobs = await client.crm.export.list('ws_abc123');
+         * const completed = jobs.filter((j) => j.status === 'complete');
+         * console.log(`${completed.length} completed exports available`);
+         * ```
+         */
+        list: (workspaceId: string, options?: RequestOptions) => Promise<CrmDataExportJob[]>;
+        /**
+         * Regenerate the presigned download URL for a completed export job.
+         * Use when the original URL has expired (1-hour TTL). Only works on
+         * jobs with status 'complete'.
+         *
+         * @param jobId - The export job ID
+         * @returns The updated job with a fresh `file_url` and `url_expires_at`
+         *
+         * @example
+         * ```typescript
+         * const refreshed = await client.crm.export.refreshUrl('export_abc123');
+         * console.log(refreshed.file_url); // new presigned URL
+         * ```
+         */
+        refreshUrl: (jobId: string, options?: RequestOptions) => Promise<CrmDataExportJob>;
+    };
+};
+//# sourceMappingURL=crm.d.ts.map