@forestadmin/datasource-zendesk 1.0.0

package/README.md

@@ -0,0 +1,162 @@
+# @forestadmin/datasource-zendesk
+
+Forest Admin datasource for Zendesk Support, with optional smart-action plugins.
+
+Exposes three collections wired to the Zendesk REST + Search APIs:
+
+| Forest collection       | Zendesk resource | CRUD          | Aggregation     |
+| ----------------------- | ---------------- | ------------- | --------------- |
+| `zendesk_ticket`        | Ticket           | List, create, update, delete | Count only |
+| `zendesk_user`          | User             | List, create, update, delete | Count only |
+| `zendesk_organization`  | Organization     | List, create, update, delete | Count only |
+
+The datasource introspects Zendesk **custom fields** on startup (ticket, user, organization) and registers them as Forest columns.
+
+## Installation
+
+```bash
+yarn add @forestadmin/datasource-zendesk
+```
+
+## Quick start
+
+```ts
+import { createAgent } from '@forestadmin/agent';
+import {
+  createZendeskClient,
+  createZendeskDataSource,
+  closeTicketPlugin,
+  createTicketWithNotificationPlugin,
+} from '@forestadmin/datasource-zendesk';
+
+const zendeskClient = createZendeskClient({
+  subdomain: process.env.ZENDESK_SUBDOMAIN!,
+  email: process.env.ZENDESK_EMAIL!,
+  apiToken: process.env.ZENDESK_API_TOKEN!,
+});
+
+const agent = createAgent({ /* ... */ })
+  .addDataSource(createZendeskDataSource({ client: zendeskClient }))
+
+  // Smart action on Zendesk tickets: Mark as solved / closed.
+  .customizeCollection('zendesk_ticket', collection =>
+    collection.use(closeTicketPlugin, {
+      client: zendeskClient,
+      ticketIdField: 'id',
+    }),
+  )
+
+  // Smart action on ANY collection (here: customers): create a Zendesk ticket
+  // and notify the requester by email.
+  .customizeCollection('customers', collection =>
+    collection.use(createTicketWithNotificationPlugin, {
+      client: zendeskClient,
+      requesterEmailDefault: record => String(record.email ?? ''),
+      defaultSubject: 'Follow-up about your account',
+      ticketIdField: 'last_zendesk_ticket_id',
+    }),
+  );
+```
+
+## Datasource
+
+### `createZendeskDataSource(options)`
+
+`options` accepts either an already-built `client` (recommended when also passing it to plugins) or raw credentials:
+
+```ts
+createZendeskDataSource({ client: createZendeskClient({ subdomain, email, apiToken }) });
+
+// or
+createZendeskDataSource({ subdomain, email, apiToken });
+```
+
+### Filter operators
+
+Zendesk Search supports a restricted set of operators. The datasource exposes:
+
+- `Equal`, `In` for the primary key (`id`), resolved by id lookup outside of Search
+- `Equal`, `NotEqual`, `In`, `NotIn`, `Present`, `Blank` for strings and enums
+- `Equal`, `NotEqual` for booleans
+- `Equal`, `NotEqual`, `In`, `NotIn`, `Present`, `Blank`, `GreaterThan`, `LessThan` for numbers
+- `Equal`, `Before`, `After`, `Present`, `Blank` for dates
+
+Zendesk Search has no `OR` operator. Multi-value membership (`In`/`NotIn`) on the primary key matches each value exactly (id lookup), but on other fields Zendesk ANDs the terms — so `status In ['open', 'pending']` returns nothing. Unsupported operators (`Contains`, `Or` aggregator, …) raise `UnsupportedOperatorError`. The Zendesk Search API caps result pagination at 1000 records — large skips raise the same error.
+
+### Custom fields
+
+On boot, the datasource calls `GET /ticket_fields.json`, `/user_fields.json` and `/organization_fields.json`. Active fields are mapped to Forest columns:
+
+| Zendesk type | Forest column |
+| ------------ | ------------- |
+| `text`, `textarea`, `regexp`, `partialcreditcard` | `String` |
+| `integer`, `decimal`, `lookup` | `Number` |
+| `date` | `Dateonly` |
+| `checkbox` | `Boolean` |
+| `dropdown`, `tagger` | `Enum` (or `String` if no options) |
+| `multiselect` | `Json` |
+
+Ticket custom fields are exposed as `custom_<id>`; user/organization ones use the Zendesk `key`.
+
+## Plugins
+
+Both plugins accept the same client contract as the datasource: pass an
+already-built `client`, **or** raw credentials (`subdomain`, `email`, `apiToken`)
+and the plugin builds one for you. Reusing a single client across the datasource
+and the plugins is recommended, but no longer required.
+
+```ts
+// with a shared client
+collection.use(closeTicketPlugin, { client, ticketIdField: 'id' });
+
+// or with raw credentials (client is optional)
+collection.use(closeTicketPlugin, {
+  subdomain: process.env.ZENDESK_SUBDOMAIN!,
+  email: process.env.ZENDESK_EMAIL!,
+  apiToken: process.env.ZENDESK_API_TOKEN!,
+  ticketIdField: 'id',
+});
+```
+
+### `closeTicketPlugin`
+
+Adds Single + Bulk actions to mark Zendesk tickets as `solved` or `closed`. Tickets that Zendesk reports as already closed are folded into the success message rather than counted as failures.
+
+```ts
+collection.use(closeTicketPlugin, {
+  client,
+  ticketIdField: 'zendesk_id',
+  // optional:
+  statuses: ['solved'],            // default: ['solved', 'closed']
+  scopes: ['Single'],              // default: ['Single', 'Bulk']
+});
+```
+
+### `createTicketWithNotificationPlugin`
+
+Adds a Single action that creates a Zendesk ticket. Useful on a customer-facing collection so an agent can reach out without leaving Forest. With `emailTemplates`, the form becomes two-page (template picker → body).
+
+```ts
+collection.use(createTicketWithNotificationPlugin, {
+  client,
+  actionName: 'Notify customer',                 // optional
+  emailTemplates: [
+    { title: 'Welcome', content: 'Hi {{ record.first_name }}, welcome aboard.' },
+  ],
+  requesterEmailDefault: record => String(record.email ?? ''),
+  defaultSubject: 'Follow-up',
+  priorityOverride: 'normal',                    // hides Priority from the form
+  ticketIdField: 'last_zendesk_ticket_id',       // best-effort writeback after creation
+  showInternalNote: true,                        // adds a "Send as internal note" toggle
+});
+```
+
+Template interpolation supports `{{ record.field }}` (including dotted paths like `{{ record.org.name }}`).
+
+## Errors
+
+All exceptions raised by the datasource are subclasses of Forest Admin's `BusinessError` / `ValidationError`:
+
+- `ZendeskConfigurationError` — missing/invalid client options
+- `ZendeskApiError` — Zendesk HTTP failure (carries the operation, status code and response body)
+- `UnsupportedOperatorError` — filter / aggregation that Zendesk cannot express

package/dist/client/index.d.ts

@@ -0,0 +1,91 @@
+import type { CustomFieldEntry, SearchParams, ZendeskClientOptions, ZendeskRecord, ZendeskResource } from '../types';
+import type { Logger } from '@forestadmin/datasource-toolkit';
+export declare const MAX_PER_PAGE = 100;
+export declare const MAX_TOTAL_RESULTS = 1000;
+export type RawCustomFieldDefinition = {
+    id: number;
+    key?: string;
+    title?: string;
+    raw_title?: string;
+    type: string;
+    active?: boolean;
+    removable?: boolean;
+    custom_field_options?: Array<{
+        value: string;
+        name?: string;
+    }>;
+};
+export type ZendeskClient = {
+    search(type: ZendeskResource, params: SearchParams): Promise<ZendeskRecord[]>;
+    count(type: ZendeskResource, query: string): Promise<number>;
+    findTicket(id: number | string): Promise<ZendeskRecord | null>;
+    findUser(id: number | string): Promise<ZendeskRecord | null>;
+    findOrganization(id: number | string): Promise<ZendeskRecord | null>;
+    fetchTicketsByIds(ids: Array<number | string>): Promise<Map<number, ZendeskRecord>>;
+    fetchUsersByIds(ids: Array<number | string>): Promise<Map<number, ZendeskRecord>>;
+    fetchOrganizationsByIds(ids: Array<number | string>): Promise<Map<number, ZendeskRecord>>;
+    fetchUserEmails(ids: Array<number | string>): Promise<Map<number, string>>;
+    fetchTicketComments(ticketId: number | string): Promise<ZendeskRecord[]>;
+    fetchTicketFields(): Promise<RawCustomFieldDefinition[]>;
+    fetchUserFields(): Promise<RawCustomFieldDefinition[]>;
+    fetchOrganizationFields(): Promise<RawCustomFieldDefinition[]>;
+    createTicket(attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    updateTicket(id: number | string, attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    deleteTicket(id: number | string): Promise<void>;
+    createUser(attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    updateUser(id: number | string, attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    deleteUser(id: number | string): Promise<void>;
+    createOrganization(attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    updateOrganization(id: number | string, attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    deleteOrganization(id: number | string): Promise<void>;
+    readonly baseUrl: string;
+    /**
+     * Best-effort wrapper that logs and returns the default if the action throws.
+     * Used internally and exposed so embedders/plugins can degrade gracefully.
+     */
+    bestEffort<T>(operation: string, defaultValue: T, fn: () => Promise<T>): Promise<T>;
+};
+export declare class ZendeskHttpClient implements ZendeskClient {
+    readonly baseUrl: string;
+    private readonly authHeader;
+    private readonly logger?;
+    constructor(options: ZendeskClientOptions, logger?: Logger);
+    search(type: ZendeskResource, params: SearchParams): Promise<ZendeskRecord[]>;
+    count(type: ZendeskResource, query: string): Promise<number>;
+    findTicket(id: number | string): Promise<ZendeskRecord | null>;
+    findUser(id: number | string): Promise<ZendeskRecord | null>;
+    findOrganization(id: number | string): Promise<ZendeskRecord | null>;
+    fetchTicketsByIds(ids: Array<number | string>): Promise<Map<number, ZendeskRecord>>;
+    fetchUsersByIds(ids: Array<number | string>): Promise<Map<number, ZendeskRecord>>;
+    fetchOrganizationsByIds(ids: Array<number | string>): Promise<Map<number, ZendeskRecord>>;
+    fetchUserEmails(ids: Array<number | string>): Promise<Map<number, string>>;
+    fetchTicketComments(ticketId: number | string): Promise<ZendeskRecord[]>;
+    fetchTicketFields(): Promise<RawCustomFieldDefinition[]>;
+    fetchUserFields(): Promise<RawCustomFieldDefinition[]>;
+    fetchOrganizationFields(): Promise<RawCustomFieldDefinition[]>;
+    createTicket(attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    updateTicket(id: number | string, attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    deleteTicket(id: number | string): Promise<void>;
+    createUser(attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    updateUser(id: number | string, attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    deleteUser(id: number | string): Promise<void>;
+    createOrganization(attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    updateOrganization(id: number | string, attrs: ZendeskRecord): Promise<ZendeskRecord>;
+    deleteOrganization(id: number | string): Promise<void>;
+    bestEffort<T>(operation: string, defaultValue: T, fn: () => Promise<T>): Promise<T>;
+    private findOne;
+    private showMany;
+    private fetchFields;
+    private createOne;
+    private updateOne;
+    private deleteOne;
+    private mustSucceed;
+    private get;
+    private post;
+    private put;
+    private delete;
+    private send;
+}
+export declare function createZendeskClient(options: ZendeskClientOptions, logger?: Logger): ZendeskClient;
+export type { CustomFieldEntry };
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZendeskHttpClient = exports.MAX_TOTAL_RESULTS = exports.MAX_PER_PAGE = void 0;
+exports.createZendeskClient = createZendeskClient;
+const superagent_1 = __importDefault(require("superagent"));
+const errors_1 = require("../errors");
+exports.MAX_PER_PAGE = 100;
+exports.MAX_TOTAL_RESULTS = 1000;
+const RESOURCE_PLURAL = {
+    ticket: 'tickets',
+    user: 'users',
+    organization: 'organizations',
+};
+function composeQuery(type, query) {
+    const parts = [type ? `type:${type}` : null, (query ?? '').trim()].filter(Boolean);
+    return parts.join(' ').trim();
+}
+function extractResource(body, key, operation) {
+    const resource = body[key];
+    if (resource && typeof resource === 'object' && !Array.isArray(resource)) {
+        return resource;
+    }
+    throw new errors_1.ZendeskApiError(operation, undefined, body, new Error(`Zendesk API returned an unexpected body shape (missing '${key}')`));
+}
+function validate(options) {
+    const missing = [];
+    if (!options?.subdomain?.trim())
+        missing.push('subdomain');
+    if (!options?.email?.trim())
+        missing.push('email');
+    if (!options?.apiToken?.trim())
+        missing.push('apiToken');
+    if (missing.length > 0) {
+        throw new errors_1.ZendeskConfigurationError(`Zendesk client is missing required configuration: ${missing.join(', ')}`);
+    }
+}
+class ZendeskHttpClient {
+    constructor(options, logger) {
+        validate(options);
+        this.baseUrl = `https://${options.subdomain}.zendesk.com/api/v2`;
+        const credentials = Buffer.from(`${options.email}/token:${options.apiToken}`).toString('base64');
+        this.authHeader = `Basic ${credentials}`;
+        this.logger = logger;
+    }
+    async search(type, params) {
+        const query = composeQuery(type, params.query);
+        const perPage = Math.min(params.perPage ?? exports.MAX_PER_PAGE, exports.MAX_PER_PAGE);
+        return this.mustSucceed(`search(${type})`, async () => {
+            const queryParams = {
+                query,
+                per_page: perPage,
+                page: params.page ?? 1,
+            };
+            if (params.sortBy)
+                queryParams.sort_by = params.sortBy;
+            if (params.sortOrder)
+                queryParams.sort_order = params.sortOrder;
+            const body = await this.get('/search.json', queryParams);
+            return Array.isArray(body.results) ? body.results : [];
+        });
+    }
+    async count(type, query) {
+        return this.mustSucceed(`count(${type})`, async () => {
+            const body = await this.get('/search/count.json', { query: composeQuery(type, query) });
+            return typeof body.count === 'number' ? body.count : 0;
+        });
+    }
+    findTicket(id) {
+        return this.findOne('ticket', id);
+    }
+    findUser(id) {
+        return this.findOne('user', id);
+    }
+    findOrganization(id) {
+        return this.findOne('organization', id);
+    }
+    fetchTicketsByIds(ids) {
+        return this.showMany('ticket', ids, (r) => [Number(r.id), r]);
+    }
+    fetchUsersByIds(ids) {
+        return this.bestEffort('fetch_users_by_ids', new Map(), () => this.showMany('user', ids, r => [Number(r.id), r]));
+    }
+    fetchOrganizationsByIds(ids) {
+        return this.bestEffort('fetch_organizations_by_ids', new Map(), () => this.showMany('organization', ids, r => [Number(r.id), r]));
+    }
+    fetchUserEmails(ids) {
+        return this.bestEffort('fetch_user_emails', new Map(), () => this.showMany('user', ids, r => [Number(r.id), String(r.email ?? '')]));
+    }
+    async fetchTicketComments(ticketId) {
+        return this.mustSucceed(`fetch_ticket_comments(${ticketId})`, async () => {
+            const body = await this.get(`/tickets/${encodeURIComponent(String(ticketId))}/comments.json`);
+            return Array.isArray(body.comments) ? body.comments : [];
+        });
+    }
+    fetchTicketFields() {
+        return this.fetchFields('ticket_fields');
+    }
+    fetchUserFields() {
+        return this.fetchFields('user_fields');
+    }
+    fetchOrganizationFields() {
+        return this.fetchFields('organization_fields');
+    }
+    createTicket(attrs) {
+        return this.createOne('ticket', attrs);
+    }
+    updateTicket(id, attrs) {
+        return this.updateOne('ticket', id, attrs);
+    }
+    deleteTicket(id) {
+        return this.deleteOne('ticket', id);
+    }
+    createUser(attrs) {
+        return this.createOne('user', attrs);
+    }
+    updateUser(id, attrs) {
+        return this.updateOne('user', id, attrs);
+    }
+    deleteUser(id) {
+        return this.deleteOne('user', id);
+    }
+    createOrganization(attrs) {
+        return this.createOne('organization', attrs);
+    }
+    updateOrganization(id, attrs) {
+        return this.updateOne('organization', id, attrs);
+    }
+    deleteOrganization(id) {
+        return this.deleteOne('organization', id);
+    }
+    async bestEffort(operation, defaultValue, fn) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            this.logger?.('Warn', `[datasource-zendesk] ${operation} failed; degrading: ${err instanceof Error ? err.message : String(err)}`);
+            return defaultValue;
+        }
+    }
+    // ===== Internal helpers =====
+    async findOne(type, id) {
+        const plural = RESOURCE_PLURAL[type];
+        const path = `/${plural}/${encodeURIComponent(String(id))}.json`;
+        try {
+            const body = await this.mustSucceed(`find(${plural}/${id})`, () => this.get(path));
+            return body[type] ?? null;
+        }
+        catch (err) {
+            if (err instanceof errors_1.ZendeskApiError && err.status === 404)
+                return null;
+            throw err;
+        }
+    }
+    async showMany(type, ids, project) {
+        const plural = RESOURCE_PLURAL[type];
+        const uniqueIds = Array.from(new Set(ids.filter(id => id !== null && id !== undefined)));
+        const result = new Map();
+        if (uniqueIds.length === 0)
+            return result;
+        for (let i = 0; i < uniqueIds.length; i += exports.MAX_PER_PAGE) {
+            const chunk = uniqueIds.slice(i, i + exports.MAX_PER_PAGE);
+            // eslint-disable-next-line no-await-in-loop
+            const body = await this.mustSucceed(`fetch_${plural}_by_ids`, () => this.get(`/${plural}/show_many.json`, { ids: chunk.join(',') }));
+            const records = Array.isArray(body[plural]) ? body[plural] : [];
+            for (const record of records) {
+                const [key, value] = project(record);
+                result.set(key, value);
+            }
+        }
+        return result;
+    }
+    async fetchFields(path) {
+        return this.mustSucceed(`fetch_${path}`, async () => {
+            const body = await this.get(`/${path}.json`);
+            return Array.isArray(body[path]) ? body[path] : [];
+        });
+    }
+    async createOne(type, attrs) {
+        const plural = RESOURCE_PLURAL[type];
+        return this.mustSucceed(`create(${plural})`, async () => {
+            const body = await this.post(`/${plural}.json`, { [type]: attrs });
+            return extractResource(body, type, `create(${plural})`);
+        });
+    }
+    async updateOne(type, id, attrs) {
+        const plural = RESOURCE_PLURAL[type];
+        return this.mustSucceed(`update(${plural}/${id})`, async () => {
+            const body = await this.put(`/${plural}/${encodeURIComponent(String(id))}.json`, {
+                [type]: attrs,
+            });
+            return extractResource(body, type, `update(${plural}/${id})`);
+        });
+    }
+    async deleteOne(type, id) {
+        const plural = RESOURCE_PLURAL[type];
+        await this.mustSucceed(`delete(${plural}/${id})`, async () => {
+            await this.delete(`/${plural}/${encodeURIComponent(String(id))}.json`);
+            return null;
+        });
+    }
+    async mustSucceed(operation, fn) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (err instanceof errors_1.ZendeskApiError)
+                throw err;
+            const status = err?.status;
+            const body = err?.response?.body;
+            throw new errors_1.ZendeskApiError(operation, status, body, err);
+        }
+    }
+    get(path, query) {
+        const request = superagent_1.default.get(`${this.baseUrl}${path}`);
+        if (query)
+            request.query(query);
+        return this.send(request);
+    }
+    post(path, body) {
+        return this.send(superagent_1.default.post(`${this.baseUrl}${path}`).send(body));
+    }
+    put(path, body) {
+        return this.send(superagent_1.default.put(`${this.baseUrl}${path}`).send(body));
+    }
+    delete(path) {
+        return this.send(superagent_1.default.delete(`${this.baseUrl}${path}`));
+    }
+    async send(request) {
+        const response = await request
+            .set('Authorization', this.authHeader)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json');
+        return (response.body ?? {});
+    }
+}
+exports.ZendeskHttpClient = ZendeskHttpClient;
+function createZendeskClient(options, logger) {
+    return new ZendeskHttpClient(options, logger);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"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"}

package/dist/client-options.d.ts

@@ -0,0 +1,16 @@
+import type { ZendeskClient } from './client';
+import type { ZendeskClientOptions } from './types';
+import type { Logger } from '@forestadmin/datasource-toolkit';
+/**
+ * A Zendesk client can always be supplied directly, or built on-the-fly from raw
+ * credentials. The datasource factory and the smart-action plugins share this
+ * contract so users never have to instantiate a client by hand when they don't
+ * already have one.
+ */
+export type ZendeskClientProvider = {
+    client: ZendeskClient;
+} | ({
+    client?: never;
+} & ZendeskClientOptions);
+export declare function resolveZendeskClient(options: ZendeskClientProvider, logger?: Logger): ZendeskClient;
+//# sourceMappingURL=client-options.d.ts.map

package/dist/client-options.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveZendeskClient = resolveZendeskClient;
+const client_1 = require("./client");
+function resolveZendeskClient(options, logger) {
+    return 'client' in options && options.client
+        ? options.client
+        : (0, client_1.createZendeskClient)(options, logger);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY2xpZW50LW9wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFnQkEsb0RBT0M7QUFuQkQscUNBQStDO0FBWS9DLFNBQWdCLG9CQUFvQixDQUNsQyxPQUE4QixFQUM5QixNQUFlO0lBRWYsT0FBTyxRQUFRLElBQUksT0FBTyxJQUFJLE9BQU8sQ0FBQyxNQUFNO1FBQzFDLENBQUMsQ0FBQyxPQUFPLENBQUMsTUFBTTtRQUNoQixDQUFDLENBQUMsSUFBQSw0QkFBbUIsRUFBQyxPQUErQixFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQ25FLENBQUMifQ==

package/dist/collections/base-zendesk-collection.d.ts

@@ -0,0 +1,52 @@
+import type { ZendeskClient } from '../client';
+import type { CustomFieldEntry, ZendeskRecord, ZendeskResource } from '../types';
+import type { AggregateResult, Aggregation, Caller, ConditionTree, DataSource, Filter, Logger, PaginatedFilter, Projection, RecordData, Sort } from '@forestadmin/datasource-toolkit';
+import { BaseCollection } from '@forestadmin/datasource-toolkit';
+export { BOOLEAN_OPS, DATE_OPS, ID_OPS, NUMBER_OPS, STRING_OPS } from '../query/operators';
+export default abstract class BaseZendeskCollection extends BaseCollection {
+    protected readonly client: ZendeskClient;
+    protected readonly resource: ZendeskResource;
+    protected readonly sortableFields: Record<string, string>;
+    protected readonly logger?: Logger;
+    protected readonly zendeskIdToColumnName: Map<number, string>;
+    constructor(name: string, datasource: DataSource, client: ZendeskClient, resource: ZendeskResource, sortableFields: Record<string, string>, logger?: Logger);
+    abstract create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    abstract list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    abstract update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    abstract delete(caller: Caller, filter: Filter): Promise<void>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+    /** Fetch a single resource by primary key, or null when it does not exist (404). */
+    protected abstract findOne(id: number | string): Promise<ZendeskRecord | null>;
+    /** Convert a raw Zendesk payload into the Forest column layout this collection exposes. */
+    protected abstract serializeRecord(record: ZendeskRecord): RecordData;
+    /**
+     * Count the records matching the filter. An exact id-lookup is resolved by fetching the
+     * referenced records and re-applying the full condition tree in memory, so that non-existent
+     * ids and sibling conditions (scope/segment) are honored rather than blindly trusted.
+     */
+    protected aggregateCount(caller: Caller, filter: Filter): Promise<number>;
+    protected addCustomFields(customFields: CustomFieldEntry[]): void;
+    protected translateSort(sort: Sort | undefined): {
+        sortBy?: string;
+        sortOrder?: 'asc' | 'desc';
+    };
+    protected searchRecords(filter: PaginatedFilter | undefined): Promise<ZendeskRecord[]>;
+    protected fetchRecordsByIds(ids: number[]): Promise<ZendeskRecord[]>;
+    protected serializeForFilter(records: ZendeskRecord[]): Promise<RecordData[]>;
+    protected refine(records: RecordData[], filter: PaginatedFilter | undefined, timezone: string): RecordData[];
+    protected buildZendeskQuery(filter: Filter | PaginatedFilter | undefined): string;
+    /**
+     * Returns the list of primary-key values if the condition tree is an exact `id`
+     * lookup (Equal N or In [N1, N2, ...]), otherwise null. Lets `list/update/delete`
+     * bypass the Search API and hit the resource endpoint directly.
+     */
+    protected extractIdLookup(tree: ConditionTree | undefined): number[] | null;
+    /**
+     * Resolve the primary keys targeted by update/delete. A pure id-lookup is authoritative; an
+     * id-lookup combined with other conditions (scope/segment) is re-checked in memory so we never
+     * mutate a record outside the caller's perimeter. Otherwise every matching page is collected.
+     */
+    protected resolveIds(filter: Filter | undefined, timezone: string): Promise<number[]>;
+    private searchAllIds;
+}
+//# sourceMappingURL=base-zendesk-collection.d.ts.map