@planescrm/sdk 0.4.0 → 0.55.0

package/dist/index.d.mts

@@ -89,6 +89,8 @@ interface HttpRequestOptions {
     body?: unknown;
     params?: Record<string, unknown>;
     headers?: Record<string, string>;
+    /** 'arrayBuffer' returns the raw response body (binary downloads); default 'json'. */
+    responseType?: 'json' | 'arrayBuffer';
 }
 /**
  * Internal HTTP client wrapper using native fetch.
@@ -151,20 +153,31 @@ interface ListParams {
 }
 
 /**
- * Abstract base resource with standard CRUD methods.
+ * Minimal base: the http client and the resource's base path, no methods.
+ * Resources whose API routes aren't flat CRUD on `basePath` (nested under a
+ * parent like `customers/:customerId/properties`, or missing an operation like
+ * tasks without delete) extend this and declare only the methods the API
+ * serves, so a method the API doesn't have is a compile error, not a 404.
+ */
+declare abstract class ApiResource {
+    protected readonly http: HttpClient;
+    protected readonly basePath: string;
+    constructor(http: HttpClient, basePath: string);
+}
+/**
+ * Flat CRUD on `basePath`: `GET /`, `POST /`, `GET /:id`, `PATCH /:id`,
+ * `DELETE /:id`. Extend it only when the API serves all five (override a verb
+ * where it differs); otherwise extend `ApiResource`.
  * Generic parameters:
  * - TEntity: the entity response type
  * - TCreate: the create request body type
  * - TUpdate: the update request body type
  */
-declare abstract class BaseResource<TEntity = Record<string, unknown>, TCreate = Record<string, unknown>, TUpdate = Record<string, unknown>> {
-    protected readonly http: HttpClient;
-    protected readonly basePath: string;
-    constructor(http: HttpClient, basePath: string);
+declare abstract class BaseResource<TEntity = Record<string, unknown>, TCreate = Record<string, unknown>, TUpdate = Record<string, unknown>, TList = PaginatedResponse<TEntity>> extends ApiResource {
     /**
      * List entities with optional filters and pagination.
      */
-    list(params?: ListParams): Promise<PaginatedResponse<TEntity>>;
+    list(params?: ListParams): Promise<TList>;
     /**
      * Get a single entity by ID.
      */
@@ -183,24 +196,413 @@ declare abstract class BaseResource<TEntity = Record<string, unknown>, TCreate =
     delete(id: string): Promise<void>;
 }
 
-/** Opportunity resource — CRUD operations on /opportunities. */
+/**
+ * Query params for `GET /opportunities` — mirrors `opportunityFilterSchema` in
+ * `@blueprint/shared`. `tag_ids` is ANY-of: an opportunity tagged with at least
+ * one of the given tags matches (max 20). It is sent as one comma-separated value.
+ * Extends the generic `ListParams` so it stays assignable to `BaseResource.list`.
+ */
+/** Sortable columns on `GET /opportunities` (kept in lockstep with the server enum by the SDK's wire-contract spec). */
+declare const OPPORTUNITY_SORT_KEYS: readonly ["created_at", "total", "title", "customer_name", "stage", "priority", "recent"];
+type OpportunitySortKey = (typeof OPPORTUNITY_SORT_KEYS)[number];
+/**
+ * Lifecycle states on `GET /opportunities` (kept in lockstep with the server's
+ * `OPPORTUNITY_STATES` by the SDK's wire-contract spec).
+ */
+declare const OPPORTUNITY_STATES: readonly ["open", "closed", "won", "lost"];
+type OpportunityState = (typeof OPPORTUNITY_STATES)[number];
+interface OpportunityListParams extends ListParams {
+    search?: string;
+    /** Stage name (matched case-insensitively against the published pipeline). */
+    stage?: string;
+    /**
+     * Open / closed / won / lost, read from the record's current stage — works
+     * across pipeline versions (stage names can differ between versions).
+     * Records with no pipeline match no state. ANDs with `stage`.
+     */
+    state?: OpportunityState;
+    agent_id?: string;
+    customer_id?: string;
+    priority?: 'low' | 'normal' | 'high' | 'urgent';
+    source?: string;
+    tag_ids?: string[];
+    /**
+     * Mirrors `OPPORTUNITY_SORT_KEYS`. `customer_name` orders by the customer's
+     * display name, `stage` by pipeline position (stage-less rows last),
+     * `priority` low → normal → high → urgent. `recent` orders by the calling
+     * user's last view (newest first, never-viewed last) and ignores `sort_order`.
+     */
+    sort_by?: OpportunitySortKey;
+    sort_order?: 'asc' | 'desc';
+    page?: number;
+    limit?: number;
+}
+/**
+ * `PUT /opportunities/{id}` body — mirrors `updateOpportunitySchema` in
+ * `@blueprint/shared` (every field optional; `null` clears a nullable one).
+ * `source` is validated against the tenant's lead sources; `customFields`
+ * against the tenant's opportunity field definitions. Stage moves go through
+ * the workflow transition routes, not this body.
+ */
+interface UpdateOpportunityDto$1 {
+    title?: string | undefined;
+    customerId?: string | undefined;
+    agentId?: string | null | undefined;
+    source?: string | null | undefined;
+    priority?: 'low' | 'normal' | 'high' | 'urgent' | undefined;
+    total?: number | undefined;
+    notes?: string | null | undefined;
+    /** ISO 8601 datetime. */
+    closedAt?: string | null | undefined;
+    closedReason?: string | null | undefined;
+    primaryContactId?: string | null | undefined;
+    customFields?: Record<string, unknown> | null | undefined;
+}
+
+/** Opportunity resource — CRUD operations on /opportunities (updates are PUT). */
 declare class OpportunityResource extends BaseResource {
     constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+    /**
+     * List opportunities. `tag_ids` is ANY-of and travels as one comma-separated
+     * query value (`?tag_ids=a,b`), which is what the API's filter schema parses.
+     */
+    list(params?: OpportunityListParams): Promise<PaginatedResponse<Record<string, unknown>>>;
+    /** PUT /opportunities/{id} — partial update; stage moves go through workflow transitions. */
+    update(id: string, data: UpdateOpportunityDto$1): Promise<Record<string, unknown>>;
+}
+
+/**
+ * Company merge result (E38-F10-S1) — the body of
+ * `POST /customers/{winnerId}/merge/{loserId}`.
+ *
+ * Derived from `CustomerMergeResult` on the API service rather than hand-written
+ * from the docs: `counts` is keyed by table / repoint-handler name and grows as
+ * features register handlers, so it is deliberately an open record rather than a
+ * closed shape that would go stale the first time a module is added.
+ */
+interface CustomerMergeResult {
+    /** The survivor. */
+    winnerId: string;
+    /** The duplicate, now soft-deleted; its id still resolves to the winner. */
+    loserId: string;
+    /** Rows moved per table / handler, e.g. `{ opportunity: 2, invoice: 1 }`. */
+    counts: Record<string, number>;
+}
+/**
+ * Optional service address embeddable on customer create/update. Mirrors
+ * `createAddressInputSchema` in `packages/shared/src/validation/property.ts`:
+ * all-or-nothing — once present, line1/city/state/zip are required.
+ */
+interface CustomerAddressInput {
+    addressLine1: string;
+    addressLine2?: string;
+    city: string;
+    /** Two-letter state code. */
+    state: string;
+    /** 5-digit or ZIP+4. */
+    zip: string;
+    /** Two-letter country code; defaults to `US`. */
+    country?: string;
+}
+/**
+ * `PUT /customers/{id}` body. Mirrors `updateCustomerSchema` in
+ * `packages/shared/src/validation/customer.ts`. Every field is optional; the
+ * kind ↔ name rules only apply when `kind` is sent.
+ *
+ * `address` is an upsert, never a delete: a match on an existing property is a
+ * no-op, the customer's only property is updated in place, otherwise a new
+ * property is added. Omit it to leave properties untouched.
+ */
+interface UpdateCustomerDto {
+    kind?: 'person' | 'company';
+    firstName?: string;
+    lastName?: string;
+    companyName?: string | null;
+    email?: string | null;
+    phone?: string | null;
+    phoneDnc?: boolean | null;
+    marketingOptOut?: boolean | null;
+    notes?: string | null;
+    source?: string | null;
+    address?: CustomerAddressInput;
+    customFields?: Record<string, unknown> | null;
+}
+/**
+ * Query params for `GET /customers` — mirrors `customerFilterSchema` in
+ * `@blueprint/shared`. `tag_ids` is ANY-of: a customer tagged with at least one
+ * of the given tags matches (max 20). It is sent as one comma-separated value.
+ * Extends the generic `ListParams` so it stays assignable to `BaseResource.list`.
+ */
+/** Sortable columns on `GET /customers` (kept in lockstep with the server enum by the SDK's wire-contract spec). */
+declare const CUSTOMER_SORT_KEYS: readonly ["created_at", "last_name", "first_name", "email", "phone", "source", "recent"];
+type CustomerSortKey = (typeof CUSTOMER_SORT_KEYS)[number];
+interface CustomerListParams extends ListParams {
+    /** Person or company name; every word must match, so a full name works in either order. */
+    search?: string;
+    notes_contains?: string;
+    source?: string;
+    kind?: 'person' | 'company';
+    tag_ids?: string[];
+    /**
+     * Mirrors `CUSTOMER_SORT_KEYS`. `last_name` sorts companies by company name.
+     * email / phone / source are nullable and sort NULLs last in both directions.
+     * `recent` orders by the calling user's last view (newest first, never-viewed
+     * last) and ignores `sort_order`.
+     */
+    sort_by?: CustomerSortKey;
+    sort_order?: 'asc' | 'desc';
+    page?: number;
+    limit?: number;
 }
 
 /** Customer resource — CRUD operations on /customers. */
 declare class CustomerResource extends BaseResource {
     constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+    /**
+     * Update a customer. The API route is `PUT /customers/{id}` (not PATCH like
+     * the other resources), so this overrides the base verb; the body is still a
+     * partial — send only the fields to change. See `UpdateCustomerDto.address`
+     * for how a service address resolves to a property.
+     */
+    update(id: string, data: UpdateCustomerDto): Promise<Record<string, unknown>>;
+    /**
+     * List customers. `tag_ids` is ANY-of and travels as one comma-separated
+     * query value (`?tag_ids=a,b`), which is what the API's filter schema parses.
+     */
+    list(params?: CustomerListParams): Promise<PaginatedResponse<Record<string, unknown>>>;
+    /**
+     * Fold a duplicate company (`loserId`) into a survivor (`winnerId`).
+     *
+     * Everything hanging off the loser moves to the winner, the winner's empty
+     * fields are filled from the loser, and the loser is soft-deleted with a
+     * resolvable pointer — `GET /customers/{loserId}` afterwards returns the
+     * winner's detail with a `mergedFrom` pointer, so a stored loser id keeps
+     * working. Irreversible; requires admin scope.
+     */
+    merge(winnerId: string, loserId: string): Promise<CustomerMergeResult>;
 }
 
-/** Property resource — CRUD operations on /properties. */
-declare class PropertyResource extends BaseResource {
-    constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+/**
+ * Wire shapes for properties (`/customers/{customerId}/properties`, plus the
+ * direct `GET /properties/{id}`). Mirror `createPropertySchema` /
+ * `updatePropertySchema` / `propertyFilterSchema` in
+ * `packages/shared/src/validation/property.ts`, redefined here so the
+ * published package carries no dependency on `@blueprint/shared`;
+ * `crud-route-types.parity.ts` fails the build when the two drift.
+ */
+/** `POST /customers/{customerId}/properties` body — the customer comes from the path. */
+interface CreatePropertyDto {
+    addressLine1: string;
+    addressLine2?: string | null | undefined;
+    city: string;
+    /** Two-letter state code. */
+    state: string;
+    zip: string;
+    /** Defaults to `US`. */
+    country?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+/** `PUT /customers/{customerId}/properties/{id}` body — every field optional. */
+interface UpdatePropertyDto {
+    addressLine1?: string | undefined;
+    addressLine2?: string | null | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    zip?: string | undefined;
+    country?: string | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+}
+/** Query for `GET /customers/{customerId}/properties` (`page` ≥ 1, `limit` 1–100, default 25). */
+type PropertyListParams = {
+    search?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+};
+
+/**
+ * Properties. Every write and the list are nested under the owning customer
+ * (`/customers/{customerId}/properties`); only the single-property read has a
+ * direct route (`GET /properties/{id}`).
+ */
+declare class PropertyResource extends ApiResource {
+    constructor(http: ConstructorParameters<typeof ApiResource>[0]);
+    /** GET /customers/{customerId}/properties — paginated (`page`, `limit` ≤ 100). */
+    list(customerId: string, params?: PropertyListParams): Promise<PaginatedResponse<Record<string, unknown>>>;
+    /** GET /properties/{id} — one property, without naming its customer. */
+    get(id: string): Promise<Record<string, unknown>>;
+    /** POST /customers/{customerId}/properties — the property inherits the customer's org path. */
+    create(customerId: string, data: CreatePropertyDto): Promise<Record<string, unknown>>;
+    /** PUT /customers/{customerId}/properties/{id} — partial update. */
+    update(customerId: string, id: string, data: UpdatePropertyDto): Promise<Record<string, unknown>>;
+    /** DELETE /customers/{customerId}/properties/{id} — soft delete (204). */
+    delete(customerId: string, id: string): Promise<void>;
+}
+
+/**
+ * Wire shapes for `POST /events/:id/complete` (E46-F6-S2) and
+ * `PATCH /events/:id` (body E46-F6-S6, edit mode E46-F6-S11).
+ *
+ * Mirrors `completionWorkflowTriggerSchema` / `COMPLETION_TRIGGER_REASONS` in
+ * `packages/shared/src/validation/calendar-event.ts` and the shape
+ * `CalendarService.completeEvent` returns. Types are redefined here (not
+ * imported) so the published package carries no dependency on
+ * `@blueprint/shared`; `calendar-events.spec.ts` parses the response with the
+ * REAL shared schema.
+ */
+/** Whether the event's "on complete" transition ran. */
+type CompletionTriggerStatus = 'fired' | 'skipped' | 'failed';
+type CompletionTriggerReason = 'no_completion_transition' | 'executor_unavailable' | 'no_linked_record' | 'no_workflow_instance' | 'transition_not_found' | 'wrong_pipeline' | 'no_equivalent_in_version' | 'not_valid_from_current_stage' | 'role_not_allowed' | 'missing_required_fields' | 'transition_error';
+/** A pipeline stage, named as the record's pipeline version names it (0.55.0). */
+interface CompletionTriggerStage {
+    id: string;
+    name: string;
+}
+interface CompletionWorkflowTrigger {
+    status: CompletionTriggerStatus;
+    /** Present whenever `status` isn't `fired`. */
+    reason?: CompletionTriggerReason | undefined;
+    /** Human-readable explanation, safe to show to the person who completed the event. */
+    message?: string | undefined;
+    /**
+     * Present only when `status` is `fired`: the stage the completion's
+     * transition moved the record to (0.55.0). Actions on that transition run
+     * afterwards, so a chained transition may move the record again later.
+     */
+    to_stage?: CompletionTriggerStage | undefined;
+}
+interface CompleteCalendarEventDto {
+    completion_notes?: string;
+}
+/**
+ * The completed event (snake_case, as every `/events` read returns it) plus
+ * `workflow_trigger`. Completing always completes the event; a trigger that
+ * fails is reported here and to the tenant's admins, never thrown.
+ */
+interface CompleteCalendarEventResponse extends Record<string, unknown> {
+    id: string;
+    status: 'completed';
+    completion_workflow_transition_id: string | null;
+    entity_type: string | null;
+    entity_id: string | null;
+    workflow_trigger: CompletionWorkflowTrigger;
+}
+type CalendarEventType = 'appointment' | 'site_visit' | 'call' | 'delivery' | 'pickup' | 'session' | 'custom';
+type CalendarEventLocationType = 'physical' | 'virtual' | 'none';
+type CalendarEventStatus = 'scheduled' | 'confirmed' | 'in_progress' | 'completed' | 'cancelled' | 'no_show';
+interface CalendarEventParticipantDto {
+    type: 'user' | 'contact' | 'crew' | 'agent';
+    id: string;
+    /** Defaults to `invited`. */
+    status?: 'invited' | 'accepted' | 'declined' | 'tentative' | undefined;
+}
+/**
+ * Body of `PATCH /events/:id`. Mirrors `updateCalendarEventSchema`
+ * (`calendar-event-types.parity.ts` fails the build if they drift). Every
+ * field is optional; an omitted field is left unchanged.
+ */
+interface UpdateCalendarEventDto {
+    title?: string | undefined;
+    description?: string | undefined;
+    event_type?: CalendarEventType | undefined;
+    /** Wall-clock time in `timezone`, e.g. `2026-11-02T14:00:00`. */
+    starts_at?: string | undefined;
+    ends_at?: string | undefined;
+    all_day?: boolean | undefined;
+    timezone?: string | undefined;
+    /** RRULE; blank means "does not repeat". */
+    recurrence_rule?: string | undefined;
+    location_type?: CalendarEventLocationType | undefined;
+    address_line1?: string | undefined;
+    address_line2?: string | undefined;
+    city?: string | undefined;
+    state?: string | undefined;
+    zip?: string | undefined;
+    /** A bare host like `zoom.us/j/123` is stored as `https://zoom.us/j/123`; blank clears it. */
+    virtual_url?: string | undefined;
+    property_id?: string | undefined;
+    entity_type?: string | undefined;
+    entity_id?: string | undefined;
+    status?: CalendarEventStatus | undefined;
+    /**
+     * The workflow transition to run when the event is completed. Must belong to
+     * the linked record's pipeline (else 422 COMPLETION_TRANSITION_WRONG_PIPELINE).
+     * `null` removes the completion step; omit it to leave the step unchanged.
+     */
+    completion_workflow_transition_id?: string | null | undefined;
+    /** Replaces the event's participants with exactly this list. */
+    participants?: CalendarEventParticipantDto[] | undefined;
+}
+/**
+ * Which occurrences of a recurring event an update applies to. Mirrors the
+ * shared `RECURRENCE_EDIT_MODES`; sent as the `recurrence_edit_mode` query
+ * parameter. Ignored for one-time events.
+ * - `this` — this occurrence only (the default). Not allowed on a series master.
+ * - `this_and_future` — splits the series here; this and later occurrences change.
+ * - `all` — the whole series.
+ */
+type RecurrenceEditMode = 'this' | 'this_and_future' | 'all';
+/** Options for `calendarEvents.update()` (E46-F6-S11). */
+interface UpdateCalendarEventOptions {
+    /** Defaults to `this` on the server when omitted. */
+    editMode?: RecurrenceEditMode | undefined;
 }
 
-/** Calendar event resource — CRUD operations on /calendar-events. */
-declare class CalendarEventResource extends BaseResource {
+/**
+ * Query filters for `GET /events`. Mirrors the API's
+ * `listCalendarEventsQuerySchema` (`@blueprint/shared`) — keep in sync.
+ * Deliberately NOT `ListParams`: this endpoint paginates by `limit`/`offset`
+ * only and has no `page`, `sort`, `order` or `search` (Zod would strip them
+ * silently and the caller would loop on page 1 forever).
+ */
+interface ListCalendarEventsParams {
+    /** ISO timestamp — events starting at or after this instant. */
+    starts_after?: string;
+    /** ISO timestamp — events starting at or before this instant. */
+    starts_before?: string;
+    /** Must be paired with `entity_id`. */
+    entity_type?: string;
+    entity_id?: string;
+    /** Agent id of the event's creator. */
+    created_by?: string;
+    /**
+     * Events this agent is ON: a staff participant (canonical `{id}` or legacy
+     * `{agent_id}` shape), or the creator only when the event has no staff
+     * participants (self-booked / Google-synced) — the same rule availability
+     * uses to count busy time. An event booked for someone else is not on the
+     * creator's schedule.
+     */
+    agent_id?: string;
+    status?: string;
+    event_type?: string;
+    /** Only recurrence masters / one-time events (no generated instances). */
+    masters_only?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/** What `GET /events` actually returns: offset pagination, no `meta` envelope. */
+interface CalendarEventListResponse<T = Record<string, unknown>> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/** Calendar event resource — CRUD operations on /events. */
+declare class CalendarEventResource extends BaseResource<Record<string, unknown>, Record<string, unknown>, UpdateCalendarEventDto, CalendarEventListResponse> {
     constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+    list(params?: ListCalendarEventsParams): Promise<CalendarEventListResponse>;
+    /**
+     * PATCH /events/:id. For an occurrence of a recurring event, `editMode`
+     * picks which occurrences change (`this` when omitted — the server's
+     * default); it is ignored for one-time events.
+     */
+    update(id: string, data: UpdateCalendarEventDto, options?: UpdateCalendarEventOptions): Promise<Record<string, unknown>>;
+    /**
+     * POST /events/:id/complete — marks the event completed and runs its "on
+     * complete" transition, best-effort. The event is completed even when the
+     * transition can't run; `workflow_trigger` says whether it fired, was
+     * skipped (none set) or failed (with a reason).
+     */
+    complete(id: string, body?: CompleteCalendarEventDto): Promise<CompleteCalendarEventResponse>;
 }
 
 /** Contract resource — CRUD operations on /contracts. */
@@ -208,24 +610,453 @@ declare class ContractResource extends BaseResource {
     constructor(http: ConstructorParameters<typeof BaseResource>[0]);
 }
 
-/** Job resource — CRUD operations on /jobs. */
-declare class JobResource extends BaseResource {
-    constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+/**
+ * Query params for `GET /opportunities/{opportunityId}/jobs` — mirrors
+ * `jobFilterSchema` in `packages/shared/src/validation/job.ts`. Extends the
+ * generic `ListParams` so it stays assignable to `BaseResource.list`.
+ */
+/** Sort keys on the per-opportunity jobs list (kept in lockstep with the server enum by the SDK's wire-contract spec). */
+declare const JOB_SORT_KEYS: readonly ["created_at", "recent"];
+type JobSortKey = (typeof JOB_SORT_KEYS)[number];
+type JobStatus = 'active' | 'on_hold' | 'completed' | 'cancelled';
+interface JobListParams extends ListParams {
+    tradeId?: string;
+    status?: JobStatus;
+    /**
+     * Mirrors `JOB_SORT_KEYS`. Default `created_at` desc. `recent` orders by the
+     * calling user's last view (newest first, never-viewed last) and ignores
+     * `sort_order`.
+     */
+    sort_by?: JobSortKey;
+    sort_order?: 'asc' | 'desc';
+    page?: number;
+    limit?: number;
+}
+/**
+ * One active trade and whether a job can be created under it
+ * (`GET /api/v1/jobs/trade-coverage`). Mirrors `jobTradeCoverageItemSchema` in
+ * `packages/shared` — redefined here so the published package carries no
+ * dependency on `@blueprint/shared`; `jobs.spec.ts` parses the response with
+ * the REAL shared schema. `hasWorkflow: false` means creating a job with this
+ * trade returns 422 WORKFLOW_NOT_CONFIGURED.
+ */
+interface JobTradeCoverageItemDto {
+    tradeId: string;
+    name: string;
+    hasWorkflow: boolean;
+}
+/** Every active trade of the tenant, ordered by name, with job-workflow coverage. */
+interface JobTradeCoverageResponse {
+    trades: JobTradeCoverageItemDto[];
+}
+/**
+ * `POST /opportunities/{opportunityId}/jobs` body — mirrors `createJobSchema`
+ * minus `opportunityId` (it comes from the path). A trade with no published
+ * job workflow returns 422 WORKFLOW_NOT_CONFIGURED; see `getTradeCoverage()`.
+ */
+interface CreateJobDto {
+    tradeId: string;
+    propertyId?: string | undefined;
+    notes?: string | undefined;
+}
+/** `PUT /opportunities/{opportunityId}/jobs/{id}` body — mirrors `updateJobSchema`. */
+interface UpdateJobDto {
+    status?: JobStatus | undefined;
+    notes?: string | null | undefined;
 }
 
-/** Estimate resource — CRUD operations on /estimates. */
-declare class EstimateResource extends BaseResource {
-    constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+/**
+ * Jobs. CRUD is nested under the parent opportunity
+ * (`/opportunities/{opportunityId}/jobs`); there is no flat `/jobs` list or
+ * `/jobs/{id}` read. `getTradeCoverage()` is the one top-level route.
+ */
+declare class JobResource extends ApiResource {
+    constructor(http: ConstructorParameters<typeof ApiResource>[0]);
+    /** The jobs under one opportunity — the same route as `listForOpportunity()`. */
+    list(opportunityId: string, params?: JobListParams): Promise<PaginatedResponse<Record<string, unknown>>>;
+    /**
+     * List the jobs under one opportunity — `GET /opportunities/{opportunityId}/jobs`,
+     * the API's job list route. Default order is `created_at` desc;
+     * `sort_by: 'recent'` puts the calling user's most recently opened jobs first.
+     */
+    listForOpportunity(opportunityId: string, params?: JobListParams): Promise<PaginatedResponse<Record<string, unknown>>>;
+    /** GET /opportunities/{opportunityId}/jobs/{id} */
+    get(opportunityId: string, id: string): Promise<Record<string, unknown>>;
+    /**
+     * POST /opportunities/{opportunityId}/jobs — 422 WORKFLOW_NOT_CONFIGURED when
+     * the trade has no published job workflow (check `getTradeCoverage()` first).
+     */
+    create(opportunityId: string, data: CreateJobDto): Promise<Record<string, unknown>>;
+    /** PUT /opportunities/{opportunityId}/jobs/{id} — partial update (status, notes). */
+    update(opportunityId: string, id: string, data: UpdateJobDto): Promise<Record<string, unknown>>;
+    /** DELETE /opportunities/{opportunityId}/jobs/{id} — soft delete (204). */
+    delete(opportunityId: string, id: string): Promise<void>;
+    /**
+     * GET /jobs/trade-coverage — every active trade with whether a job can be
+     * created under it (a published job workflow resolves: the trade's own or the
+     * generic one). Check before creating a job to avoid a 422
+     * WORKFLOW_NOT_CONFIGURED. Readable by any role that can create jobs (403
+     * otherwise); carries no workflow details.
+     */
+    getTradeCoverage(): Promise<JobTradeCoverageResponse>;
+}
+
+/** Estimate statuses — mirrors `ESTIMATE_STATUSES` in `packages/shared/src/validation/estimate.ts` (runtime parity spec). */
+declare const ESTIMATE_STATUSES: readonly ["draft", "sent", "approved", "rejected"];
+type EstimateStatus = (typeof ESTIMATE_STATUSES)[number];
+/**
+ * Query params for the estimate lists — mirrors `estimateFilterSchema`
+ * (`page` ≥ 1, `limit` 1–100, default 25).
+ */
+interface EstimateListParams extends ListParams {
+    status?: EstimateStatus;
+    page?: number;
+    limit?: number;
+}
+/**
+ * One estimate list row (no line items) — transcribed from
+ * `EstimatesService.findAllForOpportunity`, the same shape as the per-job list.
+ * Money/rate columns are Postgres numerics, so they arrive as strings.
+ */
+interface EstimateSummaryDto {
+    id: string;
+    tenantId: string;
+    jobId: string;
+    estimateTemplateId: string | null;
+    status: EstimateStatus;
+    notes: string | null;
+    subtotal: string;
+    discountType: string | null;
+    discountValue: string | null;
+    taxRate: string | null;
+    taxAmount: string | null;
+    total: string;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+    lineItemCount: number;
+}
+/**
+ * `POST /jobs/{jobId}/estimates` body — mirrors `createEstimateSchema` minus
+ * `jobId` (it comes from the path).
+ */
+interface CreateEstimateDto {
+    estimateTemplateId?: string | undefined;
+    /** Defaults to `{}`. */
+    measurements?: Record<string, unknown> | undefined;
+    notes?: string | undefined;
+}
+/** `PUT /jobs/{jobId}/estimates/{id}` body — mirrors `updateEstimateSchema`. `taxRate` is a fraction (0–1). */
+interface UpdateEstimateDto {
+    measurements?: Record<string, unknown> | undefined;
+    notes?: string | null | undefined;
+    discountType?: 'percent' | 'flat' | null | undefined;
+    discountValue?: number | null | undefined;
+    taxRate?: number | null | undefined;
+}
+
+/**
+ * Estimates. CRUD is nested under the parent job (`/jobs/{jobId}/estimates`);
+ * `listForOpportunity()` reads every estimate across an opportunity's jobs.
+ * There is no flat `/estimates` list or `/estimates/{id}` read.
+ */
+declare class EstimateResource extends ApiResource {
+    constructor(http: ConstructorParameters<typeof ApiResource>[0]);
+    /** GET /jobs/{jobId}/estimates — newest first, paginated (`page`, `limit` ≤ 100). */
+    list(jobId: string, params?: EstimateListParams): Promise<PaginatedResponse<EstimateSummaryDto>>;
+    /**
+     * Every estimate across all of one opportunity's jobs, in one request —
+     * `GET /opportunities/{opportunityId}/estimates`. Newest first; each row
+     * carries its `jobId`. Paginated with `page` / `limit` (max 100).
+     */
+    listForOpportunity(opportunityId: string, params?: EstimateListParams): Promise<PaginatedResponse<EstimateSummaryDto>>;
+    /** GET /jobs/{jobId}/estimates/{id} — the estimate with its line items. */
+    get(jobId: string, id: string): Promise<Record<string, unknown>>;
+    /** POST /jobs/{jobId}/estimates — optionally cloned from an estimate template. */
+    create(jobId: string, data: CreateEstimateDto): Promise<Record<string, unknown>>;
+    /** PUT /jobs/{jobId}/estimates/{id} — partial update (measurements, notes, discount, tax). */
+    update(jobId: string, id: string, data: UpdateEstimateDto): Promise<Record<string, unknown>>;
+    /** DELETE /jobs/{jobId}/estimates/{id} — soft delete (204). */
+    delete(jobId: string, id: string): Promise<void>;
+}
+
+/**
+ * Wire shapes for `GET /admin/invoices` — mirrors `invoiceFilterSchema` in
+ * `@blueprint/shared` and the row `InvoiceService.findAll` actually returns
+ * (camelCase Drizzle columns, Date columns serialised as ISO strings, money as
+ * numeric(12,2) dollar strings). Redefined here (not imported) so the published
+ * package carries no dependency on `@blueprint/shared`; `invoices.spec.ts`
+ * parses the query the SDK sends with the REAL shared filter schema.
+ */
+type InvoiceStatus = 'draft' | 'sent' | 'partially_paid' | 'paid' | 'void' | 'uncollectible';
+type InvoiceSourceType = 'job' | 'contract' | 'estimate' | 'manual' | 'billing_schedule';
+/**
+ * Status of a payment row. `needs_review` (E56-F5-S2) is a processor payment
+ * that landed on a void invoice: recorded so the money is never lost, but it
+ * does not count toward the invoice's totals until someone resolves it.
+ */
+type PaymentStatus = 'pending' | 'succeeded' | 'failed' | 'refunded' | 'needs_review';
+/**
+ * `payLink` on `GET /admin/invoices/:id` (E56-F5-S2) — mirrors
+ * `invoicePayLinkStatusSchema`. Whether a live pay link exists and when one was
+ * last issued. The URL itself is never returned: only its hash is stored. Call
+ * `invoices.createPayLink(id)` to get a new one.
+ */
+interface InvoicePayLinkStatusDto {
+    active: boolean;
+    lastSentAt: string | null;
+}
+/** Response of `POST /admin/invoices/:id/pay-link` — mirrors `invoicePayLinkSchema`. */
+interface InvoicePayLinkDto {
+    url: string;
+}
+interface InvoiceListParams extends ListParams {
+    status?: InvoiceStatus;
+    customerId?: string;
+    sourceType?: InvoiceSourceType;
+    sourceId?: string;
+    page?: number;
+    limit?: number;
+}
+/** One row of `GET /admin/invoices`. */
+interface InvoiceListItemDto {
+    id: string;
+    tenantId: string;
+    invoiceNumber: string;
+    sourceType: InvoiceSourceType;
+    sourceId: string | null;
+    customerId: string;
+    /**
+     * The billed customer's display name — company name for a company, "First
+     * Last" for a person. Still set when the customer has since been deleted
+     * (historical invoice); `null` only if the customer row is missing.
+     */
+    customerName: string | null;
+    orgPath: string;
+    status: InvoiceStatus;
+    currency: string;
+    subtotal: string;
+    taxAmount: string;
+    total: string;
+    amountPaid: string;
+    balance: string;
+    issuedAt: string | null;
+    dueAt: string | null;
+    paidAt: string | null;
+    memo: string | null;
+    terms: string | null;
+    /** Provider → external id, e.g. `{ quickbooks: '130', stripe: 'in_…' }`. */
+    externalRef: Record<string, string>;
+    /**
+     * Storage key of the PDF copy stored when the invoice was sent (E56-F6-S1);
+     * `null` for drafts and for sends that stored no copy. Download the bytes
+     * with `invoices.downloadPdf(id)`.
+     */
+    pdfStorageKey: string | null;
+    pdfGeneratedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+/** One line of `GET /admin/invoices/:id`. */
+type InvoiceLineItemDto = {
+    id: string;
+    tenantId: string;
+    invoiceId: string;
+    description: string;
+    quantity: string;
+    unitPrice: string;
+    lineTotal: string;
+    sourceLineId: string | null;
+    sortOrder: number;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * One payment of `GET /admin/invoices/:id`. A `needs_review` row (money that
+ * arrived after the invoice was voided) is listed here but is not counted in
+ * the invoice's `amountPaid`/`balance`.
+ */
+type InvoicePaymentDto = {
+    id: string;
+    tenantId: string;
+    invoiceId: string;
+    amount: string;
+    currency: string;
+    method: string;
+    processor: string;
+    status: PaymentStatus;
+    externalRef: Record<string, string>;
+    receivedAt: string;
+    memo: string | null;
+    /** Set on a refund row: the payment it refunds. */
+    refundsPaymentId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+};
+/** `GET /admin/invoices/:id` — the invoice row plus its lines, payments and pay-link state. */
+type InvoiceDetailDto = Omit<InvoiceListItemDto, 'customerName'> & {
+    lineItems: InvoiceLineItemDto[];
+    payments: InvoicePaymentDto[];
+    payLink: InvoicePayLinkStatusDto;
+};
+/**
+ * Query of `GET /admin/invoices/overdue` (E56-F8-S2) — mirrors
+ * `overdueInvoiceQuerySchema` in `@blueprint/shared`.
+ */
+interface OverdueInvoiceListParams {
+    /** Only invoices at least this many whole days past due (1–3650). */
+    minDays?: number;
+    customerId?: string;
+    page?: number;
+    limit?: number;
+}
+/**
+ * One row of `GET /admin/invoices/overdue` — mirrors `overdueInvoiceSchema`:
+ * a sent or partially paid invoice with a balance, past its due date.
+ */
+interface OverdueInvoiceDto {
+    id: string;
+    invoiceNumber: string;
+    customerId: string;
+    customerName: string | null;
+    status: 'sent' | 'partially_paid';
+    currency: string;
+    total: string;
+    balance: string;
+    issuedAt: string | null;
+    dueAt: string;
+    /** Whole days since the due date (0 = past due today). */
+    daysOverdue: number;
+    /** The highest overdue offset (days) Planes has recorded for it, or null if none yet. */
+    lastOffsetReached: number | null;
+    sourceType: InvoiceSourceType;
+    sourceId: string | null;
+}
+/** Response of `GET /admin/invoices/overdue/summary` — mirrors `invoiceOverdueSummarySchema`. */
+interface InvoiceOverdueSummaryDto {
+    count: number;
+    /** Sum of the overdue balances, dollars as a decimal string. */
+    total: string;
 }
 
-/** Invoice resource — CRUD operations on /invoices. */
-declare class InvoiceResource extends BaseResource {
+/** Invoice resource — CRUD operations on /admin/invoices (the API's invoices controller route). */
+declare class InvoiceResource extends BaseResource<Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, PaginatedResponse<InvoiceListItemDto>> {
     constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+    /** List invoices, newest first. Each row carries the customer's `customerName`. */
+    list(params?: InvoiceListParams): Promise<PaginatedResponse<InvoiceListItemDto>>;
+    /**
+     * GET /admin/invoices/:id — the invoice with its line items, payments
+     * (including any `needs_review` payment) and `payLink` state.
+     */
+    get(id: string): Promise<InvoiceDetailDto>;
+    /**
+     * POST /admin/invoices/:id/pay-link — issue a fresh durable pay link for a
+     * `sent` or `partially_paid` invoice (Send Invoice grant) and return its URL,
+     * e.g. to share by text. Rotates: the previously emailed link stops working.
+     * Any other status → 409 `INVOICE_NOT_PAYABLE`.
+     */
+    createPayLink(id: string): Promise<InvoicePayLinkDto>;
+    /**
+     * GET /admin/invoices/:id/pdf — the invoice PDF bytes (Read Invoice grant).
+     * A sent invoice returns the copy stored when it was sent; a draft renders on
+     * demand with a DRAFT watermark.
+     */
+    downloadPdf(id: string): Promise<ArrayBuffer>;
+    /**
+     * GET /admin/invoices/overdue — sent / partially paid invoices with a balance
+     * past their due date, most overdue first, each with `daysOverdue` and the
+     * last overdue offset reached (E56-F8-S2). Read Invoice.
+     */
+    listOverdue(params?: OverdueInvoiceListParams): Promise<PaginatedResponse<OverdueInvoiceDto>>;
+    /** GET /admin/invoices/overdue/summary — `{ count, total }` of every overdue invoice. Read Invoice. */
+    overdueSummary(): Promise<InvoiceOverdueSummaryDto>;
+}
+
+/**
+ * Wire shapes for inventory items (`/admin/inventory/items`). Mirror
+ * `createInventoryItemSchema` / `updateInventoryItemSchema` /
+ * `inventoryItemFilterSchema` in `packages/shared/src/validation/inventory.ts`,
+ * redefined here so the published package carries no dependency on
+ * `@blueprint/shared`; `crud-route-types.parity.ts` fails the build when the
+ * two drift.
+ */
+/** Units an inventory item is counted in — mirrors `UNITS_OF_MEASURE`. */
+type InventoryUnitOfMeasure = 'ea' | 'sq' | 'lf' | 'bundle' | 'box' | 'roll' | 'jug' | 'spool';
+/** `POST /admin/inventory/items` body. Money and quantities are decimal strings (`"82.50"`). */
+interface CreateInventoryItemDto {
+    name: string;
+    tradeId: string;
+    unitOfMeasure: InventoryUnitOfMeasure;
+    materialCatalogId?: string | null | undefined;
+    metadata?: Record<string, unknown> | null | undefined;
+    sku?: string | null | undefined;
+    productGroup?: string | null | undefined;
+    description?: string | null | undefined;
+    costDefault?: string | null | undefined;
+    /** Defaults to `true`. */
+    trackStock?: boolean | undefined;
+    reorderPoint?: string | null | undefined;
+    category?: string | null | undefined;
+    manufacturer?: string | null | undefined;
 }
+/** `PUT /admin/inventory/items/{id}` body — any subset of the create fields. */
+type UpdateInventoryItemDto = {
+    [K in keyof CreateInventoryItemDto]?: CreateInventoryItemDto[K] | undefined;
+};
+/** Query for `GET /admin/inventory/items`. Booleans travel as `'true'` / `'false'`. */
+type InventoryItemListParams = {
+    tradeId?: string | undefined;
+    category?: string | undefined;
+    productGroup?: string | undefined;
+    active?: 'true' | 'false' | undefined;
+    trackStock?: 'true' | 'false' | undefined;
+    search?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+};
 
-/** Inventory resource — CRUD operations on /inventory/items. */
-declare class InventoryResource extends BaseResource {
+/** Inventory items — CRUD on /admin/inventory/items (updates are PUT). */
+declare class InventoryResource extends BaseResource<Record<string, unknown>, CreateInventoryItemDto, UpdateInventoryItemDto> {
     constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+    list(params?: InventoryItemListParams): Promise<PaginatedResponse<Record<string, unknown>>>;
+    /** PUT /admin/inventory/items/{id} — partial update. */
+    update(id: string, data: UpdateInventoryItemDto): Promise<Record<string, unknown>>;
+}
+
+/**
+ * The `consent` object on contact-channel and customer reads (E53-F5-S1) —
+ * mirrors `ConsentStateDto` in @blueprint/shared (parity-checked in
+ * `consent-types.parity.ts`).
+ *
+ * Consent is per ADDRESS (a phone number or email), not per record. The
+ * record's own flags say what was set on THIS record; `effective_opted_out`
+ * is the verdict every send honours, which can be true while the record's own
+ * flag is false because another record bearing the same address holds it.
+ */
+/** The newest recorded consent change for the record's address(es). */
+interface ConsentLastChangeDto {
+    outcome: 'revoked' | 'granted';
+    /** `manual`, `stop_reply`, `unsubscribe_link`, `import`, or `integration:<slug>`. */
+    source: string;
+    /** ISO timestamp. */
+    at: string;
+    /** `value`: applied to every record with the address. `row`: a manual un-opt-out of one record. */
+    scope: 'row' | 'value';
+}
+interface ConsentStateDto {
+    /** This record's own marketing opt-out flag. */
+    marketing_opt_out: boolean;
+    /** This record's own do-not-call flag (`dnc` on a channel, `phoneDnc` on a customer). */
+    dnc: boolean;
+    /** By-address verdict across every contact channel and customer bearing the address. */
+    effective_opted_out: {
+        marketing_email: boolean;
+        sms: boolean;
+        call: boolean;
+    };
+    last_change: ConsentLastChangeDto | null;
 }
 
 /**
@@ -240,225 +1071,2690 @@ declare class InventoryResource extends BaseResource {
  * (tenantId, deletedAt, createdBy, …) are intentionally omitted — see
  * `CustomerDto` for the house style.
  */
+
 type ContactSource = 'manual' | 'import' | 'convert_from_customer';
+/**
+ * Query params for `GET /contacts` — mirrors `contactFilterSchema` in
+ * `@blueprint/shared`. `customer_id` / `property_id` return only contacts with
+ * an ACTIVE link to that record; `q` matches a name or a channel value, word
+ * by word (every word must match), so a full name works in either order.
+ * `sort_by: 'name'` is case-insensitive first name then last name; the default
+ * is `created_at` desc. Extends the generic `ListParams` so it stays assignable
+ * to `BaseResource.list`.
+ */
+/** Sortable columns on `GET /contacts` (kept in lockstep with the server enum by the SDK's wire-contract spec). */
+declare const CONTACT_SORT_KEYS: readonly ["name", "created_at", "recent"];
+type ContactSortKey = (typeof CONTACT_SORT_KEYS)[number];
+/**
+ * Related collections `GET /contacts?include=` eager-loads onto each row
+ * (kept in lockstep with the server's `CONTACT_LIST_INCLUDES` by the SDK's
+ * wire-contract spec). `channels` = all channels; `links` = ACTIVE links only.
+ */
+declare const CONTACT_LIST_INCLUDES: readonly ["channels", "links"];
+type ContactListInclude = (typeof CONTACT_LIST_INCLUDES)[number];
+interface ContactListParams extends ListParams {
+    customer_id?: string;
+    property_id?: string;
+    q?: string;
+    /** Mirrors `CONTACT_SORT_KEYS`. `recent` = the calling user's last view, newest first; ignores `sort_order`. */
+    sort_by?: ContactSortKey;
+    sort_order?: 'asc' | 'desc';
+    page?: number;
+    limit?: number;
+    /**
+     * Eager-load related collections onto each row in one request — sent as one
+     * comma-separated value (`include=channels,links`). Use this instead of a
+     * `get()` per row.
+     */
+    include?: ContactListInclude[];
+}
 interface ContactDto {
     id: string;
-    firstName: string;
-    lastName: string | null;
-    notes: string | null;
-    customFields: Record<string, unknown> | null;
-    source: ContactSource | null;
-    createdAt: string;
-    updatedAt: string;
+    firstName: string;
+    lastName: string | null;
+    notes: string | null;
+    customFields: Record<string, unknown> | null;
+    source: ContactSource | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateContactDto {
+    firstName: string;
+    lastName?: string | null;
+    notes?: string | null;
+    customFields?: Record<string, unknown> | null;
+    source?: ContactSource | null;
+}
+interface UpdateContactDto {
+    firstName?: string;
+    lastName?: string | null;
+    notes?: string | null;
+    customFields?: Record<string, unknown> | null;
+    source?: ContactSource | null;
+}
+type ContactChannelType = 'email' | 'phone' | 'url';
+type ContactChannelPhoneType = 'mobile' | 'landline' | 'voip' | 'unknown';
+interface ContactChannelDto {
+    id: string;
+    contactId: string;
+    channelType: ContactChannelType;
+    label: string | null;
+    value: string;
+    isPrimary: boolean;
+    phoneType: ContactChannelPhoneType | null;
+    smsCapable: boolean | null;
+    dnc: boolean | null;
+    marketingOptOut: boolean | null;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Consent for this channel's address (E53-F5-S1): own flags, the
+     * by-address verdict and the newest change. Present on every channel the
+     * API returns (`GET /contacts/:id`, `include=channels`, channel create/update).
+     */
+    consent: ConsentStateDto;
+}
+type ContactLinkTargetType = 'customer' | 'property';
+/** A contact's link to a customer or property (`endedAt` null = active). */
+interface ContactLinkDto {
+    id: string;
+    contactId: string;
+    targetType: ContactLinkTargetType;
+    targetId: string;
+    role: string | null;
+    isPrimary: boolean;
+    endedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * A `GET /contacts` row. `channels` / `links` are present only when requested
+ * via `include` — the same shapes `GET /contacts/:id` returns (links: active only).
+ */
+interface ContactListItemDto extends ContactDto {
+    channels?: ContactChannelDto[];
+    links?: ContactLinkDto[];
+}
+interface CreateContactChannelDto {
+    channelType: ContactChannelType;
+    label?: string | null;
+    value: string;
+    isPrimary?: boolean;
+    dnc?: boolean | null;
+    marketingOptOut?: boolean | null;
+}
+interface UpdateContactChannelDto {
+    label?: string | null;
+    value?: string;
+    isPrimary?: boolean;
+    dnc?: boolean | null;
+    marketingOptOut?: boolean | null;
+}
+/** A channel elsewhere in the tenant with the same normalized value. */
+interface ContactChannelDuplicateMatch {
+    contactId: string;
+    channelId: string;
+    value: string;
+}
+/**
+ * `POST /contacts/:id/channels` return shape — `ContactChannelsService.addChannel()`
+ * always returns this wrapper, never a flat channel. `duplicateOf` is the
+ * dedup signal (empty array when there's no match) — the point of this API
+ * for connectors doing identity resolution (e.g. Messenger).
+ */
+interface AddContactChannelResult {
+    channel: ContactChannelDto;
+    duplicateOf: ContactChannelDuplicateMatch[];
+}
+interface ContactMergeResult {
+    winnerId: string;
+    loserId: string;
+}
+
+/**
+ * `/contacts/:id/channels` — POST/PATCH/DELETE only. There is no list/get
+ * route: reads come embedded in the contact detail response (`GET
+ * /contacts/:id` returns `{ ...contact, channels, links, mergedInto }`), so
+ * this does NOT extend `BaseResource`.
+ */
+declare class ContactChannelResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient, contactId: string);
+    /** Returns `{ channel, duplicateOf }` — `duplicateOf` is the dedup signal. */
+    create(data: CreateContactChannelDto): Promise<AddContactChannelResult>;
+    update(channelId: string, data: UpdateContactChannelDto): Promise<ContactChannelDto>;
+    delete(channelId: string): Promise<void>;
+}
+declare class ContactResource extends BaseResource<ContactDto, CreateContactDto, UpdateContactDto> {
+    constructor(http: ConstructorParameters<typeof BaseResource>[0]);
+    /**
+     * List contacts. Typed against the real filter schema (customer_id /
+     * property_id / q / sort_by / sort_order / page / limit / include) — the base
+     * `list` would accept any key and let a typo reach the server as a 400.
+     * `include: ['channels', 'links']` attaches each row's channels and active
+     * links in the same response.
+     */
+    list(params?: ContactListParams): Promise<PaginatedResponse<ContactListItemDto>>;
+    merge(winnerId: string, loserId: string): Promise<ContactMergeResult>;
+    channels(contactId: string): ContactChannelResource;
+}
+
+/**
+ * Wire shapes for the generic activity/timeline API (E31-F1).
+ *
+ * Mirrors `recordActivitySchema` (write) and `ActivityRecord` (read) in
+ * `packages/shared/src/validation/activity.ts` — both snake_case on the wire.
+ * Types are redefined here (not imported) so the published package carries no
+ * runtime or type dependency on `@blueprint/shared`.
+ */
+interface CreateActivityDto {
+    entity_type: string;
+    entity_id?: string | null;
+    /** The contact a channel-targeted send was addressed to, if any. */
+    contact_id?: string | null;
+    source: string;
+    type: string;
+    occurred_at?: string;
+    actor?: string | null;
+    /** Required — a short human-readable description of the event. */
+    summary: string;
+    external_ref?: string | null;
+    match_key?: string | null;
+    payload?: Record<string, unknown>;
+    payload_version?: number;
+}
+interface ActivityDto {
+    id: string;
+    type: string;
+    source: string;
+    occurred_at: string;
+    actor: string | null;
+    summary: string;
+    entity_type: string;
+    entity_id: string | null;
+    contact_id: string | null;
+    payload: Record<string, unknown>;
+}
+
+declare class ActivityResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(data: CreateActivityDto): Promise<ActivityDto>;
+    list(params?: ListParams): Promise<PaginatedResponse<ActivityDto>>;
+    listForEntity(entityType: string, entityId: string, params?: ListParams): Promise<PaginatedResponse<ActivityDto>>;
+}
+
+/**
+ * Wire shapes for the communications log API (E48-F1).
+ *
+ * Mirrors the schemas in `packages/shared/src/validation/communications.ts`
+ * (logCommunicationSchema, listCommunicationsQuerySchema, linkCommunicationSchema,
+ * CommunicationSummaryDto, CommunicationDto) — all snake_case on the wire.
+ * Types are redefined here (not imported) so the published package carries no
+ * runtime or type dependency on `@blueprint/shared`.
+ */
+interface CommunicationAttachmentDto {
+    name: string;
+    mimeType: string;
+}
+/** `email` (default) or `call`. */
+type CommunicationChannel = 'email' | 'call';
+/** The record levels a communication can be logged against / linked to. */
+type CommunicationEntityType = 'customer' | 'contact' | 'property' | 'opportunity' | 'job';
+/** How a logged call ended. */
+type CallOutcome = 'connected' | 'voicemail' | 'no_answer' | 'busy' | 'left_message';
+/** A record target: both fields together. */
+interface CommunicationTarget {
+    entity_type: CommunicationEntityType;
+    entity_id: string;
+}
+interface LogCommunicationBase {
+    direction: 'inbound' | 'outbound';
+    summary: string;
+    /** Email body, or call notes. Max 64KB. */
+    body?: string;
+    occurred_at: string;
+    via?: 'agent' | 'bcc' | 'gmail' | 'dropbox' | 'manual';
+    /**
+     * The PRIMARY record to log against (any level). Omit for the legacy
+     * behavior: a customer row via `customer_id` / server-side matching.
+     */
+    entity_type?: CommunicationEntityType;
+    entity_id?: string;
+    /** Legacy explicit customer link; must agree with `entity_*` when both given. */
+    customer_id?: string;
+    /** The contact this was with (secondary attribution, any target). */
+    contact_id?: string;
+}
+/** Log an email: `from` and a non-empty `to` are required. */
+interface LogEmailCommunicationDto extends LogCommunicationBase {
+    channel?: 'email';
+    from: string;
+    to: string[];
+    cc?: string[];
+    subject?: string;
+    attachments?: CommunicationAttachmentDto[];
+    /** RFC 5322 Message-ID — the dedupe key. Optional (an outbound API send has none). */
+    provider_message_id?: string | null;
+    thread_id?: string;
+}
+/** Log a call: no addresses; optional number, duration and outcome. */
+interface LogCallCommunicationDto extends LogCommunicationBase {
+    channel: 'call';
+    phone_number?: string;
+    /** 0–1440. */
+    duration_minutes?: number;
+    outcome?: CallOutcome;
+}
+/**
+ * Input for logging a communication: an email (default channel) or a call.
+ * Mirrors `logCommunicationSchema`.
+ */
+type LogCommunicationDto = LogEmailCommunicationDto | LogCallCommunicationDto;
+/**
+ * Result of logging a communication.
+ * Includes the activity ID, link status, and dedup status.
+ */
+interface LogCommunicationResult {
+    activity_id: string;
+    linked: boolean;
+    deduped: boolean;
+}
+/**
+ * Query parameters for listing communications with filters and pagination.
+ * Supports filtering by customer, contact, participant email, direction, date range, and link status.
+ */
+interface ListCommunicationsParams {
+    channel?: CommunicationChannel;
+    /** Filter by the primary record (any level). */
+    entity_type?: CommunicationEntityType;
+    entity_id?: string;
+    /** Legacy: rows whose primary record is this customer. */
+    customer_id?: string;
+    contact_id?: string;
+    participant?: string;
+    direction?: 'inbound' | 'outbound';
+    linked?: boolean | string;
+    from_date?: string;
+    to_date?: string;
+    cursor?: string;
+    limit?: number;
+}
+/**
+ * Keyset-paginated response from list() endpoint.
+ * Uses cursor-based pagination (not offset/limit).
+ */
+interface CommunicationsListResponse {
+    data: CommunicationSummaryDto[];
+    cursor: string | null;
+    has_more: boolean;
+}
+/**
+ * Summary DTO for a communication (list view).
+ * Includes metadata and excerpt, but not the full body or attachments.
+ */
+interface CommunicationSummaryDto {
+    id: string;
+    channel: CommunicationChannel;
+    /** The primary record this row is logged against. */
+    entity_type: string;
+    entity_id: string | null;
+    /** Legacy view: `entity_id` when `entity_type === 'customer'`, else null. */
+    customer_id: string | null;
+    contact_id: string | null;
+    /** True when attached to any record (`entity_id` or `contact_id` set). */
+    linked: boolean;
+    direction: 'inbound' | 'outbound';
+    /** Email only — `''` for a call. */
+    from: string;
+    to: string[];
+    cc: string[];
+    subject: string;
+    summary: string;
+    phone_number: string | null;
+    duration_minutes: number | null;
+    outcome: CallOutcome | null;
+    occurred_at: string;
+    thread_id: string | null;
+    has_attachments: boolean;
+    via: string;
+    /**
+     * The RFC 5322 Message-ID this row was logged/deduped under
+     * (`activity.external_ref`). `CommunicationsService.toSummaryDto` maps a
+     * missing `external_ref` to `''`, never `null` — the field is always a
+     * string on the wire (Gmail Send Phase 1, Task 5 carried parity item).
+     */
+    provider_message_id: string;
+}
+/**
+ * Full DTO for a communication (detail view).
+ * Extends CommunicationSummaryDto with body and attachments.
+ */
+interface CommunicationDto extends CommunicationSummaryDto {
+    body: string;
+    attachments: CommunicationAttachmentDto[];
+}
+/**
+ * Link (or re-link) a communication to a record. Mirrors
+ * `linkCommunicationSchema`: an `entity_type` + `entity_id` target at any
+ * level, or the legacy `customer_id` / `contact_id`; at least one required.
+ */
+interface LinkCommunicationDto {
+    entity_type?: CommunicationEntityType;
+    entity_id?: string;
+    customer_id?: string;
+    contact_id?: string;
+}
+
+declare class CommunicationsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    log(data: LogCommunicationDto): Promise<LogCommunicationResult>;
+    list(params?: ListCommunicationsParams): Promise<CommunicationsListResponse>;
+    get(id: string): Promise<CommunicationDto>;
+    link(id: string, data: LinkCommunicationDto): Promise<CommunicationDto>;
+}
+
+/**
+ * E55 — Conversations SDK types. Redefined here (not imported) so the published
+ * package carries no dependency on @blueprint/shared; conversations.spec.ts
+ * asserts parity with the real Zod schemas.
+ */
+type ConversationKind = 'meeting';
+type ConversationMatchStatus = 'matched' | 'needs_review' | 'ignored';
+type ConversationLinkEntityType = 'customer' | 'opportunity' | 'job';
+interface ConversationAttendeeDto {
+    name?: string | null;
+    email: string;
+}
+interface ConversationActionItemDto {
+    title: string;
+    description?: string | null;
+    assignee_email?: string | null;
+    status?: 'pending' | 'done';
+}
+interface LogConversationDto {
+    kind?: ConversationKind;
+    title: string;
+    occurred_at: string;
+    duration_s?: number;
+    summary_md?: string;
+    attendees?: ConversationAttendeeDto[];
+    action_items?: ConversationActionItemDto[];
+    customer_id?: string;
+    calendar_event_id?: string;
+}
+interface PatchConversationDto {
+    title?: string;
+    summary_md?: string;
+    action_items?: ConversationActionItemDto[];
+}
+interface LinkConversationDto {
+    entity_type: ConversationLinkEntityType;
+    entity_id: string;
+}
+type ResolveConversationMatchDto = {
+    action: 'match';
+    customer_id: string;
+} | {
+    action: 'ignore';
+};
+interface InternalDomainsDto {
+    domains: string[];
+}
+interface ListConversationsParams {
+    entity_type?: ConversationLinkEntityType;
+    entity_id?: string;
+    match_status?: ConversationMatchStatus;
+    limit?: number;
+    offset?: number;
+}
+interface ConversationParticipant {
+    id: string;
+    kind: 'contact' | 'user' | 'unmatched';
+    contact_id: string | null;
+    agent_id: string | null;
+    /**
+     * null either when masked (internal users' emails need Read on Agent) or,
+     * since E57-F2-S1, genuinely null at rest for a name-only attendee.
+     */
+    name: string | null;
+    email: string | null;
+    role: string | null;
+}
+interface ConversationLink {
+    id: string;
+    entity_type: ConversationLinkEntityType;
+    entity_id: string;
+}
+/**
+ * E55-F1-S8 — a company that tied when the conversation landed in the review
+ * queue. `name` is null when the caller can't see that candidate (out of
+ * their RLS scope); the id is still listed.
+ */
+interface ConversationMatchCandidate {
+    customer_id: string;
+    name: string | null;
+    votes: number;
+    via: 'attendee' | 'domain';
+}
+interface Conversation {
+    id: string;
+    kind: ConversationKind;
+    source: string;
+    external_id: string | null;
+    title: string;
+    occurred_at: string;
+    duration_s: number | null;
+    summary_md: string;
+    action_items: ConversationActionItemDto[];
+    provider_insights: Record<string, unknown> | null;
+    has_transcript: boolean;
+    calendar_event_id: string | null;
+    /** E57-F2-S1 — the source provider's meeting URL (e.g. Circleback's `url`). */
+    meeting_url: string | null;
+    match_status: ConversationMatchStatus;
+    match_candidates: ConversationMatchCandidate[];
+    created_at: string;
+    updated_at: string;
+    participants: ConversationParticipant[];
+    links: ConversationLink[];
+}
+interface ConversationListItem {
+    id: string;
+    kind: ConversationKind;
+    source: string;
+    title: string;
+    occurred_at: string;
+    duration_s: number | null;
+    meeting_url: string | null;
+    match_status: ConversationMatchStatus;
+    match_candidates: ConversationMatchCandidate[];
+    participant_count: number;
+    links: ConversationLink[];
+}
+interface ConversationListResponse {
+    data: ConversationListItem[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface LogConversationResult {
+    conversation: Conversation;
+    created: boolean;
+}
+interface InternalDomainsResult {
+    domains: string[];
+    inferred: boolean;
+}
+/**
+ * E57-F2-S4 — the caller's own source connection. Only `disconnect` is
+ * SDK-exposed: `connect` + `callback` are the interactive browser OAuth leg
+ * (authorize redirect → web callback page → POST with the rep's session),
+ * deliberately not an SDK surface.
+ */
+type SourceConnectionStatus = 'connected' | 'disconnected' | 'error';
+interface DisconnectSourceConnectionDto {
+    connectionId: string;
+}
+interface SourceConnectionResult {
+    connectionId: string;
+    status: SourceConnectionStatus;
+}
+/**
+ * E57-F2-S8 — on-demand sync. `pull` backfills one company from every
+ * active teammate's connected source; `syncNow` runs the caller's own
+ * connection; `syncStatus` reports it (plus a restricted roster for admins).
+ */
+interface PullConversationsDto {
+    customer_id: string;
+}
+/** `job_ids` (E57-F2-S9): one per connection — pass them to `getPullStatus`. `job_id` is `job_ids[0]`. */
+interface PullConversationsResult {
+    job_id: string;
+    job_ids: string[];
+    connections: number;
+}
+/**
+ * E57-F2-S9 — whether a Pull has finished. `state` aggregates the jobs:
+ * pending if any is pending; else completed if any completed; else skipped if
+ * any skipped; else failed. `missing` counts expired / unknown ids.
+ */
+type PullStatusState = 'pending' | 'completed' | 'failed' | 'skipped';
+interface PullStatusCounts {
+    listed: number;
+    read: number;
+    ingested: number;
+    duplicate: number;
+    skipped_no_match: number;
+    skipped_internal: number;
+    malformed: number;
+}
+interface PullStatus {
+    state: PullStatusState;
+    jobs: {
+        pending: number;
+        completed: number;
+        failed: number;
+        skipped: number;
+        missing: number;
+    };
+    /** Summed over the finished runs; absent until one reports counts. */
+    counts?: PullStatusCounts;
+}
+interface SyncNowResult {
+    job_id: string;
+    connection_id: string;
+}
+type ConversationSyncErrorClass = 'owner_deactivated' | 'auth_expired' | 'rate_limited' | 'upstream_error' | 'outbound_disabled' | 'malformed_item' | 'internal_error';
+interface ConversationSyncStatusMine {
+    connection_id: string;
+    status: SourceConnectionStatus;
+    last_run_at: string | null;
+    last_success_at: string | null;
+    last_error_class: ConversationSyncErrorClass | null;
+    last_counts: Record<string, number>;
+    backoff_until: string | null;
+}
+/** Admin roster row: exactly these four fields — never an account id or email. */
+interface ConversationSyncRosterItem {
+    agent_id: string;
+    name: string | null;
+    status: SourceConnectionStatus;
+    last_success_at: string | null;
+}
+interface ConversationSyncStatus {
+    mine: ConversationSyncStatusMine | null;
+    has_sources: boolean;
+    /** Present only for a caller who can Update Tenant (an admin). */
+    roster?: ConversationSyncRosterItem[];
+}
+/**
+ * E57-F4-S1 — a synced meeting's transcript, fetched LIVE from the meeting
+ * recorder through the connection that synced it; Planes never stores it.
+ * `timestamp` is the segment start in seconds. `segments: []` means the
+ * recorder has no transcript for the meeting yet (not an error).
+ */
+interface TranscriptSegment {
+    speaker: string | null;
+    text: string;
+    timestamp: number | null;
+}
+interface ConversationTranscript {
+    segments: TranscriptSegment[];
+}
+/** `owner` (default): only the rep whose recorder synced the meeting. `viewers`: anyone who can see the conversation. */
+type TranscriptAccessMode = 'owner' | 'viewers';
+interface TranscriptAccess {
+    transcript_access: TranscriptAccessMode;
+}
+
+/** E55 — client conversations (meetings): log, list, link, review-queue resolve. */
+declare class ConversationsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    log(data: LogConversationDto): Promise<LogConversationResult>;
+    list(params?: ListConversationsParams): Promise<ConversationListResponse>;
+    /** The review queue: `list()` pinned to `match_status: 'needs_review'`. */
+    reviewQueue(params?: Omit<ListConversationsParams, 'match_status'>): Promise<ConversationListResponse>;
+    get(id: string): Promise<Conversation>;
+    update(id: string, data: PatchConversationDto): Promise<Conversation>;
+    delete(id: string): Promise<void>;
+    link(id: string, data: LinkConversationDto): Promise<Conversation>;
+    unlink(id: string, linkId: string): Promise<Conversation>;
+    resolve(id: string, data: ResolveConversationMatchDto): Promise<Conversation>;
+    getInternalDomains(): Promise<InternalDomainsResult>;
+    /** Requires an admin: the server checks `Update` on `Subject.Tenant` (tenant-wide matching config), not `Subject.Conversation`. */
+    setInternalDomains(data: InternalDomainsDto): Promise<InternalDomainsResult>;
+    /**
+     * E57-F2-S4 — disconnect the CALLER's own Circleback connection (Update
+     * Conversation). Another user's connection id is a 404. Connecting is the
+     * interactive browser OAuth flow (Settings → Conversations), not an SDK call.
+     */
+    disconnectCircleback(data: DisconnectSourceConnectionDto): Promise<SourceConnectionResult>;
+    /**
+     * E57-F2-S8 — pull one company's meetings from every active teammate's
+     * connected source (Update Conversation). 202, runs in the background.
+     * 404 for a company you can't see; 409 `NO_SOURCES` when nobody has one.
+     */
+    pull(data: PullConversationsDto): Promise<PullConversationsResult>;
+    /**
+     * E57-F2-S9 — whether a Pull has finished: pass the `job_ids` `pull()`
+     * returned (1–50). Update Conversation, like `pull()`. 404
+     * `PULL_NOT_FOUND` when none of them is readable (expired after ~2h,
+     * unknown) — treat that as settled.
+     */
+    getPullStatus(jobIds: readonly string[]): Promise<PullStatus>;
+    /** E57-F2-S8 — sync the caller's OWN Circleback connection now (deduplicated). 409 `NO_CONNECTION` when they have none. */
+    syncNow(): Promise<SyncNowResult>;
+    /** E57-F2-S8 — the caller's own connection, `has_sources`, and (admins only) the roster. */
+    syncStatus(): Promise<ConversationSyncStatus>;
+    /**
+     * E57-F4-S1 — a synced meeting's transcript, fetched live from the meeting
+     * recorder (never stored by Planes; the response is `Cache-Control:
+     * no-store`). Read Conversation, plus the tenant's transcript-access rule:
+     * 403 `TRANSCRIPT_OWNER_ONLY` under `owner` for a non-owner; 409
+     * `TRANSCRIPT_SOURCE_UNAVAILABLE` (`owner_name` says who must reconnect) or
+     * `TRANSCRIPT_NOT_AVAILABLE` (not a synced meeting); 404 when you can't see
+     * the conversation. `segments: []` = no transcript yet.
+     */
+    getTranscript(id: string): Promise<ConversationTranscript>;
+    /** E57-F4-S1 — who can view transcripts: `owner` (default) or `viewers`. Read Conversation. */
+    getTranscriptAccess(): Promise<TranscriptAccess>;
+    /** E57-F4-S1 — requires an admin: the server checks `Update` on `Subject.Tenant`. */
+    setTranscriptAccess(value: TranscriptAccessMode): Promise<TranscriptAccess>;
+}
+
+/**
+ * Wire shapes for the Gmail send API (Gmail Send Phase 1, Task 4/5).
+ *
+ * Mirrors `sendGmailSchema` / `SendGmailResultDto` in
+ * `packages/shared/src/validation/gmail-send.ts` and the actual return of
+ * `GmailSendService.send()` (`apps/api/src/modules/integrations/google/surfaces/gmail/gmail-send.service.ts`,
+ * `GmailSendResult`). Types are redefined here (not imported) so the
+ * published package carries no runtime or type dependency on
+ * `@blueprint/shared`.
+ */
+/**
+ * Input for sending an email from the connected user's real Gmail address.
+ * `to`/`cc` accept at most 10 combined recipients (enforced server-side);
+ * `reply_to_communication_id` threads the send off a prior communication
+ * (`In-Reply-To`/`References`) via `GmailSendService`'s reply-mode.
+ */
+interface SendGmailDto {
+    to: string[];
+    cc?: string[];
+    subject: string;
+    body: string;
+    reply_to_communication_id?: string;
+    /**
+     * Optional: which of the caller's connected Gmail accounts to send from
+     * (its account email address). Absent sends from the caller's primary
+     * gmail-enabled connection (unchanged prior behavior).
+     */
+    from?: string;
+}
+/**
+ * Result of a successful Gmail send: the logged communication's activity id and
+ * Gmail's own thread id.
+ *
+ * `provider_message_id` is `null` for outbound sends — Gmail asserts its OWN
+ * RFC 5322 Message-ID and discards the one we put in the MIME, and we cannot
+ * read the real one back under the `gmail.send` scope, so there is no real id
+ * to return (and we NEVER return our `<uuid>@planescrm.com` correlation id).
+ * `thread_id` is Gmail's conversation id — the authoritative threading key
+ * (reply grouping keys on it, not on a Message-ID).
+ */
+interface SendGmailResult {
+    communication_id: string;
+    provider_message_id: string | null;
+    thread_id: string;
+}
+
+declare class GmailResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Send an email RIGHT NOW from the connected user's real Gmail address.
+     * Hits `POST /admin/integrations/google/gmail/send` — final per Task 4
+     * (`apps/api/src/modules/integrations/google/google-connection.controller.ts`).
+     */
+    send(data: SendGmailDto): Promise<SendGmailResult>;
+}
+
+/**
+ * Wire shapes for the documents API (Drive Rung 0 — external references).
+ *
+ * Input mirrors `attachExternalDocumentSchema` in
+ * `packages/shared/src/validation/document.ts` (snake_case on the wire).
+ * Responses are the documents API's existing `DocumentDto` (camelCase — it
+ * predates the snake_case convention; transcribed from
+ * DocumentsService.toDto), extended with externalUrl/externalProvider.
+ * Types are redefined here so the published package carries no dependency
+ * on `@blueprint/shared`.
+ */
+type DocumentEntityType = 'opportunity' | 'customer' | 'job' | 'estimate';
+type DocumentKind = 'image' | 'document';
+/** Body for POST /documents/external. */
+interface AttachExternalDocumentDto {
+    entity_type: DocumentEntityType;
+    entity_id: string;
+    /** Becomes the document's fileName (max 255). */
+    title: string;
+    /** Absolute https:// link, max 2048 chars. Stored as data; never fetched by the server. */
+    url: string;
+    /** Lowercase snake_case provider tag. Default 'google_drive'. */
+    provider?: string;
+    /** Default 'text/uri-list'. */
+    mime_type?: string;
+    /** Default 'document'. */
+    kind?: DocumentKind;
+}
+/** A document row — uploaded blob OR external link (exactly one). */
+interface DocumentDto {
+    id: string;
+    entityType: string;
+    entityId: string;
+    customerId: string | null;
+    fileName: string;
+    mimeType: string;
+    sizeBytes: number;
+    kind: DocumentKind;
+    uploadedBy: string | null;
+    createdAt: string;
+    /** Set for external rows; open it directly — there is no download URL for these. */
+    externalUrl: string | null;
+    externalProvider: string | null;
+}
+/** GET /:entityType/:entityId/documents — plain list, not keyset-paginated. */
+interface DocumentsListResponse {
+    data: DocumentDto[];
+}
+
+declare class DocumentsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Attach an external (link-only) document — e.g. a Google Drive link — to a record. */
+    attachExternal(data: AttachExternalDocumentDto): Promise<DocumentDto>;
+    /** Documents filed directly on one record (uploaded + external), newest first. */
+    listForEntity(entityType: DocumentEntityType, entityId: string): Promise<DocumentsListResponse>;
+}
+
+/**
+ * Wire shapes for the Tags & entity-tagging API.
+ *
+ * Mirrors `createTagSchema`/`updateTagSchema`/`setEntityTagsSchema` in
+ * `packages/shared/src/validation/tags.ts`, plus `TagsService`'s actual
+ * response shapes — snake_case, per `toDto()`/`list()`. Types are redefined
+ * here (not imported) so the published package carries no runtime or type
+ * dependency on `@blueprint/shared`.
+ */
+interface TagDto {
+    id: string;
+    name: string;
+    color: string | null;
+    created_at: string;
+    updated_at: string;
+    /** Only present on `list()` — `create()`/`update()` omit it. */
+    usage_count?: number;
+}
+interface CreateTagDto {
+    name: string;
+    color?: string | null;
+}
+interface UpdateTagDto {
+    name?: string;
+    color?: string | null;
+}
+/**
+ * Declarative set-tags input. Provide `tag_ids` and/or `tag_names` — at least
+ * one must be present (the server rejects neither); an empty array clears
+ * that side of the set.
+ */
+interface SetEntityTagsDto {
+    tag_ids?: string[];
+    tag_names?: string[];
+}
+interface EntityTagDto {
+    id: string;
+    name: string;
+    color: string | null;
+}
+interface TagEntityDto {
+    entity_type: string;
+    entity_id: string;
+}
+interface TagEntitiesPage {
+    data: TagEntityDto[];
+    page: number;
+    limit: number;
+    total: number;
+}
+
+/**
+ * Tags. There is no single-tag read: `list()` returns every tag (with usage
+ * counts), and `getEntities()` pages through the records carrying one.
+ */
+declare class TagResource extends ApiResource {
+    constructor(http: ConstructorParameters<typeof ApiResource>[0]);
+    /** GET /tags */
+    list(params?: ListParams): Promise<PaginatedResponse<TagDto>>;
+    /** POST /tags — 409 on a case-insensitive duplicate name. */
+    create(data: CreateTagDto): Promise<TagDto>;
+    /** PATCH /tags/:id — rename / recolor; 409 on a case-insensitive duplicate name. */
+    update(id: string, data: UpdateTagDto): Promise<TagDto>;
+    /** DELETE /tags/:id — cascades the tag off every record. */
+    delete(id: string): Promise<void>;
+    /** `TagsService.setEntityTags()` returns the final tag set wrapped in `{ tags }`. */
+    setEntityTags(entityType: string, entityId: string, data: SetEntityTagsDto): Promise<{
+        tags: TagDto[];
+    }>;
+    getEntityTags(entityType: string, entityId: string): Promise<EntityTagDto[]>;
+    getEntities(tagId: string, params?: Record<string, unknown>): Promise<TagEntitiesPage>;
+}
+
+/**
+ * Wire shapes for the Tasks API (`/api/v1/tasks`, E41-F3).
+ *
+ * Mirrors `createTaskSchema` / `patchTaskSchema` / `listTasksQuerySchema` in
+ * `packages/shared/src/validation/tasks.ts` plus `TasksService.TaskDto`'s
+ * actual response shape — snake_case, Date columns serialised as ISO strings.
+ * Types are redefined here (not imported) so the published package carries no
+ * runtime or type dependency on `@blueprint/shared`; `tasks.spec.ts` asserts
+ * every request body against the REAL shared zod schema.
+ */
+
+type TaskStatus = 'open' | 'in_progress' | 'completed' | 'cancelled';
+type TaskPriority = 'low' | 'normal' | 'high' | 'urgent';
+/** Records a task can hang off (polymorphic link). */
+type TaskEntityType = 'customer' | 'opportunity' | 'job' | 'contract' | 'calendar_event';
+type TaskAssigneeType = 'agent' | 'team';
+/** One assignee to put on a task (an agent or a whole team). */
+interface TaskAssigneeInput {
+    assignee_type: TaskAssigneeType;
+    assignee_id: string;
+    role_label?: string | null;
+}
+/** One assignee as read back — with the agent's display name / team's name. */
+interface TaskAssigneeDto {
+    assignee_type: TaskAssigneeType;
+    assignee_id: string;
+    role_label: string | null;
+    display_name: string | null;
+}
+interface TaskDto {
+    id: string;
+    org_path: string;
+    title: string;
+    description: string | null;
+    status: TaskStatus;
+    priority: TaskPriority;
+    due_at: string | null;
+    entity_type: string | null;
+    entity_id: string | null;
+    /** Parent opportunity id for a job/contract-linked task (nested detail route). */
+    entity_parent_id: string | null;
+    completion_transition_id: string | null;
+    source: string;
+    created_by: string | null;
+    completed_by: string | null;
+    completed_at: string | null;
+    created_at: string;
+    updated_at: string;
+    /** Always present — empty when unassigned. */
+    assignees: TaskAssigneeDto[];
+}
+/**
+ * `POST /tasks/:id/complete` (E46-F6-S8): the completed task plus whether its
+ * "on complete" transition ran. The task completes whatever the outcome; a
+ * `failed` trigger also notifies the tenant's admins. Same shape as the
+ * calendar event completion's `workflow_trigger`.
+ */
+interface CompletedTaskDto extends TaskDto {
+    workflow_trigger: CompletionWorkflowTrigger;
+}
+interface CreateTaskDto {
+    title: string;
+    description?: string | null;
+    /** Defaults to 'normal'. */
+    priority?: TaskPriority;
+    /** ISO 8601. */
+    due_at?: string | null;
+    /** Provide entity_type and entity_id together. */
+    entity_type?: TaskEntityType | null;
+    entity_id?: string | null;
+    /**
+     * Transition to run when the task is completed. Needs a linked record and
+     * must belong to its pipeline (else 422 COMPLETION_TRANSITION_WRONG_PIPELINE).
+     */
+    completion_transition_id?: string | null;
+    /** Up to 50. */
+    assignees?: TaskAssigneeInput[];
+}
+/**
+ * PATCH edits an active task. `status` may only nudge between the two
+ * non-terminal states — completion/cancellation/reopen are explicit actions
+ * (`complete()`, `cancel()`, `reopen()`). `assignees`, when present, is the
+ * FULL desired set (replace-set); `[]` clears every assignee; omit to leave
+ * assignees untouched.
+ */
+interface UpdateTaskDto {
+    title?: string;
+    description?: string | null;
+    priority?: TaskPriority;
+    /** ISO 8601. */
+    due_at?: string | null;
+    status?: 'open' | 'in_progress';
+    assignees?: TaskAssigneeInput[];
+    /**
+     * Transition to run when the task is completed (E46-F6-S8). Must belong to
+     * the linked record's pipeline (else 422 COMPLETION_TRANSITION_WRONG_PIPELINE).
+     * `null` clears it; omit to leave it unchanged.
+     */
+    completion_transition_id?: string | null;
+}
+interface ListTasksParams {
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    /** `'me'` unions tasks assigned directly + via a team the caller belongs to. */
+    assignee?: 'me';
+    /** One specific agent or team — provide together with `assignee_type`. */
+    assignee_id?: string;
+    assignee_type?: TaskAssigneeType;
+    /** `true` → only tasks with no assignee. */
+    unassigned?: boolean;
+    entity_type?: TaskEntityType;
+    entity_id?: string;
+    /** ISO 8601. */
+    due_before?: string;
+    /** ISO 8601. */
+    due_after?: string;
+    overdue?: boolean;
+    /** 1–500, default 100. */
+    limit?: number;
+    offset?: number;
+}
+
+/**
+ * Tasks — the free-core to-do module (`/api/v1/tasks`). `list()` returns a
+ * BARE array (the controller does not wrap in `{ data, meta }`); paginate with
+ * `limit`/`offset`. Terminal status changes go through the explicit action
+ * methods, never `update()`. There is no delete: a task is cancelled
+ * (`cancel()`), and `reopen()` brings it back.
+ */
+declare class TaskResource extends ApiResource {
+    constructor(http: ConstructorParameters<typeof ApiResource>[0]);
+    list(params?: ListTasksParams): Promise<TaskDto[]>;
+    /** GET /tasks/:id */
+    get(id: string): Promise<TaskDto>;
+    /** POST /tasks */
+    create(data: CreateTaskDto): Promise<TaskDto>;
+    /** PATCH /tasks/:id — non-terminal fields only; terminal status changes use the action methods. */
+    update(id: string, data: UpdateTaskDto): Promise<TaskDto>;
+    /**
+     * POST /tasks/:id/complete — fires the linked workflow transition (best-effort).
+     * The task always completes; `workflow_trigger` says whether the next step ran.
+     */
+    complete(id: string): Promise<CompletedTaskDto>;
+    /** POST /tasks/:id/cancel */
+    cancel(id: string): Promise<TaskDto>;
+    /** POST /tasks/:id/reopen — the sanctioned resurrect of a completed/cancelled task. */
+    reopen(id: string): Promise<TaskDto>;
+}
+
+/**
+ * Wire shapes for record views (`/api/v1/record-views`, E41-F7) — the
+ * per-user "recently viewed" primitive behind `sort_by: 'recent'` on the
+ * customer / contact / opportunity / job lists.
+ *
+ * Mirrors `recordViewSchema` / `recentRecordViewsQuerySchema` in
+ * `packages/shared/src/validation/record-view.ts`. Redefined here (not
+ * imported) so the published package carries no dependency on
+ * `@blueprint/shared`; `record-views.spec.ts` asserts every request against the
+ * REAL shared schema.
+ */
+/** Root records whose detail views are counted (kept in lockstep with the server by the wire spec). */
+declare const RECORD_VIEW_ENTITY_TYPES: readonly ["customer", "contact", "opportunity", "job"];
+type RecordViewEntityType = (typeof RECORD_VIEW_ENTITY_TYPES)[number];
+/** Body of `POST /record-views`. The viewer is always the authenticated user. */
+interface RecordViewInput {
+    entity_type: RecordViewEntityType;
+    entity_id: string;
+}
+/** Query of `GET /record-views/recent`. `limit` defaults to 10 on the server, max 50. */
+interface RecentRecordViewsParams {
+    entity_type?: RecordViewEntityType;
+    limit?: number;
+}
+/** One row of `GET /record-views/recent`, newest first. */
+interface RecentRecordView {
+    entity_type: RecordViewEntityType;
+    entity_id: string;
+    /** ISO timestamp of the caller's most recent view. */
+    viewed_at: string;
+}
+
+/**
+ * Record views (`/api/v1/record-views`, E41-F7) — "recently viewed". Not a
+ * CRUD resource (no id, no get/update/delete), so it does NOT extend
+ * `BaseResource`.
+ *
+ * `touch()` is the idempotent beacon a UI sends when a record opens; the server
+ * keeps one row per user × record and answers 204 even for an id that no
+ * longer exists. `recent()` is the caller's newest views. Views feed
+ * `sort_by: 'recent'` on `customers.list` / `contacts.list` /
+ * `opportunities.list` / `jobs.listForOpportunity`.
+ */
+declare class RecordViewsResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /** POST /record-views — record that the calling user opened this record. Resolves on 204. */
+    touch(input: RecordViewInput): Promise<void>;
+    /** GET /record-views/recent — the calling user's most recently viewed records, newest first. */
+    recent(params?: RecentRecordViewsParams): Promise<RecentRecordView[]>;
+}
+
+/**
+ * Wire shapes for tenant module status (`GET /api/v1/modules`, E51-F1-S1).
+ *
+ * Mirrors `tenantModuleStatusSchema` / `MODULE_KEYS` in `packages/shared`.
+ * Redefined here (not imported) so the published package carries no dependency
+ * on `@blueprint/shared`; `modules.spec.ts` asserts key parity and parses the
+ * response with the REAL shared schema.
+ */
+/** Every registered module key, in the server's canonical order. */
+declare const MODULE_KEYS: readonly ["estimates", "contracts", "inventory", "production", "production_scheduling", "calendar", "service-schedules", "marketplace", "invoicing", "knocks", "accounting", "contacts", "tasks", "comments", "conversations"];
+type ModuleKey = (typeof MODULE_KEYS)[number];
+/** One entry of `GET /modules` — whether a module is on for the caller's tenant. */
+interface TenantModuleStatusDto {
+    moduleKey: ModuleKey;
+    /** `false` both for an explicitly deactivated module and one never activated. */
+    isActive: boolean;
+}
+
+/**
+ * Module status (`/api/v1/modules`, E51-F1-S1) — which modules are active for
+ * the caller's tenant. Readable by every role; read-only (activating a module
+ * is an admin action on `/admin/modules`, deliberately not exposed here). Not a
+ * CRUD resource, so it does NOT extend `BaseResource`.
+ */
+declare class ModulesResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /** GET /modules — one entry per registered module key, in canonical order. */
+    list(): Promise<TenantModuleStatusDto[]>;
+}
+
+/**
+ * Wire shapes for the tenant's plan (`GET /api/v1/plan`, E54-F1-S2).
+ *
+ * Mirrors `tenantPlanSchema` and the plan enums in `packages/shared`
+ * (`features/plans.ts`, `features/feature-keys.ts`). Redefined here (not
+ * imported) so the published package carries no dependency on
+ * `@blueprint/shared`; `plan.spec.ts` asserts enum parity and parses the
+ * response with the REAL shared schema.
+ */
+
+declare const PLAN_KEYS: readonly ["solo", "sales", "business", "operations", "legacy", "internal"];
+type PlanKey = (typeof PLAN_KEYS)[number];
+declare const BILLING_STATUSES: readonly ["trialing", "active", "past_due", "unpaid", "paused", "canceled", "comped"];
+type BillingStatus = (typeof BILLING_STATUSES)[number];
+declare const PLAN_SOURCES: readonly ["stripe", "manual"];
+type PlanSource = (typeof PLAN_SOURCES)[number];
+declare const BILLING_INTERVALS: readonly ["month", "year"];
+type BillingInterval = (typeof BILLING_INTERVALS)[number];
+/** Every feature-flag key a plan ceiling can include, in the server's order. */
+declare const FEATURE_KEYS: readonly ["calendar", "estimates", "contracts", "service_dispatch", "production_scheduling", "sub_management", "reports", "open_api", "workflow_builder", "integrations.quickbooks", "integrations.stripe", "integrations.hover", "integrations.ortto", "communications.marketing", "ai.scheduling", "ai.content_assist", "ai.documents", "ai.search", "inventory_management", "workflow_execution", "marketplace"];
+type FeatureKey = (typeof FEATURE_KEYS)[number];
+/** `GET /plan` — the caller tenant's plan, billing state and plan ceiling. */
+interface TenantPlanDto {
+    planKey: PlanKey;
+    /** Display name, e.g. "Business". */
+    label: string;
+    billingStatus: BillingStatus;
+    /** Who last set the plan: `stripe` (subscription webhook) or `manual` (Planes staff). */
+    planSource: PlanSource;
+    /** ISO-8601, or null when not trialing. */
+    trialEndsAt: string | null;
+    billingInterval: BillingInterval | null;
+    /** ISO-8601 end of a price lock (Founding Fleet), or null. */
+    priceLockedUntil: string | null;
+    /** Module keys the plan may enable (a ceiling, not what is switched on). */
+    modules: ModuleKey[];
+    /** Feature keys the plan may enable. */
+    features: FeatureKey[];
+    includedFullSeats: number;
+    crewSeatsAllowed: boolean;
+    monthlyAiCredits: number;
+    storageGb: number;
+}
+
+/**
+ * The caller tenant's plan (`/api/v1/plan`, E54-F1-S2). Readable by every role;
+ * read-only — plans change through Stripe-hosted billing in Settings → Billing,
+ * deliberately not through the API. Not a CRUD resource, so it does NOT extend
+ * `BaseResource`.
+ */
+declare class PlanResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /** GET /plan — plan, billing status and the plan's ceiling. */
+    get(): Promise<TenantPlanDto>;
+}
+
+/**
+ * Wire shapes for `GET /api/v1/me/abilities` (E52-F1-S3).
+ *
+ * Mirrors `meAbilitiesResponseSchema` / `AGENT_ROLES` in `packages/shared`.
+ * Redefined here (not imported) so the published package carries no dependency
+ * on `@blueprint/shared`; `me.spec.ts` asserts role parity and parses the
+ * response with the REAL shared schema.
+ */
+/** Every built-in role, in the server's canonical order. */
+declare const AGENT_ROLES: readonly ["admin", "sales", "service", "production", "sub", "readonly", "system_agent"];
+type AgentRole = (typeof AGENT_ROLES)[number];
+/**
+ * One CASL packed rule (`packRules` from `@casl/ability/extra`):
+ * `[action, subject, conditions|0, inverted 1|0, fields|0, reason]`, trailing
+ * empty slots trimmed. Rebuild the ability with
+ * `createMongoAbility(unpackRules(rules))`.
+ */
+type PackedAbilityRule = [string, string] | [string, string, Record<string, unknown>] | [string, string, Record<string, unknown> | 0, 1] | [string, string, Record<string, unknown> | 0, 1 | 0, string] | [string, string, Record<string, unknown> | 0, 1 | 0, string | 0, string];
+/** `GET /me/abilities` — the caller's effective ability. */
+interface MeAbilitiesResponse {
+    /** Live role (session), key role (API key) or token role (service token). */
+    role: AgentRole;
+    /** API keys only: the acting agent's live role; `rules` are the intersection. */
+    actingRole?: AgentRole;
+    /** Same value as the `X-Planes-Abilities-Version` response header. Opaque — compare, don't parse. */
+    version: string;
+    /** The exact rules the server enforces for this caller, CASL-packed. */
+    rules: PackedAbilityRule[];
+}
+
+/**
+ * The authenticated caller (`/api/v1/me/*`, E52-F1-S3). Any principal may read
+ * its own abilities; not a CRUD resource, so it does NOT extend `BaseResource`.
+ */
+declare class MeResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /**
+     * GET /me/abilities — the caller's effective ability: for an API key, the key
+     * role intersected with its acting agent's live role (`actingRole`).
+     */
+    abilities(): Promise<MeAbilitiesResponse>;
+}
+
+/**
+ * Wire shapes for Settings → Roles (`/api/v1/roles`, E52-F2-S3/S4/S5).
+ *
+ * Mirrors `roleSummarySchema`, `roleDetailSchema`, `updateRoleGrantsRequestSchema`
+ * and `roleHistoryPageSchema` in `packages/shared/src/auth/roles-api.ts`.
+ * Redefined here (not imported) so the published package carries no dependency
+ * on `@blueprint/shared`; `roles.spec.ts` parses every request body with the
+ * REAL shared request schema and every response fixture with the REAL
+ * response schemas, so drift fails there rather than as a production 400.
+ */
+
+/** Every role Settings → Roles shows (all built-in roles but `system_agent`). */
+type RoleKey = Exclude<AgentRole, 'system_agent'>;
+/** The roles whose grants can be changed (`admin` never is). */
+type TunableRole = Exclude<RoleKey, 'admin'>;
+/** A cell's stored state: `default` = no change from the Planes default. */
+type GrantEffect = 'allow' | 'deny' | 'default';
+/** `shell` and `company` cells are locked; `financial` needs confirmation to grant. */
+type GrantTier = 'shell' | 'record' | 'financial' | 'company';
+/** `GET /roles` row. */
+interface RoleSummaryDto {
+    key: RoleKey;
+    label: string;
+    tunable: boolean;
+    /** Active users with this role. */
+    userCount: number;
+    /** Cells changed from the Planes default. */
+    changeCount: number;
+}
+interface RoleListResponse {
+    data: RoleSummaryDto[];
+}
+/** One (action × subject) cell of the matrix. */
+interface RoleCellDto {
+    /** e.g. `read`, `create`, `update`, `delete`, `approve`, `mark_paid`. */
+    action: string;
+    /** e.g. `Customer`, `Invoice`, `Paysheet`. */
+    subject: string;
+    /** The role holds it now. */
+    value: boolean;
+    /** The Planes built-in value. */
+    default: boolean;
+    tier: GrantTier;
+    /** Can't be toggled (shell/company tier, a long-standing default, or admin). */
+    locked: boolean;
+}
+interface RoleRowDto {
+    /** The subject-catalog row id, e.g. `customers`. */
+    rowId: string;
+    cells: RoleCellDto[];
+}
+/** `GET /roles/:key`, and the response of every write. */
+interface RoleDetailDto {
+    key: RoleKey;
+    label: string;
+    tunable: boolean;
+    /** One sentence, e.g. "Can create and edit Customers …; can't delete Customers." */
+    summary: string;
+    /** The tenant's grant version — send it back as `baseVersion` to detect concurrent edits. */
+    version: string;
+    rows: RoleRowDto[];
+}
+/** One sparse change in `PUT /roles/:key/grants`. */
+interface RoleGrantChange {
+    action: string;
+    subject: string;
+    effect: GrantEffect;
+}
+/** `PUT /roles/:key/grants` body. */
+interface UpdateRoleGrantsBody {
+    /** 1–200 changes, at most one per (action, subject). */
+    changes: RoleGrantChange[];
+    /** Required (`true`) with `reason` when a change grants a money action. */
+    confirm?: boolean;
+    /** Required with `confirm` when a change grants a money action (≤ 500 chars). */
+    reason?: string;
+    /** The `version` the edit was based on; a newer server version is a 409. */
+    baseVersion?: string;
+}
+/** `GET /roles/history` query. */
+interface RoleHistoryParams {
+    role?: TunableRole;
+    /** The previous page's `cursor`. */
+    cursor?: string;
+    /** 1–100 (server default 50). */
+    limit?: number;
+}
+interface RoleHistoryEntryDto {
+    id: string;
+    /** Null when the platform made the change. */
+    actorAgentId: string | null;
+    actorName: string | null;
+    roleKey: TunableRole;
+    action: string;
+    subject: string;
+    before: GrantEffect;
+    after: GrantEffect;
+    reason: string | null;
+    createdAt: string;
+}
+/** Cursor page, newest first. */
+interface RoleHistoryPage {
+    data: RoleHistoryEntryDto[];
+    cursor: string | null;
+    has_more: boolean;
+}
+
+/**
+ * Settings → Roles (`/api/v1/roles`, E52-F2). Admin only: reads need Read
+ * RolePermission and writes Update RolePermission, which only admins hold —
+ * any other caller gets a 403 `FORBIDDEN_BY_ROLE`. Not a CRUD resource, so it
+ * does NOT extend `BaseResource`.
+ */
+declare class RolesResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /** GET /roles — every role (not `system_agent`) with user and change counts. */
+    list(): Promise<RoleListResponse>;
+    /** GET /roles/:key — one role's permission matrix, summary and grant version. */
+    get(key: RoleKey): Promise<RoleDetailDto>;
+    /**
+     * PUT /roles/:key/grants — sparse per-cell changes, all validated before any
+     * is written. 422 `GRANT_REQUIRED` / `GRANT_NOT_DELEGABLE` for locked cells,
+     * `CONFIRMATION_REQUIRED` when a money action is granted without
+     * `confirm: true` + `reason`, `ROLE_NOT_TUNABLE` for admin; 409
+     * `ROLE_VERSION_CONFLICT` on a stale `baseVersion`. Returns the updated role.
+     */
+    updateGrants(key: TunableRole, body: UpdateRoleGrantsBody): Promise<RoleDetailDto>;
+    /** DELETE /roles/:key/grants — back to the Planes defaults. Returns the reset role. */
+    reset(key: TunableRole): Promise<RoleDetailDto>;
+    /** GET /roles/history — the change log, newest first; page with `cursor`. */
+    history(params?: RoleHistoryParams): Promise<RoleHistoryPage>;
+}
+
+/** Body and response of `admin/invoice-settings/offline-instructions`. */
+interface OfflineInstructionsDto {
+    instructions: string | null;
+}
+/** Body and response of `admin/invoice-settings/overdue-offsets` (E56-F8-S2). */
+interface OverdueOffsetsDto {
+    /** Days after the due date at which `invoice.overdue` fires, ascending. */
+    offsets: number[];
+}
+/** Body and response of `admin/invoice-settings/attach-pdf` (E56-F6-S2). */
+interface AttachPdfSettingDto {
+    enabled: boolean;
+}
+/**
+ * Per-tenant invoice settings (`/api/v1/admin/invoice-settings`, E56-F5-S4).
+ * Reads need Read Invoice; writes need Update Tenant (admin only) — any other
+ * caller gets a 403 `FORBIDDEN_BY_ROLE`. Not a CRUD resource, so it does NOT
+ * extend `BaseResource`.
+ */
+declare class InvoiceSettingsResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /**
+     * GET /admin/invoice-settings/offline-instructions — the plain-text
+     * instructions shown on the pay page when online payment is unavailable,
+     * or null when none are set.
+     */
+    getOfflineInstructions(): Promise<string | null>;
+    /**
+     * PUT /admin/invoice-settings/offline-instructions — store plain text
+     * (trimmed, at most 2,000 characters); null or blank clears it. Returns the
+     * stored value.
+     */
+    setOfflineInstructions(text: string | null): Promise<string | null>;
+    /**
+     * GET /admin/invoice-settings/overdue-offsets — the days after the due date
+     * at which `invoice.overdue` fires, ascending (default `[3, 7, 14]`).
+     */
+    getOverdueOffsets(): Promise<number[]>;
+    /**
+     * PUT /admin/invoice-settings/overdue-offsets — replace the offsets: 1 to 5
+     * unique whole days, each 1–90. Returns them sorted ascending. Admin only.
+     */
+    setOverdueOffsets(offsets: number[]): Promise<number[]>;
+    /**
+     * GET /admin/invoice-settings/attach-pdf — whether invoice emails carry the
+     * invoice PDF (on unless an admin turned it off).
+     */
+    getAttachPdf(): Promise<boolean>;
+    /**
+     * PUT /admin/invoice-settings/attach-pdf — turn the PDF attachment on
+     * invoice emails on or off. Returns the stored value.
+     */
+    setAttachPdf(enabled: boolean): Promise<boolean>;
+}
+
+/** Who a reminder rule emails about: every overdue invoice, or recurring ones only. */
+type InvoiceReminderAppliesTo = 'all' | 'recurring_only';
+/**
+ * One rule as sent to `invoiceReminders.update()` (mirrors the shared
+ * `invoiceReminderRuleSchema` input; the spec parses the captured body with it).
+ */
+interface InvoiceReminderRuleInputDto {
+    /** Days past due the reminder sends at, 1–90, unique across the set. */
+    offsetDays: number;
+    enabled: boolean;
+    /** Plain text, ≤ 200 chars. Placeholders: see `update()`. */
+    subject: string;
+    /** Plain text, ≤ 5,000 chars. */
+    body: string;
+    /** Defaults to `'all'`. */
+    appliesTo?: InvoiceReminderAppliesTo;
+}
+/** A stored rule (mirrors `invoiceReminderRuleResponseSchema`). */
+interface InvoiceReminderRuleDto {
+    offsetDays: number;
+    enabled: boolean;
+    subject: string;
+    body: string;
+    appliesTo: InvoiceReminderAppliesTo;
+    /** The offset is not in the overdue offsets, so this rule never sends. */
+    willNeverFire: boolean;
+}
+/** GET / PUT `admin/invoice-reminders` (mirrors `invoiceReminderSettingsSchema`). */
+interface InvoiceReminderSettingsDto {
+    rules: InvoiceReminderRuleDto[];
+    /** The days past due the overdue sweep fires at (`invoiceSettings.getOverdueOffsets()`). */
+    overdueOffsets: number[];
+}
+/** Body of `invoiceReminders.preview()` (mirrors `invoiceReminderPreviewSchema`). */
+interface InvoiceReminderPreviewParams {
+    subject: string;
+    body: string;
+    /** Render against this invoice; omit for a sample invoice. */
+    invoiceId?: string;
+}
+/** What a reminder would send (mirrors `invoiceReminderPreviewResultSchema`). */
+interface InvoiceReminderPreviewDto {
+    subject: string;
+    body: string;
+    /** True when rendered against the sample invoice. */
+    sample: boolean;
+}
+/**
+ * Payment reminder settings (`/api/v1/admin/invoice-reminders`, E56-F8-S6).
+ * Admin only (Update Tenant) — reads included; anyone else gets a 403
+ * `FORBIDDEN_BY_ROLE`. Not a CRUD resource, so it does NOT extend `BaseResource`.
+ */
+declare class InvoiceRemindersResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /** GET /admin/invoice-reminders — the rules, ascending by offset, and the overdue offsets. */
+    list(): Promise<InvoiceReminderSettingsDto>;
+    /**
+     * PUT /admin/invoice-reminders — replace the WHOLE rule set (a rule left out
+     * is deleted): up to 5 rules at unique offsets. Templates may use only
+     * `{{customerName}}`, `{{invoiceNumber}}`, `{{amountDue}}`, `{{total}}`,
+     * `{{dueDate}}`, `{{daysOverdue}}` and `{{companyName}}`; any other is a 422
+     * `REMINDER_TEMPLATE_INVALID` listing each one. Returns the stored set.
+     */
+    update(rules: InvoiceReminderRuleInputDto[]): Promise<InvoiceReminderSettingsDto>;
+    /**
+     * POST /admin/invoice-reminders/preview — render a subject and body exactly
+     * as the reminder email would, against an invoice or a sample. Sends nothing.
+     */
+    preview(params: InvoiceReminderPreviewParams): Promise<InvoiceReminderPreviewDto>;
+}
+
+/**
+ * Wire shapes for enrollable sequences (`GET /api/v1/contact-sequences`,
+ * E51-F2-S6).
+ *
+ * Mirrors `contactSequenceSchema` / `contactSequenceListResponseSchema` in
+ * `packages/shared`. Redefined here (not imported) so the published package
+ * carries no dependency on `@blueprint/shared`; `contact-sequences.spec.ts`
+ * parses the response with the REAL shared schema.
+ */
+/** A published sequence a contact can be enrolled in. */
+interface ContactSequenceDto {
+    /** Lineage root id — pass as `workflow_id` when enrolling a contact. */
+    id: string;
+    name: string;
+    description: string | null;
+}
+/** `GET /contact-sequences` envelope — name-sorted, at most 100 rows. */
+interface ContactSequenceListResponse {
+    data: ContactSequenceDto[];
+    meta: {
+        total: number;
+    };
+}
+
+/**
+ * Enrollable sequences (`/api/v1/contact-sequences`, E51-F2-S6) — the published
+ * contact sequences in the caller's tenant, readable by any role that can enroll
+ * a contact. Read-only (authoring sequences stays on the admin workflow API). Not
+ * a CRUD resource, so it does NOT extend `BaseResource`.
+ */
+declare class ContactSequencesResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /** GET /contact-sequences — `{ data, meta: { total } }`, name-sorted, max 100. */
+    list(): Promise<ContactSequenceListResponse>;
+}
+
+/**
+ * Wire shapes for contact sequence enrollments (E51-F2-S8):
+ * `POST /contacts/:id/enrollments`, `GET /contacts/:id/enrollments`,
+ * `POST /enrollments/:id/exit`.
+ *
+ * Mirrors `enrollContactBodySchema` / `enrollmentStatusQuerySchema` /
+ * `contactEnrollmentSchema` / `contactEnrollmentListItemSchema` in
+ * `packages/shared` (which the API pins to the real ContactEnrollmentsService
+ * return shapes). Redefined here (not imported) so the published package carries
+ * no dependency on `@blueprint/shared`; `enrollments.spec.ts` validates requests
+ * and fixtures with the REAL shared schemas.
+ */
+type EnrollmentStatus = 'active' | 'completed' | 'exited';
+/** Enrollment provenance — `{ type: 'manual' | 'tag_added' | 'list_joined', tag_id?, list_id? }`. */
+interface EnrollmentTrigger {
+    type: string;
+    [key: string]: unknown;
+}
+/** An enrollment row — returned by `enroll()` and `exit()`. */
+interface ContactEnrollmentDto {
+    id: string;
+    tenantId: string;
+    contactId: string;
+    /** Sequence lineage root — the `workflow_id` it was enrolled with. */
+    workflowParentId: string;
+    trigger: EnrollmentTrigger;
+    status: EnrollmentStatus;
+    /** Set when exited (`'manual'`, `'opted_out'`, `'goal_met'`, ...). */
+    exitReason: string | null;
+    createdAt: string;
+    endedAt: string | null;
+}
+/** One row of `list()` — the enrollment plus its sequence name and current stage. */
+interface ContactEnrollmentListItemDto {
+    id: string;
+    contactId: string;
+    workflowParentId: string;
+    trigger: EnrollmentTrigger;
+    status: EnrollmentStatus;
+    exitReason: string | null;
+    createdAt: string;
+    endedAt: string | null;
+    currentStageId: string | null;
+    currentStageName: string | null;
+    sequenceName: string | null;
+}
+interface ListEnrollmentsParams {
+    status?: EnrollmentStatus;
+}
+
+/**
+ * Contact sequence enrollments (E51-F2-S8) — enroll a contact in a sequence, list
+ * its enrollments, and manually exit one. Pick the sequence with
+ * `client.contactSequences.list()`; its `id` is the `workflowId` here. Not a CRUD
+ * resource, so it does NOT extend `BaseResource`.
+ */
+declare class EnrollmentsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * POST /contacts/:id/enrollments — `{ workflow_id }`. 409 if the contact is
+     * already active in the sequence; 422 if the sequence has no published version.
+     */
+    enroll(contactId: string, workflowId: string): Promise<ContactEnrollmentDto>;
+    /** GET /contacts/:id/enrollments — a bare array, newest first; optional `status` filter. */
+    list(contactId: string, params?: ListEnrollmentsParams): Promise<ContactEnrollmentListItemDto[]>;
+    /**
+     * POST /enrollments/:id/exit — no body; the exit reason is recorded as
+     * `'manual'`. Idempotent: an already-ended enrollment is returned unchanged.
+     */
+    exit(enrollmentId: string): Promise<ContactEnrollmentDto>;
+}
+
+/**
+ * Wire shapes for a workflow's event rules on the admin workflow API
+ * (`/api/v1/admin/workflows/:workflowId/event-rules`) — "advance this record
+ * automatically when a related contract / invoice / calendar event changes".
+ *
+ * Mirrors `workflow-event-rule.ts` in `packages/shared`. Redefined here (not
+ * imported) so the published package carries no dependency on
+ * `@blueprint/shared`; `workflow-event-rule-types.parity.ts` fails the build
+ * when the two drift, and `workflow-event-rules.spec.ts` parses every sent body
+ * with the REAL shared schemas.
+ */
+/**
+ * Event types a rule can route on. Must equal the shared
+ * `WORKFLOW_EVENT_RULE_EVENT_TYPES`, in order — the parity check and the spec
+ * both pin it.
+ */
+declare const WORKFLOW_EVENT_RULE_EVENT_TYPES: readonly ["contract.status_changed", "invoice.status_changed", "calendar_event.status_changed", "calendar_event.created"];
+type WorkflowEventRuleEventType = (typeof WORKFLOW_EVENT_RULE_EVENT_TYPES)[number];
+/**
+ * Event types whose event carries no `changes` (a creation), so the only
+ * matcher that can match is `when: {}`.
+ */
+declare const WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES: readonly WorkflowEventRuleEventType[];
+/**
+ * Equality matcher over the event's `changes` map:
+ * `{ status: { new: 'sent' } }` matches an event whose
+ * `changes.status.new === 'sent'`. Each entry must name `old`, `new` or both
+ * (an entry naming neither is a 400); `{}` matches every event of the type.
+ */
+type WorkflowEventRuleWhen = Record<string, {
+    old?: unknown;
+    new?: unknown;
+}>;
+/**
+ * The transition to fire, by stage NAME, resolved against whichever workflow
+ * version the record is pinned to — so a rule survives a version publish.
+ */
+interface WorkflowTransitionRef {
+    from_stage_name: string;
+    to_stage_name: string;
+}
+/** Body of `POST /admin/workflows/:workflowId/event-rules`. */
+interface CreateWorkflowEventRuleInput {
+    eventType: WorkflowEventRuleEventType;
+    /** Defaults to `{}` (every event of the type). */
+    when?: WorkflowEventRuleWhen | undefined;
+    transitionRef: WorkflowTransitionRef;
+    /** Defaults to true. */
+    enabled?: boolean | undefined;
+}
+/** Body of `PATCH /admin/workflows/:workflowId/event-rules/:id` — at least one field; only the fields sent change. */
+interface UpdateWorkflowEventRuleInput {
+    eventType?: WorkflowEventRuleEventType | undefined;
+    when?: WorkflowEventRuleWhen | undefined;
+    transitionRef?: WorkflowTransitionRef | undefined;
+    enabled?: boolean | undefined;
+}
+/**
+ * An event rule as the admin API returns it (list, create, update) — exactly
+ * the shared `WorkflowEventRuleDto`. 0.53.0 dropped `tenantId`, `createdBy` and
+ * `deletedAt`, which the server no longer sends.
+ */
+interface WorkflowEventRuleDto {
+    id: string;
+    /** The workflow's LINEAGE ROOT id — the same for every version of one pipeline. */
+    workflowId: string;
+    /** TEXT on the server, so a rule stored with a newer type still reads back. */
+    eventType: string;
+    when: WorkflowEventRuleWhen;
+    transitionRef: WorkflowTransitionRef;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Response of `DELETE /admin/workflows/:workflowId/event-rules/:id` (200; the delete is soft). */
+interface DeleteWorkflowEventRuleResult {
+    id: string;
+}
+
+/**
+ * One workflow's event rules on the admin workflow API
+ * (`/api/v1/admin/workflows/:workflowId/event-rules`; manage Workflow + the
+ * `workflow_builder` feature). Get one with `client.workflows.eventRules(id)`;
+ * `workflowId` may be any version's id — the server keys rules by the lineage
+ * root, so they survive a publish. Not flat CRUD (no single-rule read), so it
+ * does NOT extend `BaseResource`.
+ */
+declare class WorkflowEventRulesResource {
+    private readonly http;
+    readonly workflowId: string;
+    constructor(http: HttpClient, workflowId: string);
+    /** GET — a bare array of the workflow's live rules, newest first. 404 `WORKFLOW_NOT_FOUND`. */
+    list(): Promise<WorkflowEventRuleDto[]>;
+    /**
+     * POST — add a rule (201). `when` defaults to `{}` and `enabled` to true; use
+     * `when: {}` for the creation types in `WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES`.
+     * 400 `VALIDATION_FAILED` for a bad body; 404 `WORKFLOW_NOT_FOUND`.
+     */
+    create(input: CreateWorkflowEventRuleInput): Promise<WorkflowEventRuleDto>;
+    /** PATCH /:id — only the fields sent change (at least one). 404 `EVENT_RULE_NOT_FOUND`. */
+    update(ruleId: string, input: UpdateWorkflowEventRuleInput): Promise<WorkflowEventRuleDto>;
+    /** DELETE /:id — soft delete; returns `{ id }` (200). 404 `EVENT_RULE_NOT_FOUND`. */
+    delete(ruleId: string): Promise<DeleteWorkflowEventRuleResult>;
+}
+
+/**
+ * Wire shapes for one workflow version's stages (`GET /api/v1/workflows/:id/stages`).
+ *
+ * Mirrors `workflowVersionStageSchema` / `workflowVersionStagesResponseSchema`
+ * in `packages/shared`. Redefined here (not imported) so the published package
+ * carries no dependency on `@blueprint/shared`; `workflows.spec.ts` parses the
+ * response with the REAL shared schema.
+ */
+type WorkflowEntityType = 'opportunity' | 'job' | 'purchase_order' | 'estimate' | 'contact' | 'contact_enrollment';
+/** How an end stage finished — set on every terminal stage (E2-F7-S6). */
+type WorkflowEndOutcome = 'won' | 'lost' | 'other';
+/** One stage of a workflow version — only what a stage progress bar draws. */
+interface WorkflowVersionStageDto {
+    id: string;
+    name: string;
+    color: string | null;
+    icon: string | null;
+    sortOrder: number;
+    isInitial: boolean;
+    isTerminal: boolean;
+    /** Won / lost / other on a terminal stage; null on every other stage. */
+    endOutcome: WorkflowEndOutcome | null;
+}
+/**
+ * The ordered stages (sortOrder ascending) of ONE workflow version — the version
+ * a record's workflow instance is pinned to, which may be an archived version
+ * still holding records.
+ */
+interface WorkflowVersionStagesResponse {
+    id: string;
+    name: string;
+    entityType: WorkflowEntityType;
+    version: number;
+    status: 'published' | 'archived';
+    stages: WorkflowVersionStageDto[];
+}
+
+/**
+ * Wire shapes for authoring a workflow transition on the admin workflow API
+ * (`POST /api/v1/admin/workflows/:wid/transitions`,
+ * `PUT /api/v1/admin/workflows/:wid/transitions/:tid`).
+ *
+ * Mirrors `createTransitionSchema` / `updateTransitionSchema` and
+ * `WorkflowTransitionDto` in `packages/shared`. Redefined here (not imported) so
+ * the published package carries no dependency on `@blueprint/shared`;
+ * `workflows.spec.ts` parses every sent body with the REAL shared schemas.
+ */
+/** Body of `POST /admin/workflows/:wid/transitions` (the workflow must be a draft). */
+interface CreateWorkflowTransitionInput {
+    fromStageId: string;
+    toStageId: string;
+    name: string;
+    description?: string | null;
+    requiredRoles?: string[] | null;
+    requiredFields?: string[] | null;
+    /**
+     * Fired only by automation (event rules, workflow actions, stage timers,
+     * completion links); never offered as a manual move, and a manual execute is
+     * a 422 `TRANSITION_AUTOMATIC_ONLY`. Defaults to false.
+     */
+    automaticOnly?: boolean;
+    sortOrder?: number;
+}
+/** Body of `PUT /admin/workflows/:wid/transitions/:tid` — only the fields sent change. */
+interface UpdateWorkflowTransitionInput {
+    name?: string;
+    description?: string | null;
+    requiredRoles?: string[] | null;
+    requiredFields?: string[] | null;
+    automaticOnly?: boolean;
+    sortOrder?: number;
+}
+/** A workflow transition row as the admin API returns it. */
+interface WorkflowTransitionDto {
+    id: string;
+    workflowId: string;
+    fromStageId: string;
+    toStageId: string;
+    name: string;
+    description: string | null;
+    requiredRoles: string[] | null;
+    requiredFields: string[] | null;
+    automaticOnly: boolean;
+    sortOrder: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+/**
+ * Wire shapes for `GET /api/v1/workflows/transitions` — transition summaries
+ * across the tenant's published workflows, or one workflow version's.
+ *
+ * Mirrors `transitionSummarySchema` / `transitionSummariesResponseSchema` /
+ * `transitionSummariesQuerySchema` in `packages/shared`. Redefined here (not
+ * imported) so the published package carries no dependency on
+ * `@blueprint/shared`; `workflows.spec.ts` parses the response and the sent
+ * query with the REAL shared schemas.
+ */
+
+/** One transition of a workflow version. snake_case, as the server sends it. */
+interface TransitionSummaryDto {
+    id: string;
+    name: string;
+    from_stage_name: string;
+    to_stage_name: string;
+    workflow_name: string;
+    entity_type: WorkflowEntityType;
+    /** The workflow version row this transition belongs to. */
+    workflow_id: string;
+    workflow_version: number;
+    /** Lineage root (`COALESCE(parent_id, id)`) — the same for every version of one pipeline. */
+    lineage_workflow_id: string;
+    /** Fired only by automation; never offered as a manual move (E2-F10). */
+    automatic_only: boolean;
+}
+interface TransitionSummariesResponse {
+    transitions: TransitionSummaryDto[];
+}
+interface ListTransitionSummariesParams {
+    /** Only these workflow entity types (sent comma-separated as `entity_types`). */
+    entityTypes?: WorkflowEntityType[];
+    /**
+     * ONE workflow version's transitions, published or archived — pass a record's
+     * instance `workflowId` (the version it is pinned to). Sent as `workflow_id`.
+     * Without it only published versions are listed. Combined with
+     * `entityTypes` it is an AND.
+     */
+    workflowId?: string;
+}
+
+/**
+ * Tenant-readable workflow reads (`/api/v1/workflows`), plus transition
+ * authoring on the admin workflow API (`/api/v1/admin/workflows`, which needs
+ * the `workflow_builder` feature and a draft workflow), and a workflow's event
+ * rules via `eventRules(workflowId)`. Not a CRUD resource, so it does NOT
+ * extend `BaseResource`.
+ */
+declare class WorkflowsResource {
+    private readonly http;
+    private readonly basePath;
+    private readonly adminPath;
+    constructor(http: HttpClient);
+    /**
+     * GET /workflows/:id/stages — the ordered stages of one workflow version. Pass
+     * a record's instance `workflowId` (e.g. from `GET /opportunities/:id/workflow`)
+     * to get the stages of the version that record is pinned to, even an archived
+     * one. 404 for an unknown or draft id; 403 if the caller cannot read the
+     * workflow's record type.
+     */
+    getStages(workflowId: string): Promise<WorkflowVersionStagesResponse>;
+    /**
+     * GET /workflows/transitions — transition summaries of every published
+     * workflow, or with `workflowId` of that one version (published or archived;
+     * an unknown, draft or other-tenant id returns an empty list). Each summary
+     * carries `workflow_id`, `workflow_version`, `lineage_workflow_id` and
+     * `automatic_only`. Only pipelines whose record type the caller can read
+     * are listed; an unreadable `workflowId` returns an empty list, not 403.
+     */
+    listTransitions(params?: ListTransitionSummariesParams): Promise<TransitionSummariesResponse>;
+    /**
+     * POST /admin/workflows/:wid/transitions — add a transition to a draft
+     * workflow. Pass `automaticOnly: true` for an edge only automation should
+     * fire (e.g. an event rule advancing on "contract sent").
+     */
+    createTransition(workflowId: string, input: CreateWorkflowTransitionInput): Promise<WorkflowTransitionDto>;
+    /**
+     * The event rules of one workflow (`/admin/workflows/:wid/event-rules`) —
+     * "advance automatically when…". Any version's id works; rules are keyed by
+     * the lineage root.
+     */
+    eventRules(workflowId: string): WorkflowEventRulesResource;
+    /** PUT /admin/workflows/:wid/transitions/:tid — update a draft workflow's transition. */
+    updateTransition(workflowId: string, transitionId: string, input: UpdateWorkflowTransitionInput): Promise<WorkflowTransitionDto>;
+}
+
+/**
+ * Crew conflict preview (`POST /api/v1/service-schedules/conflicts/preview`).
+ *
+ * Mirrors `conflictPreviewSchema` / `conflictPreviewResponseSchema` in
+ * `packages/shared` — redefined here so the published package carries no
+ * dependency on `@blueprint/shared`; `service-schedules.spec.ts` parses the
+ * request the SDK sends and a real-shaped response with the REAL shared
+ * schemas, and pins these types to the shared inferred ones.
+ */
+/** A person to check. Matched by `id`; `type` is accepted for parity with event participants. */
+interface ConflictPreviewParticipant {
+    id: string;
+    type?: string | undefined;
+}
+/** A proposed booking window (ISO 8601 instants, `ends_at` after `starts_at`). */
+interface ConflictPreviewWindow {
+    starts_at: string;
+    ends_at: string;
+    /** All-day booking: the working-hours check only asks whether each day covered is a working day. */
+    all_day?: boolean | undefined;
+}
+/** Recurring mode: a schedule cadence, expanded over `horizon_weeks` (default 8, max 104) from `dtstart`. */
+interface ConflictPreviewSchedule {
+    dtstart: string;
+    recurrence_rule: string;
+    /** YYYY-MM-DD dates to skip. */
+    recurrence_exceptions?: string[] | undefined;
+    /** IANA zone, e.g. `America/Chicago`. */
+    timezone: string;
+    default_duration_min: number;
+    horizon_weeks?: number | undefined;
+}
+/** Give exactly one of `windows` or `schedule`. */
+interface ConflictPreviewRequest {
+    participants: ConflictPreviewParticipant[];
+    windows?: ConflictPreviewWindow[] | undefined;
+    schedule?: ConflictPreviewSchedule | undefined;
+    /** Editing an event: ignore itself. */
+    exclude_event_id?: string | undefined;
+    /** Editing a schedule: ignore its own generated visits. */
+    exclude_schedule_id?: string | undefined;
+}
+interface ConflictWindowFields {
+    /** Index into the request's `windows`, or the occurrence ordinal in recurring mode. */
+    window_index: number;
+    /** Recurring mode only: the occurrence's local YYYY-MM-DD. */
+    occurrence_date?: string | undefined;
+    starts_at: string;
+    ends_at: string;
+    agent_id: string;
+    agent_display_name: string | null;
+}
+/** The person is already on another live event (any type, or time off) during the window. */
+interface CrewOverlapConflictDto extends ConflictWindowFields {
+    kind: 'overlap';
+    event_id: string;
+    event_title: string;
+    event_starts_at: string;
+    event_ends_at: string;
+    event_type: string;
+}
+/**
+ * The window is outside the person's working hours (their own, else the
+ * company default, in their timezone). People with no hours configured are
+ * never reported.
+ */
+interface WorkingHoursConflictDto extends ConflictWindowFields {
+    kind: 'outside_working_hours';
+    /** `not_working_day`: they don't work that weekday. `outside_hours`: they do, but not then. */
+    reason: 'not_working_day' | 'outside_hours';
+    /** Their local date the verdict is about (YYYY-MM-DD). */
+    local_date: string;
+    /** 0=Sunday..6=Saturday. */
+    day_of_week: number;
+    /** That day's hours ('HH:mm') for `outside_hours`; null for `not_working_day`. */
+    working_start: string | null;
+    working_end: string | null;
+    /** IANA zone the hours are in. */
+    timezone: string;
+}
+interface ConflictPreviewResponse {
+    conflicts: CrewOverlapConflictDto[];
+    working_hours: WorkingHoursConflictDto[];
+    /** How many windows were expanded and checked (0 conflicts ≠ 0 windows). */
+    windows_checked: number;
+}
+
+/**
+ * Recurring-service scheduling reads (`/api/v1/service-schedules`). Only the
+ * crew conflict preview for now. Not a CRUD resource, so it does NOT extend
+ * `BaseResource`.
+ */
+declare class ServiceSchedulesResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /**
+     * POST /service-schedules/conflicts/preview — before booking people, see
+     * who is already on another event (`conflicts`) and who would be outside
+     * their working hours (`working_hours`). Read-only and warn-only: nothing
+     * is ever blocked. Give exactly one of `windows` (single booking) or
+     * `schedule` (a cadence). 400 on invalid input, INVALID_RECURRENCE_RULE,
+     * INVALID_TIMEZONE or TOO_MANY_WINDOWS (> 400).
+     */
+    previewConflicts(request: ConflictPreviewRequest): Promise<ConflictPreviewResponse>;
+}
+
+/**
+ * Wire shapes for recurring billing schedules (`/admin/billing-schedules`,
+ * E56-F3-S1/S2). snake_case on the wire, money and quantities as 2dp decimal
+ * strings, dates as `YYYY-MM-DD` and timestamps as ISO strings.
+ *
+ * Mirrors the schemas in `packages/shared/src/validation/billing-schedule.ts`
+ * (request bodies are their `z.input`, responses their `z.infer`, which are the
+ * services' declared return types). Redefined here (not imported) so the
+ * published package carries no dependency on `@blueprint/shared`;
+ * `billing-schedule-types.parity.ts` fails `tsc` if a shape drifts, and
+ * `billing-schedules.spec.ts` parses every request body the SDK sends with the
+ * REAL shared schema.
+ */
+declare const BILLING_CADENCES: readonly ["weekly", "every_n_weeks", "monthly", "quarterly", "annually"];
+type BillingCadence = (typeof BILLING_CADENCES)[number];
+declare const BILLING_SCHEDULE_STATUSES: readonly ["active", "paused", "ended"];
+type BillingScheduleStatus = (typeof BILLING_SCHEDULE_STATUSES)[number];
+declare const BILL_TIMINGS: readonly ["in_advance", "in_arrears"];
+type BillTiming = (typeof BILL_TIMINGS)[number];
+declare const BILLING_DELIVERY_MODES: readonly ["auto_send", "draft_for_review"];
+type BillingDeliveryMode = (typeof BILLING_DELIVERY_MODES)[number];
+/**
+ * `autopay` charges the customer's saved default card after each invoice is
+ * sent (E56-F7-S4). It needs a platform-managed Stripe connection and a saved
+ * default card on it — otherwise 422 `AUTOPAY_UNAVAILABLE` with a `reason`.
+ */
+declare const BILLING_COLLECTION_MODES: readonly ["send_link", "autopay"];
+type BillingCollectionMode = (typeof BILLING_COLLECTION_MODES)[number];
+/** Why autopay cannot be turned on (`AUTOPAY_UNAVAILABLE`'s `reason`). */
+declare const AUTOPAY_UNAVAILABLE_REASONS: readonly ["no_connect", "no_saved_method"];
+type AutopayUnavailableReason = (typeof AUTOPAY_UNAVAILABLE_REASONS)[number];
+/**
+ * Autopay state of one ledger row (E56-F7-S4). `scheduled` / `retry_scheduled`
+ * charge at `autopay_next_attempt_at`; `submitted` waits for Stripe's webhook;
+ * `auth_required` emailed the customer the pay link and is never retried;
+ * `abandoned` makes no more automatic tries. `failed` is reserved.
+ */
+declare const BILLING_AUTOPAY_STATUSES: readonly ["not_applicable", "scheduled", "submitted", "succeeded", "failed", "auth_required", "retry_scheduled", "abandoned"];
+type BillingAutopayStatus = (typeof BILLING_AUTOPAY_STATUSES)[number];
+/** A backdated create must choose: skip the past periods, or draft an invoice for each. */
+declare const BILLING_BACKFILL_MODES: readonly ["skip", "draft"];
+type BillingBackfillMode = (typeof BILLING_BACKFILL_MODES)[number];
+declare const BILLING_PERIOD_STATUSES: readonly ["generated", "skipped", "needs_review", "failed", "voided"];
+type BillingPeriodStatus = (typeof BILLING_PERIOD_STATUSES)[number];
+/** A preview row's state: its ledger status, or `upcoming` with no ledger row yet. */
+declare const BILLING_PREVIEW_PERIOD_STATUSES: readonly ["generated", "skipped", "needs_review", "failed", "voided", "upcoming"];
+type BillingPreviewPeriodStatus = (typeof BILLING_PREVIEW_PERIOD_STATUSES)[number];
+declare const BILLING_DELIVERY_STATUSES: readonly ["pending", "sent", "failed", "not_applicable"];
+type BillingDeliveryStatus = (typeof BILLING_DELIVERY_STATUSES)[number];
+/** One-off adjustment state (E56-F8-S5): `pending` until an invoice carries it. */
+declare const BILLING_ADJUSTMENT_STATUSES: readonly ["pending", "consumed", "cancelled"];
+type BillingAdjustmentStatus = (typeof BILLING_ADJUSTMENT_STATUSES)[number];
+/** Where an adjustment lands: only the schedule's next generated invoice for now. */
+declare const BILLING_ADJUSTMENT_TARGETS: readonly ["next_invoice"];
+type BillingAdjustmentTarget = (typeof BILLING_ADJUSTMENT_TARGETS)[number];
+type BillingInvoiceTerms = 'due_on_receipt' | 'net_15' | 'net_30' | 'net_60';
+type BillingInvoiceStatus = 'draft' | 'sent' | 'partially_paid' | 'paid' | 'void' | 'uncollectible';
+interface BillingScheduleLineInput {
+    description: string;
+    /** Decimal string greater than zero, up to 2 decimals. */
+    quantity: string;
+    /** Decimal string, up to 2 decimals. */
+    unit_price: string;
+}
+/**
+ * `POST /admin/billing-schedules`. `timezone` defaults to the tenant's. When
+ * `start_date` is before today in that zone, `backfill` is required (else 400
+ * `BACKFILL_REQUIRED` with the past-period count).
+ */
+interface CreateBillingScheduleDto {
+    customer_id: string;
+    property_id?: string | null | undefined;
+    contract_id?: string | null | undefined;
+    name: string;
+    cadence: BillingCadence;
+    interval_count?: number | undefined;
+    /** Monthly schedules only (1–31; short months bill on their last day). */
+    anchor_day?: number | null | undefined;
+    timezone?: string | undefined;
+    start_date: string;
+    end_date?: string | null | undefined;
+    end_after_count?: number | null | undefined;
+    bill_timing?: BillTiming | undefined;
+    lead_days?: number | undefined;
+    terms?: BillingInvoiceTerms | undefined;
+    tax_amount?: string | undefined;
+    currency?: string | undefined;
+    delivery?: BillingDeliveryMode | undefined;
+    collection?: BillingCollectionMode | undefined;
+    memo?: string | null | undefined;
+    lines: BillingScheduleLineInput[];
+    backfill?: BillingBackfillMode | undefined;
+}
+/**
+ * `PATCH /admin/billing-schedules/:id` — partial; `customer_id` can't change,
+ * null clears an optional field and `lines` replaces every line from
+ * `effective_from` (a new line version). Changing the cadence after the first
+ * invoice is 409 `CADENCE_LOCKED`.
+ */
+interface UpdateBillingScheduleDto {
+    property_id?: string | null | undefined;
+    contract_id?: string | null | undefined;
+    name?: string | undefined;
+    cadence?: BillingCadence | undefined;
+    interval_count?: number | undefined;
+    anchor_day?: number | null | undefined;
+    timezone?: string | undefined;
+    start_date?: string | undefined;
+    end_date?: string | null | undefined;
+    end_after_count?: number | null | undefined;
+    bill_timing?: BillTiming | undefined;
+    lead_days?: number | undefined;
+    terms?: BillingInvoiceTerms | undefined;
+    tax_amount?: string | undefined;
+    currency?: string | undefined;
+    delivery?: BillingDeliveryMode | undefined;
+    collection?: BillingCollectionMode | undefined;
+    memo?: string | null | undefined;
+    lines?: BillingScheduleLineInput[] | undefined;
+    /**
+     * `YYYY-MM-DD` the sent `lines` take effect: periods starting on or after it
+     * bill them. Needs `lines`. Omitted = the next period not yet invoiced; a
+     * date inside an invoiced period is 422 `EFFECTIVE_DATE_IN_GENERATED_PERIOD`.
+     */
+    effective_from?: string | undefined;
+}
+/** `GET /admin/billing-schedules` query. */
+interface BillingScheduleListParams {
+    customer_id?: string | undefined;
+    status?: BillingScheduleStatus | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+}
+/** `GET /admin/billing-schedules/:id/preview` query: `count` 1–24, default 6. */
+interface BillingSchedulePreviewParams {
+    count?: number | undefined;
+}
+/** `GET /admin/billing-schedules/:id/periods` query. */
+interface BillingSchedulePeriodListParams {
+    status?: BillingPeriodStatus | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+}
+/** `GET /admin/billing-schedules/periods/needs-review` query. */
+interface BillingNeedsReviewParams {
+    page?: number | undefined;
+    limit?: number | undefined;
+}
+/** `POST /admin/billing-schedules/:id/periods/:periodStart/skip` body. */
+interface SkipBillingPeriodDto {
+    reason?: string | undefined;
+}
+/**
+ * `POST /admin/billing-schedules/:id/adjustments` (E56-F8-S5). `amount` is a
+ * signed 2dp decimal string: negative for a credit. Zero, or a credit larger
+ * than the next invoice, is 422 `ADJUSTMENT_INVALID`.
+ */
+interface CreateBillingAdjustmentDto {
+    description: string;
+    amount: string;
+    /** Defaults to `next_invoice`. */
+    apply_to?: BillingAdjustmentTarget | undefined;
+}
+/** `GET /admin/billing-schedules/:id/adjustments` query. Omitted status: pending and consumed. */
+interface BillingAdjustmentListParams {
+    status?: BillingAdjustmentStatus | undefined;
+}
+/** One upcoming period: when it generates and when the invoice is due. */
+interface BillingUpcomingPeriod {
+    index: number;
+    start: string;
+    end: string;
+    generate_at: string;
+    due_date: string;
+}
+interface BillingScheduleLine {
+    id: string;
+    description: string;
+    quantity: string;
+    unit_price: string;
+    sort_order: number;
+}
+/**
+ * One version of a schedule's lines: periods starting on or after
+ * `effective_from` (until the next version's date) bill them.
+ */
+interface BillingScheduleLineVersion {
+    id: string;
+    schedule_id: string;
+    effective_from: string;
+    note: string | null;
+    created_by: string | null;
+    created_at: string;
+    lines: BillingScheduleLine[];
+}
+/** `GET /admin/billing-schedules/:id/versions`: newest effective date first. */
+interface BillingScheduleLineVersionListResponse {
+    data: BillingScheduleLineVersion[];
+}
+/**
+ * Returned by create, update, pause, resume and end. `lines` are what the next
+ * invoice bills (the line version in effect at `next_period`).
+ */
+interface BillingSchedule {
+    id: string;
+    customer_id: string;
+    property_id: string | null;
+    contract_id: string | null;
+    name: string;
+    status: BillingScheduleStatus;
+    currency: string;
+    cadence: BillingCadence;
+    interval_count: number;
+    anchor_day: number | null;
+    timezone: string;
+    start_date: string;
+    end_date: string | null;
+    end_after_count: number | null;
+    bill_timing: BillTiming;
+    lead_days: number;
+    terms: BillingInvoiceTerms;
+    tax_amount: string;
+    delivery: BillingDeliveryMode;
+    collection: BillingCollectionMode;
+    memo: string | null;
+    lines: BillingScheduleLine[];
+    next_generate_at: string | null;
+    /** The next unbilled period, or null once the schedule has ended. */
+    next_period: BillingUpcomingPeriod | null;
+    created_at: string;
+    updated_at: string;
+}
+/** The customer's saved default card, as shown before turning autopay on. */
+interface SavedPaymentMethodSummary {
+    brand: string;
+    last4: string;
+    exp_month: number;
+    exp_year: number;
+}
+/**
+ * `GET /admin/billing-schedules/:id`: the schedule plus its next 3 periods, and
+ * whether autopay can be turned on (the same check as `AUTOPAY_UNAVAILABLE`).
+ */
+interface BillingScheduleDetail extends BillingSchedule {
+    upcoming_periods: BillingUpcomingPeriod[];
+    /** The customer's active default card, or null. */
+    saved_method: SavedPaymentMethodSummary | null;
+    autopay_available: boolean;
+    autopay_unavailable_reason: AutopayUnavailableReason | null;
+}
+/** One list row: no lines, but their count and the next invoice's total (lines + tax). */
+interface BillingScheduleListItem extends Omit<BillingSchedule, 'lines'> {
+    next_amount: string;
+    line_count: number;
+    /** Display name of the schedule's customer; null if the customer row is gone. */
+    customer_name: string | null;
+}
+/** A one-off adjustment line a preview period includes. */
+interface BillingPreviewAdjustment {
+    id: string;
+    description: string;
+    amount: string;
 }
-interface CreateContactDto {
-    firstName: string;
-    lastName?: string | null;
-    notes?: string | null;
-    customFields?: Record<string, unknown> | null;
-    source?: ContactSource | null;
+interface BillingSchedulePreviewPeriod extends BillingUpcomingPeriod {
+    subtotal: string;
+    tax: string;
+    total: string;
+    status: BillingPreviewPeriodStatus;
+    /**
+     * One-off adjustments included in the amounts: pending ones on the next
+     * unbilled period, consumed ones on the period that billed them. Absent when none.
+     */
+    adjustments?: BillingPreviewAdjustment[] | undefined;
 }
-interface UpdateContactDto {
-    firstName?: string;
-    lastName?: string | null;
-    notes?: string | null;
-    customFields?: Record<string, unknown> | null;
-    source?: ContactSource | null;
+/** `GET /admin/billing-schedules/:id/preview`. */
+interface BillingSchedulePreview {
+    schedule_id: string | null;
+    currency: string;
+    periods: BillingSchedulePreviewPeriod[];
 }
-type ContactChannelType = 'email' | 'phone' | 'url';
-type ContactChannelPhoneType = 'mobile' | 'landline' | 'voip' | 'unknown';
-interface ContactChannelDto {
+/**
+ * One period-ledger row with its invoice and delivery state.
+ * `schedule_snapshot` (what the period would bill) is present only on rows
+ * with no invoice.
+ */
+interface BillingSchedulePeriod {
     id: string;
-    contactId: string;
-    channelType: ContactChannelType;
-    label: string | null;
-    value: string;
-    isPrimary: boolean;
-    phoneType: ContactChannelPhoneType | null;
-    smsCapable: boolean | null;
-    dnc: boolean | null;
-    marketingOptOut: boolean | null;
-    createdAt: string;
-    updatedAt: string;
+    schedule_id: string;
+    period_start: string;
+    period_end: string;
+    invoice_id: string | null;
+    superseded_invoice_id: string | null;
+    status: BillingPeriodStatus;
+    delivery_status: BillingDeliveryStatus;
+    delivery_attempts: number;
+    last_error: string | null;
+    reason: string | null;
+    generated_at: string | null;
+    /** Autopay state (E56-F7-S4); `not_applicable` on send_link schedules. */
+    autopay_status: BillingAutopayStatus;
+    /** The current charge attempt (1 or 2). */
+    autopay_attempt: number | null;
+    /** What the current attempt charges, in cents. */
+    autopay_amount_cents: number | null;
+    /** Unknown-outcome re-drives of the current attempt (max 5). */
+    autopay_error_tries: number;
+    autopay_next_attempt_at: string | null;
+    autopay_last_error: string | null;
+    autopay_payment_intent_id: string | null;
+    created_at: string;
+    updated_at: string;
+    invoice_number: string | null;
+    invoice_status: BillingInvoiceStatus | null;
+    /** Number of the voided invoice a regenerate replaced (null when none). */
+    superseded_invoice_number: string | null;
+    schedule_snapshot?: Record<string, unknown> | undefined;
 }
-interface CreateContactChannelDto {
-    channelType: ContactChannelType;
-    label?: string | null;
-    value: string;
-    isPrimary?: boolean;
-    dnc?: boolean | null;
-    marketingOptOut?: boolean | null;
+/** A tenant-wide Needs review row: the ledger row plus its schedule and customer. */
+interface BillingNeedsReviewItem extends BillingSchedulePeriod {
+    schedule_name: string;
+    customer_id: string;
+    customer_name: string | null;
 }
-interface UpdateContactChannelDto {
-    label?: string | null;
-    value?: string;
-    isPrimary?: boolean;
-    dnc?: boolean | null;
-    marketingOptOut?: boolean | null;
+type BillingScheduleListResponse = PaginatedResponse<BillingScheduleListItem>;
+type BillingSchedulePeriodListResponse = PaginatedResponse<BillingSchedulePeriod>;
+type BillingNeedsReviewResponse = PaginatedResponse<BillingNeedsReviewItem>;
+/**
+ * `GET /admin/billing-schedules/autopay-summary` — what disconnecting Stripe
+ * would touch: live autopay schedules, the distinct customers on them, and
+ * active saved cards on the tenant's current Stripe connection.
+ */
+interface BillingAutopaySummary {
+    autopaySchedules: number;
+    customers: number;
+    savedCards: number;
 }
-/** A channel elsewhere in the tenant with the same normalized value. */
-interface ContactChannelDuplicateMatch {
-    contactId: string;
-    channelId: string;
-    value: string;
+interface BillingAutopaySummaryResponse {
+    data: BillingAutopaySummary;
 }
 /**
- * `POST /contacts/:id/channels` return shape — `ContactChannelsService.addChannel()`
- * always returns this wrapper, never a flat channel. `duplicateOf` is the
- * dedup signal (empty array when there's no match) — the point of this API
- * for connectors doing identity resolution (e.g. Messenger).
+ * `POST /admin/billing-schedules/:id/generate-now`. `delivery: 'queued'` means
+ * the auto_send delivery job was enqueued after commit; read its outcome from
+ * the period ledger.
  */
-interface AddContactChannelResult {
-    channel: ContactChannelDto;
-    duplicateOf: ContactChannelDuplicateMatch[];
+type GenerateNowResult = {
+    status: 'generated';
+    invoice_id: string;
+    period_start: string;
+    delivery: 'queued' | 'not_applicable';
+} | {
+    status: 'already_generated';
+    invoice_id: string;
+    period_start: string;
+};
+/** `POST /admin/billing-schedules/:id/periods/:periodStart/regenerate`. */
+interface RegeneratePeriodResult {
+    invoice_id: string;
+    superseded_invoice_id: string;
+    delivery: 'queued' | 'not_applicable';
 }
-interface ContactMergeResult {
-    winnerId: string;
-    loserId: string;
+/** A one-off adjustment on a schedule's next invoice (E56-F8-S5). */
+interface BillingAdjustment {
+    id: string;
+    schedule_id: string;
+    description: string;
+    amount: string;
+    apply_to: BillingAdjustmentTarget;
+    status: BillingAdjustmentStatus;
+    /** The invoice that carried it (set once consumed). */
+    consumed_invoice_id: string | null;
+    consumed_period_start: string | null;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** `GET /admin/billing-schedules/:id/adjustments`: oldest first. */
+interface BillingAdjustmentListResponse {
+    data: BillingAdjustment[];
 }
 
 /**
- * `/contacts/:id/channels` — POST/PATCH/DELETE only. There is no list/get
- * route: reads come embedded in the contact detail response (`GET
- * /contacts/:id` returns `{ ...contact, channels, links, mergedInto }`), so
- * this does NOT extend `BaseResource`.
+ * Recurring billing schedules (`/admin/billing-schedules`, E56-F3-S1/S2):
+ * CRUD, pause / resume / end, preview, the period ledger, the tenant-wide
+ * Needs review queue, generate-now, per-period skip / regenerate, and one-off
+ * adjustments on the next invoice (E56-F8-S5). Needs the
+ * invoicing module; reads need Read and writes Update on BillingSchedule.
  */
-declare class ContactChannelResource {
-    private readonly http;
-    private readonly basePath;
-    constructor(http: HttpClient, contactId: string);
-    /** Returns `{ channel, duplicateOf }` — `duplicateOf` is the dedup signal. */
-    create(data: CreateContactChannelDto): Promise<AddContactChannelResult>;
-    update(channelId: string, data: UpdateContactChannelDto): Promise<ContactChannelDto>;
-    delete(channelId: string): Promise<void>;
-}
-declare class ContactResource extends BaseResource<ContactDto, CreateContactDto, UpdateContactDto> {
+declare class BillingScheduleResource extends BaseResource<BillingSchedule, CreateBillingScheduleDto, UpdateBillingScheduleDto, BillingScheduleListResponse> {
     constructor(http: ConstructorParameters<typeof BaseResource>[0]);
-    merge(winnerId: string, loserId: string): Promise<ContactMergeResult>;
-    channels(contactId: string): ContactChannelResource;
+    /** GET /admin/billing-schedules — list rows (no lines; `line_count` and `next_amount` instead). */
+    list(params?: BillingScheduleListParams): Promise<BillingScheduleListResponse>;
+    /** GET /admin/billing-schedules/:id — the schedule with its lines and next 3 periods. */
+    get(id: string): Promise<BillingScheduleDetail>;
+    /**
+     * POST /admin/billing-schedules. `timezone` defaults to the tenant's. A
+     * backdated `start_date` needs `backfill` ('skip' | 'draft'), else 400
+     * `BACKFILL_REQUIRED`; `collection: 'autopay'` without a platform-managed
+     * Stripe connection and a saved default card is 422 `AUTOPAY_UNAVAILABLE`
+     * (`reason` `no_connect` | `no_saved_method`).
+     */
+    create(data: CreateBillingScheduleDto): Promise<BillingSchedule>;
+    /**
+     * PATCH /admin/billing-schedules/:id — partial. `lines` replaces every line
+     * from `effective_from` (default: the next period not yet invoiced) as a new
+     * line version. 409 `CADENCE_LOCKED`; 422 `EFFECTIVE_DATE_IN_GENERATED_PERIOD`
+     * for a date inside an invoiced period.
+     */
+    update(id: string, data: UpdateBillingScheduleDto): Promise<BillingSchedule>;
+    /** DELETE /admin/billing-schedules/:id — only a schedule that never invoiced (else 409 `SCHEDULE_HAS_INVOICES`). */
+    delete(id: string): Promise<void>;
+    /** GET /admin/billing-schedules/:id/versions — line version history, newest effective date first. */
+    listVersions(id: string): Promise<BillingScheduleLineVersionListResponse>;
+    /**
+     * POST /admin/billing-schedules/:id/adjustments — add a one-off amount
+     * (signed; negative is a credit) to the schedule's next generated invoice.
+     * Billed exactly once; no automatic proration. 422 `ADJUSTMENT_INVALID`
+     * (zero, or the next invoice would go below zero) or `SCHEDULE_NOT_ACTIVE`.
+     */
+    addAdjustment(id: string, data: CreateBillingAdjustmentDto): Promise<BillingAdjustment>;
+    /** GET /admin/billing-schedules/:id/adjustments — oldest first; default pending and consumed. */
+    listAdjustments(id: string, params?: BillingAdjustmentListParams): Promise<BillingAdjustmentListResponse>;
+    /**
+     * DELETE /admin/billing-schedules/:id/adjustments/:adjustmentId — cancel a
+     * pending adjustment (it never bills). Returns it; 409
+     * `ADJUSTMENT_ALREADY_CONSUMED` once an invoice carries it.
+     */
+    cancelAdjustment(id: string, adjustmentId: string): Promise<BillingAdjustment>;
+    /** POST /admin/billing-schedules/:id/pause — 409 `INVALID_STATUS_TRANSITION` unless active. */
+    pause(id: string): Promise<BillingSchedule>;
+    /** POST /admin/billing-schedules/:id/resume — periods that fell due while paused are skipped. */
+    resume(id: string): Promise<BillingSchedule>;
+    /** POST /admin/billing-schedules/:id/end — no further periods generate. */
+    end(id: string): Promise<BillingSchedule>;
+    /** GET /admin/billing-schedules/:id/preview — the next `count` (1–24, default 6) periods from the first unbilled one. */
+    preview(id: string, params?: BillingSchedulePreviewParams): Promise<BillingSchedulePreview>;
+    /** GET /admin/billing-schedules/:id/periods — the period ledger, newest first. */
+    periods(id: string, params?: BillingSchedulePeriodListParams): Promise<BillingSchedulePeriodListResponse>;
+    /**
+     * GET /admin/billing-schedules/periods/needs-review — tenant-wide: needs_review
+     * rows plus failed and stuck (pending over 2h) deliveries.
+     */
+    needsReview(params?: BillingNeedsReviewParams): Promise<BillingNeedsReviewResponse>;
+    /**
+     * GET /admin/billing-schedules/autopay-summary — what disconnecting Stripe
+     * would touch: live autopay schedules, the distinct customers on them, and
+     * active saved cards on the current Stripe connection. On disconnect, autopay
+     * schedules that can no longer charge switch to emailed pay links.
+     */
+    autopaySummary(): Promise<BillingAutopaySummaryResponse>;
+    /**
+     * POST /admin/billing-schedules/:id/generate-now — bill the current due
+     * period now. Idempotent (`already_generated`); 409 `NOTHING_DUE` or
+     * `SCHEDULE_NOT_ACTIVE`.
+     */
+    generateNow(id: string): Promise<GenerateNowResult>;
+    /**
+     * POST /admin/billing-schedules/:id/periods/:periodStart/skip — skip one
+     * period (`periodStart` is `YYYY-MM-DD`). Returns the skipped ledger row;
+     * 400 `NOT_A_PERIOD`, 409 `PERIOD_ALREADY_INVOICED`.
+     */
+    skipPeriod(id: string, periodStart: string, data?: SkipBillingPeriodDto): Promise<BillingSchedulePeriod>;
+    /**
+     * POST /admin/billing-schedules/:id/periods/:periodStart/regenerate — re-bill
+     * a period whose invoice was voided (new draft on the same ledger row).
+     * 409 `INVOICE_NOT_VOID` or `CHECKOUT_IN_FLIGHT`.
+     */
+    regeneratePeriod(id: string, periodStart: string): Promise<RegeneratePeriodResult>;
 }
 
 /**
- * Wire shapes for the generic activity/timeline API (E31-F1).
+ * Value types for `GET /custom-fields` definitions (E38-F9).
  *
- * Mirrors `recordActivitySchema` (write) and `ActivityRecord` (read) in
- * `packages/shared/src/validation/activity.ts` — both snake_case on the wire.
+ * Mirrors `CustomFieldEntityType` / `CustomFieldType` /
+ * `CustomFieldValidationRules` in `packages/shared/src/custom-fields/types.ts`.
  * Types are redefined here (not imported) so the published package carries no
- * runtime or type dependency on `@blueprint/shared`.
+ * dependency on `@blueprint/shared`; `custom-field-types.parity.ts` fails the
+ * build when either side drifts.
  */
-interface CreateActivityDto {
-    entity_type: string;
-    entity_id?: string | null;
-    /** The contact a channel-targeted send was addressed to, if any. */
-    contact_id?: string | null;
-    source: string;
-    type: string;
-    occurred_at?: string;
-    actor?: string | null;
-    /** Required — a short human-readable description of the event. */
-    summary: string;
-    external_ref?: string | null;
-    match_key?: string | null;
-    payload?: Record<string, unknown>;
-    payload_version?: number;
+/** Entity types that may carry tenant-defined custom fields. */
+type CustomFieldEntityType = 'contact' | 'customer' | 'opportunity' | 'job' | 'vendor' | 'agent';
+/** The supported input/value types. */
+type CustomFieldType = 'text' | 'number' | 'select' | 'multi_select' | 'date' | 'boolean' | 'url' | 'email' | 'phone';
+interface CustomFieldValidationRules {
+    required?: boolean;
+    /** number: value bound · text: length · multi_select: array length */
+    min?: number;
+    max?: number;
+    /** text/regex pattern */
+    pattern?: string;
 }
-interface ActivityDto {
+
+/** A custom-field definition as returned by `GET /custom-fields`. */
+interface CustomFieldDefinitionDto {
     id: string;
-    type: string;
-    source: string;
-    occurred_at: string;
-    actor: string | null;
-    summary: string;
-    entity_type: string;
-    entity_id: string | null;
-    contact_id: string | null;
-    payload: Record<string, unknown>;
+    tenantId: string;
+    entityType: CustomFieldEntityType;
+    fieldKey: string;
+    label: string;
+    fieldType: CustomFieldType;
+    options: string[];
+    validationRules: CustomFieldValidationRules;
+    defaultValue: unknown;
+    displayOrder: number;
+    section: string | null;
+    searchable: boolean;
+    showInList: boolean;
+    showInReports: boolean;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
 }
-
-declare class ActivityResource {
+interface ListCustomFieldDefinitionsParams {
+    entity_type?: CustomFieldEntityType;
+    /** Include deactivated definitions. Their stored values remain valid on records. */
+    include_inactive?: boolean;
+}
+/**
+ * Read-only view of a tenant's custom-field definitions — the shape of its
+ * records. Needed to know which keys a `custom_fields` payload may carry before
+ * writing a customer, contact or opportunity.
+ *
+ * Read-only by design: configuring definitions is an admin action on
+ * `/admin/custom-fields` and is deliberately not exposed here.
+ */
+declare class CustomFieldsResource {
     private readonly http;
     constructor(http: HttpClient);
-    create(data: CreateActivityDto): Promise<ActivityDto>;
-    list(params?: ListParams): Promise<PaginatedResponse<ActivityDto>>;
-    listForEntity(entityType: string, entityId: string, params?: ListParams): Promise<PaginatedResponse<ActivityDto>>;
+    /** List definitions, optionally narrowed to one entity type. */
+    list(params?: ListCustomFieldDefinitionsParams): Promise<CustomFieldDefinitionDto[]>;
 }
 
 /**
- * Wire shapes for the Tags & entity-tagging API.
+ * Wire shapes for the Ortto connector admin API (E53, `/admin/integrations/ortto/*`).
  *
- * Mirrors `createTagSchema`/`updateTagSchema`/`setEntityTagsSchema` in
- * `packages/shared/src/validation/tags.ts`, plus `TagsService`'s actual
- * response shapes — snake_case, per `toDto()`/`list()`. Types are redefined
- * here (not imported) so the published package carries no runtime or type
- * dependency on `@blueprint/shared`.
+ * Mirrors `createOrttoMappingSchema` / `updateOrttoMappingSchema` /
+ * `orttoAudiencesQuerySchema` / `orttoSyncRequestSchema` and the response
+ * interfaces (`OrttoMappingDto`, `OrttoAudienceDto`, `OrttoSyncStatusDto`,
+ * `OrttoSyncRequestResultDto`, ...) in `packages/shared/src/validation/ortto.ts`. Types are
+ * redefined here (not imported) so the published package carries no runtime or
+ * type dependency on `@blueprint/shared`; `ortto.spec.ts` parses every request
+ * body with the REAL shared zod schema and asserts type parity with the shared
+ * inferred types.
  */
-interface TagDto {
+type OrttoMappingDirection = 'push' | 'pull';
+/**
+ * Push a Planes list's membership to Ortto as a tag. `ortto_tag` defaults to
+ * `planes:<list name>` server-side.
+ */
+interface CreateOrttoPushMappingDto {
+    direction: 'push';
+    list_id: string;
+    ortto_tag?: string;
+}
+/**
+ * Mirror an Ortto audience into a read-only static Planes list — either an
+ * existing empty static list (`list_id`) or a new one (`new_list_name`), never
+ * both.
+ */
+type CreateOrttoPullMappingDto = {
+    direction: 'pull';
+    ortto_audience_id: string;
+    create_unmatched?: boolean;
+} & ({
+    list_id: string;
+    new_list_name?: never;
+} | {
+    new_list_name: string;
+    list_id?: never;
+});
+type CreateOrttoMappingDto = CreateOrttoPushMappingDto | CreateOrttoPullMappingDto;
+/** Direction and list are immutable — delete and recreate instead. At least one field is required. */
+interface UpdateOrttoMappingDto {
+    ortto_tag?: string;
+    create_unmatched?: boolean;
+}
+interface ListOrttoAudiencesParams {
+    search?: string;
+}
+interface OrttoAudienceDto {
     id: string;
     name: string;
-    color: string | null;
+    /** Member count, when Ortto reports one. */
+    members?: number;
+}
+interface OrttoMappingDto {
+    id: string;
+    connection_id: string;
+    list_id: string;
+    /** Null when the list has since been deleted. */
+    list_name: string | null;
+    list_kind: 'static' | 'smart' | null;
+    direction: OrttoMappingDirection;
+    ortto_tag: string | null;
+    ortto_audience_id: string | null;
+    ortto_audience_name: string | null;
+    create_unmatched: boolean;
+    last_synced_at: string | null;
+    /** The last successful run's counts for this mapping; null before one. */
+    last_result?: OrttoMappingLastResult | null;
+    last_error: string | null;
     created_at: string;
     updated_at: string;
-    /** Only present on `list()` — `create()`/`update()` omit it. */
-    usage_count?: number;
-}
-interface CreateTagDto {
-    name: string;
-    color?: string | null;
 }
-interface UpdateTagDto {
-    name?: string;
-    color?: string | null;
+/** Counts summed over one sync run (every step, every mapping it covered). */
+interface OrttoSyncTotals {
+    added: number;
+    removed: number;
+    unsubscribed: number;
+    resubscribed: number;
+    created: number;
+    errors: number;
+    /** Ortto opt-outs for emails no Planes person has — skipped. */
+    unsubscribed_unknown: number;
 }
 /**
- * Declarative set-tags input. Provide `tag_ids` and/or `tag_names` — at least
- * one must be present (the server rejects neither); an empty array clears
- * that side of the set.
+ * A mapping's last SUCCESSFUL run. A run that succeeded with a caveat carries
+ * it in `warning`; `last_error` is set only when a run FAILED.
  */
-interface SetEntityTagsDto {
-    tag_ids?: string[];
-    tag_names?: string[];
+interface OrttoMappingLastResult extends OrttoSyncTotals {
+    /** Pull: Ortto people without a usable email. */
+    skipped_no_email?: number;
+    /** Pull: unmatched people not created because `create_unmatched` is off. */
+    skipped_unmatched?: number;
+    /** Succeeded, but with this caveat. */
+    warning?: string;
+    trigger: string;
+    finished_at: string;
 }
-interface EntityTagDto {
-    id: string;
-    name: string;
-    color: string | null;
+/** The connection's most recent finished run, with connection-level counts. */
+interface OrttoSyncLastRun {
+    finished_at: string;
+    trigger: string;
+    /** `completed`, `auth_failed` (key rejected) or `aborted` (a connection step failed). */
+    status: string;
+    /** Set when the run synced one mapping only. */
+    mapping_id: string | null;
+    totals: OrttoSyncTotals;
 }
-interface TagEntityDto {
-    entity_type: string;
-    entity_id: string;
+/** Omit `mapping_id` to sync every mapping on the connection. */
+interface RequestOrttoSyncDto {
+    mapping_id?: string;
 }
-interface TagEntitiesPage {
-    data: TagEntityDto[];
-    page: number;
-    limit: number;
-    total: number;
+/** `deduped` is true when a sync for the same target was already queued or running. */
+interface OrttoSyncRequestResult {
+    job_id: string;
+    deduped: boolean;
 }
-
-declare class TagResource extends BaseResource<TagDto, CreateTagDto, UpdateTagDto> {
-    constructor(http: ConstructorParameters<typeof BaseResource>[0]);
-    /** `TagsService.setEntityTags()` returns the final tag set wrapped in `{ tags }`. */
-    setEntityTags(entityType: string, entityId: string, data: SetEntityTagsDto): Promise<{
-        tags: TagDto[];
+interface OrttoSyncStatusDto {
+    connection: {
+        id: string;
+        status: string;
+        error_message: string | null;
+        last_sync_at: string | null;
+        /** Null before the first finished run. */
+        last_run: OrttoSyncLastRun | null;
+    };
+    /** True while any sync on the connection is queued or running. */
+    running: boolean;
+    mappings: Array<{
+        id: string;
+        list_id: string;
+        direction: OrttoMappingDirection;
+        last_synced_at: string | null;
+        last_result: OrttoMappingLastResult | null;
+        /** Set only when the mapping's last run FAILED (a warning is in last_result). */
+        last_error: string | null;
+        running: boolean;
     }>;
-    getEntityTags(entityType: string, entityId: string): Promise<EntityTagDto[]>;
-    getEntities(tagId: string, params?: Record<string, unknown>): Promise<TagEntitiesPage>;
 }
 
 /**
- * The kinds of change a webhook event can describe.
+ * Ortto connector (E53) — list mappings, the connected account's audiences,
+ * manual sync and sync status under `/admin/integrations/ortto`. Admin-only
+ * (Manage IntegrationConnection) and gated by the `marketplace` feature.
+ * Connecting the Ortto API key is out of scope. Every route wraps its payload
+ * in `{ data }`; the methods unwrap it. Not a CRUD resource (no get-by-id), so
+ * it does NOT extend `BaseResource`.
+ */
+declare class OrttoResource {
+    private readonly http;
+    private readonly basePath;
+    constructor(http: HttpClient);
+    /** GET /admin/integrations/ortto/mappings — live mappings with their list names. */
+    listMappings(): Promise<OrttoMappingDto[]>;
+    /** GET /admin/integrations/ortto/audiences — the connected account's audiences (cached 60 s). */
+    listAudiences(params?: ListOrttoAudiencesParams): Promise<OrttoAudienceDto[]>;
+    /** POST /admin/integrations/ortto/mappings — 409 when the list already has a mapping. */
+    createMapping(data: CreateOrttoMappingDto): Promise<OrttoMappingDto>;
+    /** PATCH /admin/integrations/ortto/mappings/:id — `ortto_tag` and/or `create_unmatched`. */
+    updateMapping(id: string, data: UpdateOrttoMappingDto): Promise<OrttoMappingDto>;
+    /**
+     * DELETE /admin/integrations/ortto/mappings/:id (204). A pull list becomes
+     * editable again and keeps its members; a push tag is NOT removed from Ortto.
+     */
+    deleteMapping(id: string): Promise<void>;
+    /**
+     * POST /admin/integrations/ortto/sync (202) — queue a sync for one mapping or
+     * the whole connection. Never calls Ortto in-request.
+     */
+    sync(data?: RequestOrttoSyncDto): Promise<OrttoSyncRequestResult>;
+    /** GET /admin/integrations/ortto/sync-status — 404 when Ortto is not connected. */
+    syncStatus(): Promise<OrttoSyncStatusDto>;
+}
+
+/**
+ * Every subscribable webhook event type, in the server's canonical order.
  *
- * Mirrored (self-contained, NOT imported) from
- * `packages/shared/src/types/entity-events.ts` — the SDK must not depend on
- * `@blueprint/shared`. Keep this union byte-identical to that source of truth.
+ * Mirrored (self-contained, NOT imported) from `WEBHOOK_EVENT_TYPES` in
+ * `packages/shared` — the SDK must not depend on `@blueprint/shared`.
+ * `webhooks.spec.ts` asserts runtime parity, so drift fails there.
  */
-type EntityEventType = 'created' | 'updated' | 'deleted' | 'status_changed' | 'entity.tagged' | 'entity.untagged' | 'list.member_added' | 'list.member_removed' | 'entity.assigned' | 'entity.unassigned' | 'team.member_added' | 'team.member_removed' | 'task.created' | 'task.updated' | 'task.completed' | 'task.cancelled' | 'comment.created';
+declare const WEBHOOK_EVENT_TYPES: readonly ["created", "updated", "deleted", "status_changed", "entity.tagged", "entity.untagged", "list.member_added", "list.member_removed", "entity.assigned", "entity.unassigned", "team.member_added", "team.member_removed", "task.created", "task.updated", "task.completed", "task.cancelled", "comment.created", "conversation.created", "conversation.matched", "conversation.deleted", "customer.merged", "workflow.instance_moved", "consent.changed", "billing_schedule.period_generated", "billing_schedule.period_needs_review", "billing_schedule.period_delivered", "billing_schedule.period_delivery_failed", "payment.on_void_invoice", "invoice.overdue", "integration_connection.deactivated", "customer_payment_method.invalidated", "invoice.autopay_succeeded", "invoice.autopay_failed"];
+/** The kinds of change a webhook event can describe. */
+type EntityEventType = (typeof WEBHOOK_EVENT_TYPES)[number];
 /**
  * The entity kinds a webhook event can target.
  *
  * Mirrored (self-contained, NOT imported) from
  * `packages/shared/src/types/entity-events.ts`. Keep byte-identical.
  */
-type EntityType = 'customer' | 'opportunity' | 'job' | 'estimate' | 'contract' | 'property' | 'inventory_item' | 'agent_execution' | 'calendar_event' | 'invoice' | 'payment';
+type EntityType = 'customer' | 'opportunity' | 'job' | 'estimate' | 'contract' | 'property' | 'inventory_item' | 'agent_execution' | 'calendar_event' | 'invoice' | 'payment' | 'billing_schedule' | 'integration_connection';
 /**
  * A single entity-change event as emitted onto the Planes event bus and
  * delivered inside a {@link WebhookDelivery}.
@@ -487,6 +3783,142 @@ interface EntityEvent {
     /** Correlation ID linking related events/actions. */
     correlation_id: string;
 }
+/**
+ * `event.snapshot` of an `invoice.overdue` event (E56-F8-S2). Planes' daily
+ * overdue sweep emits it once per invoice at each of the company's overdue
+ * offsets (default 3, 7 and 14 days after the due date) while the invoice is
+ * sent and not fully paid. After downtime only the highest offset reached is
+ * emitted. Mirrored from `InvoiceOverdueSnapshot` in `packages/shared`.
+ */
+interface InvoiceOverdueSnapshot {
+    invoiceId: string;
+    invoiceNumber: string;
+    customerId: string;
+    /** The configured offset this event is for (days after the due date). */
+    offsetDays: number;
+    /** Whole days since the due date when the sweep ran (at least `offsetDays`). */
+    daysOverdue: number;
+    /** Dollars still owed, as a decimal string, e.g. `'1250.00'`. */
+    balance: string;
+    currency: string;
+    /** ISO 8601. */
+    dueAt: string;
+    /** Where the invoice came from, e.g. `'billing_schedule'`. */
+    sourceType: string;
+    /** The billing schedule, when the invoice came from one. */
+    scheduleId?: string;
+}
+/**
+ * An `invoice.overdue` event: the standard {@link EntityEvent} envelope
+ * (`entity_type` `'invoice'`, `entity_id` the invoice, `changes` `{}`) with a
+ * typed snapshot. Narrow a delivery with `event.event_type === 'invoice.overdue'`.
+ */
+interface InvoiceOverdueEvent extends Omit<EntityEvent, 'event_type' | 'entity_type' | 'snapshot'> {
+    event_type: 'invoice.overdue';
+    entity_type: 'invoice';
+    snapshot: InvoiceOverdueSnapshot & Record<string, unknown>;
+}
+/**
+ * `event.snapshot` of an `integration_connection.deactivated` event
+ * (E56-F7-S2): one of the company's integration connections was disconnected,
+ * or replaced by a new connection for the same provider. Mirrored from
+ * `IntegrationConnectionDeactivatedSnapshot` in `packages/shared`.
+ */
+interface IntegrationConnectionDeactivatedSnapshot {
+    connectionId: string;
+    /** The provider, e.g. `'stripe'`. */
+    providerSlug: string;
+    reason: 'disconnected' | 'replaced';
+    /** The new connection, for `replaced`; otherwise null. */
+    replacedByConnectionId: string | null;
+}
+/**
+ * An `integration_connection.deactivated` event: the standard
+ * {@link EntityEvent} envelope (`entity_type` `'integration_connection'`,
+ * `entity_id` the connection, `changes` `{}`) with a typed snapshot.
+ */
+interface IntegrationConnectionDeactivatedEvent extends Omit<EntityEvent, 'event_type' | 'entity_type' | 'snapshot'> {
+    event_type: 'integration_connection.deactivated';
+    entity_type: 'integration_connection';
+    snapshot: IntegrationConnectionDeactivatedSnapshot & Record<string, unknown>;
+}
+/**
+ * `event.snapshot` of a `customer_payment_method.invalidated` event
+ * (E56-F7-S2): a customer's saved card can no longer be charged because the
+ * Stripe connection it was saved on went away. One event per card. Mirrored
+ * from `CustomerPaymentMethodInvalidatedSnapshot` in `packages/shared`.
+ */
+interface CustomerPaymentMethodInvalidatedSnapshot {
+    customerId: string;
+    /** The saved payment method's id. */
+    paymentMethodId: string;
+    /** The connection the card lived on. */
+    connectionId: string;
+    /** Why, e.g. `'connection_changed'`. */
+    reason: string;
+}
+/**
+ * A `customer_payment_method.invalidated` event: the standard
+ * {@link EntityEvent} envelope (`entity_type` `'customer'`, `entity_id` the
+ * customer, `changes` `{}`) with a typed snapshot.
+ */
+interface CustomerPaymentMethodInvalidatedEvent extends Omit<EntityEvent, 'event_type' | 'entity_type' | 'snapshot'> {
+    event_type: 'customer_payment_method.invalidated';
+    entity_type: 'customer';
+    snapshot: CustomerPaymentMethodInvalidatedSnapshot & Record<string, unknown>;
+}
+/**
+ * `event.snapshot` of an `invoice.autopay_succeeded` event (E56-F7-S4): a
+ * billing schedule's autopay charge on the customer's saved card was paid.
+ * Mirrored from `InvoiceAutopaySucceededSnapshot` in `packages/shared`.
+ */
+interface InvoiceAutopaySucceededSnapshot {
+    invoiceId: string;
+    scheduleId: string;
+    periodId: string;
+    /** The charge attempt that succeeded (1, or 2 after a decline). */
+    attempt: number;
+    paymentIntentId: string;
+}
+/**
+ * An `invoice.autopay_succeeded` event: the standard {@link EntityEvent}
+ * envelope (`entity_type` `'invoice'`, `entity_id` the invoice, `changes` `{}`)
+ * with a typed snapshot.
+ */
+interface InvoiceAutopaySucceededEvent extends Omit<EntityEvent, 'event_type' | 'entity_type' | 'snapshot'> {
+    event_type: 'invoice.autopay_succeeded';
+    entity_type: 'invoice';
+    snapshot: InvoiceAutopaySucceededSnapshot & Record<string, unknown>;
+}
+/**
+ * `event.snapshot` of an `invoice.autopay_failed` event (E56-F7-S4): one
+ * autopay attempt ended without a payment — exactly one event per failed
+ * attempt. `reason` is `'authentication_required'` (the customer was emailed
+ * the pay link; never retried), the card's decline code (e.g.
+ * `'insufficient_funds'`), or why autopay gave up (e.g. `'no_saved_method'`).
+ * Mirrored from `InvoiceAutopayFailedSnapshot` in `packages/shared`.
+ */
+interface InvoiceAutopayFailedSnapshot {
+    invoiceId: string;
+    scheduleId: string;
+    periodId: string;
+    attempt: number;
+    reason: string;
+    /** True when a second attempt is scheduled (after a first decline). */
+    willRetry: boolean;
+    /** ISO 8601, present when `willRetry`. */
+    nextAttemptAt?: string;
+}
+/**
+ * An `invoice.autopay_failed` event: the standard {@link EntityEvent}
+ * envelope (`entity_type` `'invoice'`, `entity_id` the invoice, `changes` `{}`)
+ * with a typed snapshot.
+ */
+interface InvoiceAutopayFailedEvent extends Omit<EntityEvent, 'event_type' | 'entity_type' | 'snapshot'> {
+    event_type: 'invoice.autopay_failed';
+    entity_type: 'invoice';
+    snapshot: InvoiceAutopayFailedSnapshot & Record<string, unknown>;
+}
 /**
  * The webhook delivery envelope Planes POSTs to a subscriber's URL.
  *
@@ -632,7 +4064,26 @@ declare class PlanesClient {
     private _inventory?;
     private _contacts?;
     private _activities?;
+    private _communications?;
+    private _conversations?;
+    private _gmail?;
+    private _documents?;
     private _tags?;
+    private _tasks?;
+    private _recordViews?;
+    private _modules?;
+    private _plan?;
+    private _me?;
+    private _roles?;
+    private _invoiceSettings?;
+    private _invoiceReminders?;
+    private _contactSequences?;
+    private _enrollments?;
+    private _workflows?;
+    private _serviceSchedules?;
+    private _billingSchedules?;
+    private _customFields?;
+    private _ortto?;
     private _webhooks?;
     constructor(config: PlanesConfig);
     get opportunities(): OpportunityResource;
@@ -646,7 +4097,42 @@ declare class PlanesClient {
     get inventory(): InventoryResource;
     get contacts(): ContactResource;
     get activities(): ActivityResource;
+    get communications(): CommunicationsResource;
+    /** Logged meetings — manual + provider-synced, with company matching (E55). */
+    get conversations(): ConversationsResource;
+    get gmail(): GmailResource;
+    get documents(): DocumentsResource;
     get tags(): TagResource;
+    get tasks(): TaskResource;
+    /** Record views — the "recently viewed" beacon + read (E41-F7). */
+    get recordViews(): RecordViewsResource;
+    /** Module status — which modules are active for the caller's tenant (E51-F1-S1). */
+    get modules(): ModulesResource;
+    /** The tenant's plan, billing status and plan ceiling — `plan.get()` (E54-F1-S2). */
+    get plan(): PlanResource;
+    /** The authenticated caller — `me.abilities()` (E52-F1-S3). */
+    get me(): MeResource;
+    /** Settings → Roles, admin only — `roles.list/get/updateGrants/reset/history` (E52-F2-S5). */
+    get roles(): RolesResource;
+    /** Invoice settings — `invoiceSettings.getOfflineInstructions/setOfflineInstructions` (E56-F5-S4). */
+    get invoiceSettings(): InvoiceSettingsResource;
+    /** Payment reminder settings, admin only — `invoiceReminders.list/update/preview` (E56-F8-S6). */
+    get invoiceReminders(): InvoiceRemindersResource;
+    /** Published sequences a contact can be enrolled in (E51-F2-S6). */
+    get contactSequences(): ContactSequencesResource;
+    /** Enroll a contact in a sequence, list its enrollments, exit one (E51-F2-S8). */
+    get enrollments(): EnrollmentsResource;
+    /** Tenant-readable workflow reads — a workflow version's ordered stages. */
+    get workflows(): WorkflowsResource;
+    get serviceSchedules(): ServiceSchedulesResource;
+    /**
+     * Recurring billing schedules (E56-F3) — CRUD, pause/resume/end, preview,
+     * the period ledger, Needs review, generate-now, skip and regenerate.
+     */
+    get billingSchedules(): BillingScheduleResource;
+    get customFields(): CustomFieldsResource;
+    /** Ortto connector — list mappings, audiences, manual sync, sync status (E53). Admin-only. */
+    get ortto(): OrttoResource;
     /**
      * Ergonomic webhook event router — `client.webhooks.on(pattern, handler)`
      * plus `client.webhooks.process({ body, signature, secret })`. Auth-independent
@@ -1172,4 +4658,4 @@ interface CustomersGeneratedResource {
     createCustomer(data: CreateCustomerDto): Promise<CustomerDto>;
 }
 
-export { type ActionContext, type ActionHandler, type ActionRequest, type ActionResult, type ActivityDto, ActivityResource, AgentApp, type AgentHandler, AuthenticationError, AuthorizationError, type AuthorizeOptions, BaseResource, CalendarEventResource, type ClientCredentialsOptions, type ContactChannelDto, ContactChannelResource, type ContactDto, type ContactMergeResult, ContactResource, ContractResource, type CreateActivityDto, type CreateContactChannelDto, type CreateContactDto, type CreateCustomerDto, type CreateOpportunityDto, type CreateTagDto, type CustomerDto, CustomerResource, type CustomersGeneratedResource, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT, DEFAULT_TOKEN_REFRESH_SKEW_MS, type EntityEvent, type EntityEventType, type EntityTagDto, type EntityType, EstimateResource, type ExchangeCodeOptions, type FieldError, type HandlerMap, InventoryResource, InvoiceResource, JobResource, type ListParams, MemoryTokenStorage, NotFoundError, OAuthError, type OpportunitiesGeneratedResource, type OpportunityDto, OpportunityResource, type PaginatedCustomerResponse, type PaginatedOpportunityResponse, type PaginatedResponse, type PaginationMeta, type PermissionLevel, Planes, PlanesClient, type PlanesConfig, PlanesError, PropertyResource, RateLimitError, type RefreshOptions, type RegisterOptions, ServerError, type SetEntityTagsDto, type StoredTokens, type TagDto, type TagEntityDto, TagResource, type TokenResponse, type TokenStorage, type TriggerType, type UpdateContactChannelDto, type UpdateContactDto, type UpdateOpportunityDto, type UpdateTagDto, ValidationError, type WebhookDelivery, type WebhookHandler, type WebhookProcessInput, WebhookRouter, WebhookVerificationError, buildAuthorizeUrl, clientCredentialsGrant, createAgentApp, exchangeCode, parseWebhookEvent, refreshAccessToken, verifyWebhookSignature };
+export { AGENT_ROLES, AUTOPAY_UNAVAILABLE_REASONS, type ActionContext, type ActionHandler, type ActionRequest, type ActionResult, type ActivityDto, ActivityResource, AgentApp, type AgentHandler, type AgentRole, ApiResource, type AttachExternalDocumentDto, type AttachPdfSettingDto, AuthenticationError, AuthorizationError, type AuthorizeOptions, type AutopayUnavailableReason, BILLING_ADJUSTMENT_STATUSES, BILLING_ADJUSTMENT_TARGETS, BILLING_AUTOPAY_STATUSES, BILLING_BACKFILL_MODES, BILLING_CADENCES, BILLING_COLLECTION_MODES, BILLING_DELIVERY_MODES, BILLING_DELIVERY_STATUSES, BILLING_INTERVALS, BILLING_PERIOD_STATUSES, BILLING_PREVIEW_PERIOD_STATUSES, BILLING_SCHEDULE_STATUSES, BILLING_STATUSES, BILL_TIMINGS, BaseResource, type BillTiming, type BillingAdjustment, type BillingAdjustmentListParams, type BillingAdjustmentListResponse, type BillingAdjustmentStatus, type BillingAdjustmentTarget, type BillingAutopayStatus, type BillingAutopaySummary, type BillingAutopaySummaryResponse, type BillingBackfillMode, type BillingCadence, type BillingCollectionMode, type BillingDeliveryMode, type BillingDeliveryStatus, type BillingInterval, type BillingInvoiceStatus, type BillingInvoiceTerms, type BillingNeedsReviewItem, type BillingNeedsReviewParams, type BillingNeedsReviewResponse, type BillingPeriodStatus, type BillingPreviewAdjustment, type BillingPreviewPeriodStatus, type BillingSchedule, type BillingScheduleDetail, type BillingScheduleLine, type BillingScheduleLineInput, type BillingScheduleLineVersion, type BillingScheduleLineVersionListResponse, type BillingScheduleListItem, type BillingScheduleListParams, type BillingScheduleListResponse, type BillingSchedulePeriod, type BillingSchedulePeriodListParams, type BillingSchedulePeriodListResponse, type BillingSchedulePreview, type BillingSchedulePreviewParams, type BillingSchedulePreviewPeriod, BillingScheduleResource, type BillingScheduleStatus, type BillingStatus, type BillingUpcomingPeriod, CONTACT_LIST_INCLUDES, CONTACT_SORT_KEYS, CUSTOMER_SORT_KEYS, type CalendarEventLocationType, type CalendarEventParticipantDto, CalendarEventResource, type CalendarEventStatus, type CalendarEventType, type CallOutcome, type ClientCredentialsOptions, type CommunicationAttachmentDto, type CommunicationChannel, type CommunicationDto, type CommunicationEntityType, type CommunicationSummaryDto, type CommunicationTarget, type CommunicationsListResponse, CommunicationsResource, type CompleteCalendarEventDto, type CompleteCalendarEventResponse, type CompletedTaskDto, type CompletionTriggerReason, type CompletionTriggerStage, type CompletionTriggerStatus, type CompletionWorkflowTrigger, type ConflictPreviewParticipant, type ConflictPreviewRequest, type ConflictPreviewResponse, type ConflictPreviewSchedule, type ConflictPreviewWindow, type ConsentLastChangeDto, type ConsentStateDto, type ContactChannelDto, ContactChannelResource, type ContactDto, type ContactEnrollmentDto, type ContactEnrollmentListItemDto, type ContactLinkDto, type ContactLinkTargetType, type ContactListInclude, type ContactListItemDto, type ContactListParams, type ContactMergeResult, ContactResource, type ContactSequenceDto, type ContactSequenceListResponse, ContactSequencesResource, type ContactSortKey, ContractResource, type Conversation, type ConversationActionItemDto, type ConversationAttendeeDto, type ConversationKind, type ConversationLink, type ConversationLinkEntityType, type ConversationListItem, type ConversationListResponse, type ConversationMatchCandidate, type ConversationMatchStatus, type ConversationParticipant, type ConversationSyncErrorClass, type ConversationSyncRosterItem, type ConversationSyncStatus, type ConversationSyncStatusMine, type ConversationTranscript, ConversationsResource, type CreateActivityDto, type CreateBillingAdjustmentDto, type CreateBillingScheduleDto, type CreateContactChannelDto, type CreateContactDto, type CreateCustomerDto, type CreateEstimateDto, type CreateInventoryItemDto, type CreateJobDto, type CreateOpportunityDto, type CreateOrttoMappingDto, type CreateOrttoPullMappingDto, type CreateOrttoPushMappingDto, type CreatePropertyDto, type CreateTagDto, type CreateTaskDto, type CreateWorkflowEventRuleInput, type CreateWorkflowTransitionInput, type CrewOverlapConflictDto, type CustomFieldDefinitionDto, type CustomFieldEntityType, type CustomFieldType, type CustomFieldValidationRules, CustomFieldsResource, type CustomerAddressInput, type CustomerDto, type CustomerListParams, type CustomerMergeResult, type CustomerPaymentMethodInvalidatedEvent, type CustomerPaymentMethodInvalidatedSnapshot, CustomerResource, type CustomerSortKey, type CustomersGeneratedResource, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT, DEFAULT_TOKEN_REFRESH_SKEW_MS, type DeleteWorkflowEventRuleResult, type DisconnectSourceConnectionDto, type DocumentDto, type DocumentEntityType, type DocumentKind, type DocumentsListResponse, DocumentsResource, ESTIMATE_STATUSES, type EnrollmentStatus, type EnrollmentTrigger, EnrollmentsResource, type EntityEvent, type EntityEventType, type EntityTagDto, type EntityType, type EstimateListParams, EstimateResource, type EstimateStatus, type EstimateSummaryDto, type ExchangeCodeOptions, FEATURE_KEYS, type FeatureKey, type FieldError, type GenerateNowResult, GmailResource, type GrantEffect, type GrantTier, type HandlerMap, type IntegrationConnectionDeactivatedEvent, type IntegrationConnectionDeactivatedSnapshot, type InternalDomainsDto, type InternalDomainsResult, type InventoryItemListParams, InventoryResource, type InventoryUnitOfMeasure, type InvoiceAutopayFailedEvent, type InvoiceAutopayFailedSnapshot, type InvoiceAutopaySucceededEvent, type InvoiceAutopaySucceededSnapshot, type InvoiceDetailDto, type InvoiceLineItemDto, type InvoiceListItemDto, type InvoiceListParams, type InvoiceOverdueEvent, type InvoiceOverdueSnapshot, type InvoiceOverdueSummaryDto, type InvoicePayLinkDto, type InvoicePayLinkStatusDto, type InvoicePaymentDto, type InvoiceReminderAppliesTo, type InvoiceReminderPreviewDto, type InvoiceReminderPreviewParams, type InvoiceReminderRuleDto, type InvoiceReminderRuleInputDto, type InvoiceReminderSettingsDto, InvoiceRemindersResource, InvoiceResource, InvoiceSettingsResource, type InvoiceSourceType, type InvoiceStatus, JOB_SORT_KEYS, type JobListParams, JobResource, type JobSortKey, type JobStatus, type JobTradeCoverageItemDto, type JobTradeCoverageResponse, type LinkCommunicationDto, type LinkConversationDto, type ListCalendarEventsParams, type ListCommunicationsParams, type ListConversationsParams, type ListCustomFieldDefinitionsParams, type ListEnrollmentsParams, type ListOrttoAudiencesParams, type ListParams, type ListTasksParams, type ListTransitionSummariesParams, type LogCallCommunicationDto, type LogCommunicationDto, type LogCommunicationResult, type LogConversationDto, type LogConversationResult, type LogEmailCommunicationDto, MODULE_KEYS, type MeAbilitiesResponse, MeResource, MemoryTokenStorage, type ModuleKey, ModulesResource, NotFoundError, OAuthError, OPPORTUNITY_SORT_KEYS, OPPORTUNITY_STATES, type OfflineInstructionsDto, type OpportunitiesGeneratedResource, type OpportunityDto, type OpportunityListParams, OpportunityResource, type OpportunitySortKey, type OpportunityState, type OrttoAudienceDto, type OrttoMappingDirection, type OrttoMappingDto, type OrttoMappingLastResult, OrttoResource, type OrttoSyncLastRun, type OrttoSyncRequestResult, type OrttoSyncStatusDto, type OrttoSyncTotals, type OverdueInvoiceDto, type OverdueInvoiceListParams, type OverdueOffsetsDto, PLAN_KEYS, PLAN_SOURCES, type PackedAbilityRule, type PaginatedCustomerResponse, type PaginatedOpportunityResponse, type PaginatedResponse, type PaginationMeta, type PatchConversationDto, type PaymentStatus, type PermissionLevel, type PlanKey, PlanResource, type PlanSource, Planes, PlanesClient, type PlanesConfig, PlanesError, type PropertyListParams, PropertyResource, type PullConversationsDto, type PullConversationsResult, type PullStatus, type PullStatusCounts, type PullStatusState, RECORD_VIEW_ENTITY_TYPES, RateLimitError, type RecentRecordView, type RecentRecordViewsParams, type RecordViewEntityType, type RecordViewInput, RecordViewsResource, type RecurrenceEditMode, type RefreshOptions, type RegeneratePeriodResult, type RegisterOptions, type RequestOrttoSyncDto, type ResolveConversationMatchDto, type RoleCellDto, type RoleDetailDto, type RoleGrantChange, type RoleHistoryEntryDto, type RoleHistoryPage, type RoleHistoryParams, type RoleKey, type RoleListResponse, type RoleRowDto, type RoleSummaryDto, RolesResource, type SavedPaymentMethodSummary, type SendGmailDto, type SendGmailResult, ServerError, ServiceSchedulesResource, type SetEntityTagsDto, type SkipBillingPeriodDto, type SourceConnectionResult, type SourceConnectionStatus, type StoredTokens, type SyncNowResult, type TagDto, type TagEntityDto, TagResource, type TaskAssigneeDto, type TaskAssigneeInput, type TaskAssigneeType, type TaskDto, type TaskEntityType, type TaskPriority, TaskResource, type TaskStatus, type TenantModuleStatusDto, type TenantPlanDto, type TokenResponse, type TokenStorage, type TranscriptAccess, type TranscriptAccessMode, type TranscriptSegment, type TransitionSummariesResponse, type TransitionSummaryDto, type TriggerType, type TunableRole, type UpdateBillingScheduleDto, type UpdateCalendarEventDto, type UpdateCalendarEventOptions, type UpdateContactChannelDto, type UpdateContactDto, type UpdateCustomerDto, type UpdateEstimateDto, type UpdateInventoryItemDto, type UpdateJobDto, type UpdateOpportunityDto$1 as UpdateOpportunityDto, type UpdateOrttoMappingDto, type UpdatePropertyDto, type UpdateRoleGrantsBody, type UpdateTagDto, type UpdateTaskDto, type UpdateWorkflowEventRuleInput, type UpdateWorkflowTransitionInput, ValidationError, WEBHOOK_EVENT_TYPES, WORKFLOW_EVENT_RULE_EVENT_TYPES, WORKFLOW_EVENT_RULE_MATCH_ALL_EVENT_TYPES, type WebhookDelivery, type WebhookHandler, type WebhookProcessInput, WebhookRouter, WebhookVerificationError, type WorkflowEndOutcome, type WorkflowEntityType, type WorkflowEventRuleDto, type WorkflowEventRuleEventType, type WorkflowEventRuleWhen, WorkflowEventRulesResource, type WorkflowTransitionDto, type WorkflowTransitionRef, type WorkflowVersionStageDto, type WorkflowVersionStagesResponse, WorkflowsResource, type WorkingHoursConflictDto, buildAuthorizeUrl, clientCredentialsGrant, createAgentApp, exchangeCode, parseWebhookEvent, refreshAccessToken, verifyWebhookSignature };