@rachelallyson/planning-center-people-ts 2.14.1 → 3.1.0

package/CHANGELOG.md

@@ -5,8 +5,55 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.1.0] - 2026-02-05
+
+### Added
+
+- **ListsModule.getRules(listId)**: New method to fetch rules for a list (`GET /people/v2/lists/:id/rules`). Returns paginated list of rules with `data`, `meta`, and `links`. Types `ListRuleResource`, `ListRuleAttributes`, and `ListRulesList` are exported.
+
+## [3.0.0] - 2026-01-28
+
+### Added
+
+- **Debug logging**: Set `config.debug: true` (or an options object) when creating the client to see detailed logs (rate limiting, retries, each request, and each module call). Helpers `createDebugLogger`, `attachDebugListener`, and `formatDebugEvent` are exported; see `docs/DEBUG_LOGGING.md` if present.
+- **Person create/update with snake_case**: You can pass snake_case attributes (e.g. `first_name`, `last_name`) to `client.people.create()` and `client.people.update()` in addition to camelCase; both are accepted.
+- **Stricter list options**: List and page options (e.g. `PersonListOptions`, `WorkflowPageOptions`) are fully typed per endpoint. Types such as `PersonInclude`, `PersonOrderField`, `PersonWhereClause` (and equivalents for other resources) are exported for better autocomplete and type safety.
+- **Included-data helpers**: `findIncluded`, `resolveIncluded`, and `createIncludedLookup` are exported for working with JSON:API `included` data.
+- **Event types**: When you use `client.on('request:start', ...)` (and other events), TypeScript narrows the handler argument to the correct event type via overloads.
+- **`getPage()`** on all list-capable modules for single-page fetching (e.g. `client.people.getPage({ perPage: 25, page: 1, where: { status: 'active' } })`).
+
+### Changed
+
+- **Responses with `include`**: When you request related data (e.g. `getById(id, ['primary_campus'])`), that data now appears at the top level (e.g. `person.primary_campus`) as well as in the response structure.
+- **Contacts create methods** now require the person ID as the first argument (API is person-scoped): `createEmail(personId, data)`, `createPhoneNumber(personId, data)`, `createAddress(personId, data)`, `createSocialProfile(personId, data)`.
+- **Single-page fetching**: `getAllPagesPaginated()` has been removed from all modules. Use `getPage(options)` instead.
+- **Low-level HTTP helpers** are no longer exported: `del`, `getAllPages`, `getList`, `getSingle`, `patch`, `post`. Use module methods or `createPcoClient` / `getRateLimitInfo` from core.
+- **Function-style API** has been removed: standalone functions such as `createPerson`, `getPerson`, `getHouseholds`, `getLists` are no longer exported. Use the client and its modules (e.g. `client.people.create`, `client.contacts.createEmail(personId, data)`, `client.households.getAll()`).
+- **`buildQueryParams`** is no longer exported from this package; use module methods and the exported option types. It remains available from `@rachelallyson/planning-center-base-ts` if needed.
+- **Modules**: All 11 modules now receive a config getter for debug and pass option objects into base for query building. See `MODULE_CHANGES.md` for a per-module summary.
+
+### Breaking changes
+
+- **Response shape (flattened data)**: All methods now return **flattened** resources (from base `mapIncludedToRelationships`). Use `resource.first_name` instead of `resource.attributes.first_name`, and `resource.emails` instead of `resource.relationships.emails.data` and `response.included`. Applies to getById, getPage, getAll, create, and update responses.
+- **Contacts**: If you use `client.contacts.createEmail(data)` (or the same for phone/address/social profile), you must switch to `createEmail(personId, data)` (and similarly for `createPhoneNumber`, `createAddress`, `createSocialProfile`).
+- **Function API**: If you import the old function API (`createPerson`, `getPerson`, `getHouseholds`, `getLists`, etc.), replace those calls with the module API on a `PcoClient` instance.
+
+### Dependency
+
+- This release depends on `@rachelallyson/planning-center-base-ts` `^1.1.1`. It is installed automatically when you install the people package.
+
 ## [2.14.1] - 2026-01-21
 
+### ✨ **New Features**
+
+- **Strictly Typed API Options**: Added comprehensive TypeScript types for all endpoint parameters
+  - Created `api-options.ts` with strict types for Include, OrderField, WhereClause, and ListOptions
+  - Fully typed: Person, FieldDefinition, Workflow, Note, List, Household endpoints
+  - Basic structure for: Campus, Form, Report, ServiceTime (can be enhanced with full API doc extraction)
+  - All types exported from main index for easy import
+  - Replaces `Record<string, any>` with strict interfaces for better type safety and IDE autocomplete
+  - Added `order` parameter support to people, workflows, notes, lists, households modules
+
 ### 🔧 **Bug Fixes**
 
 - **Complete Tab API Coverage**: Added missing `getTabById()` / `getTab()` method to retrieve a single tab by ID
@@ -14,6 +61,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Function API: `getTab(client, tabId, params?, context?)`
   - Completes full CRUD coverage for tabs (get, list, create, update, delete)
 
+- **Fixed `getAll()` Methods to Actually Get All Pages**: All `getAll()` methods now fetch all pages instead of just one
+  - Fixed: `people.getAll()`, `workflows.getAll()`, `notes.getAll()`, `lists.getAll()`, `households.getAll()`, `campus.getAll()`, `forms.getAll()`, `reports.getAll()`, `service-time.getAll()`
+  - Previously used `getList()` (one page), now uses `getAllPages()` (all pages)
+  - Note: `perPage` and `page` options are ignored when using `getAll()` - it automatically fetches all pages
+
+- **Removed `getAllPagesPaginated()` Methods**: Removed redundant `getAllPagesPaginated()` methods from all modules
+  - `getAll()` now handles fetching all pages automatically
+  - Removed from: `people`, `workflows`, `notes`, `lists`, `households`, `campus`, `forms`, `reports`, `service-time` modules
+
+- **Added `getPage()` Methods for Single Page Fetching**: Added `getPage()` methods to all modules for fetching a single page with full pagination control
+  - Use `getAll()` when you need all pages automatically
+  - Use `getPage()` when you need a specific page, custom per_page, or want to limit results
+  - Available on: `people.getPage()`, `workflows.getPage()`, `notes.getPage()`, `lists.getPage()`, `households.getPage()`, `campus.getPage()`, `forms.getPage()`, `reports.getPage()`, `service-time.getPage()`
+  - Example: `client.people.getPage({ perPage: 25, page: 1, where: { status: 'active' } })`
+
+- **Fixed `getAllFieldDefinitions()` Pagination**: Changed `include: ['tab']` to `include: 'tab'` to properly fetch all pages
+  - `getAllPages()` expects query params where `include` is a comma-separated string, not an array
+
+- **Made `getAllFieldDefinitions()` Include Parameter Optional**: `getAllFieldDefinitions()` now accepts an optional `include` parameter
+  - Defaults to `['tab']` if not provided (maintains backward compatibility)
+  - Can pass custom include array: `getAllFieldDefinitions(['tab', 'field_options'])`
+  - Can pass empty array to exclude relationships: `getAllFieldDefinitions([])`
+
+- **Added `where` Filtering, `order`, and `includeDeleted` Option to `getAllFieldDefinitions()`**: Enhanced `getAllFieldDefinitions()` with full API parameter support
+  - Added `where` parameter for filtering: `getAllFieldDefinitions(['tab'], { where: { tab_id: '123', data_type: 'string' } })`
+  - Added `order` parameter for sorting: `getAllFieldDefinitions(['tab'], { order: 'sequence' })` or `{ order: '-name' }` for descending
+  - Added `includeDeleted` option: `getAllFieldDefinitions(['tab'], { includeDeleted: true })`
+  - Valid where keys: `config`, `data_type`, `deleted_at`, `name`, `sequence`, `slug`, `tab_id`
+  - Valid order values: `config`, `data_type`, `deleted_at`, `name`, `sequence`, `slug`, `tab_id` (prefix with `-` for descending)
+
 ### 📦 **Exports**
 
 - `getTab` - Function API for retrieving a single tab by ID
@@ -21,6 +98,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### 🧪 **Testing**
 
 - Added tests for `getTabById()` / `getTab()` in fields test suites
+- Updated all `getAll()` tests to mock `paginationHelper.getAllPages()` instead of `httpClient.request()`
 
 ## [2.14.0] - 2026-01-21
 
@@ -517,11 +595,11 @@ No breaking changes - this is a type enhancement release:
 // Existing code continues to work
 const fields = await client.people.getFieldDefinitions();
 
-// New type safety benefits
+// New type safety benefits (flattened resources: attributes at top level)
 fields.data.forEach(field => {
-  if (field.attributes.data_type === 'select') {
+  if (field.data_type === 'select') {
     // TypeScript knows this is a select field
-    console.log('Select field:', field.attributes.name);
+    console.log('Select field:', field.name);
   }
 });
 ```
@@ -555,7 +633,7 @@ No breaking changes - this is a bug fix release:
 const person = await client.people.findOrCreate({
     firstName: 'John',
     lastName: 'Doe',
-    email: 'john@example.com',
+    email: 'john@gmail.com
     phone: '555-1234',
     campusId: 'campus-123'  // NEW: Campus assignment support
 });
@@ -885,7 +963,6 @@ This release adds three high-priority modules to extend the Planning Center Peop
 - `client.serviceTime.create(campusId, data)` - Create new service time
 - `client.serviceTime.update(campusId, id, data)` - Update existing service time
 - `client.serviceTime.delete(campusId, id)` - Delete service time
-- `client.serviceTime.getAllPagesPaginated(campusId, params?)` - Get all service times with pagination
 
 **ServiceTime Resource Structure:**
 
@@ -935,7 +1012,6 @@ This release adds three high-priority modules to extend the Planning Center Peop
 - `client.reports.delete(id)` - Delete report
 - `client.reports.getCreatedBy(reportId)` - Get report creator
 - `client.reports.getUpdatedBy(reportId)` - Get report updater
-- `client.reports.getAllPagesPaginated(params?)` - Get all reports with pagination
 
 **Reports Resource Structure:**
 
@@ -1014,7 +1090,6 @@ This release adds comprehensive Campus management functionality to the Planning
 - `client.campus.delete(id)` - Delete campus
 - `client.campus.getLists(campusId)` - Get lists for a specific campus
 - `client.campus.getServiceTimes(campusId)` - Get service times for a specific campus
-- `client.campus.getAllPagesPaginated()` - Get all campuses with automatic pagination
 
 #### **🏗️ Campus Resource Structure**
 

package/README.md

@@ -61,7 +61,7 @@ const person = await getPerson(client, 'person-id', ['emails']);
 const newPerson = await createPerson(client, {
     first_name: 'John',
     last_name: 'Doe',
-    email: 'john.doe@example.com',
+    email: 'john.doe@gmail.com',
 });
 
 // Update a person
@@ -86,6 +86,44 @@ await createPersonFieldData(
 
 ## Configuration
 
+### Debug logging
+
+Turn logs on or off to see everything that happens inside the package (requests, auth, rate limit, cache, errors). Debug is provided by the base package and shared across all PCO clients. Enable at creation or at runtime:
+
+```typescript
+import { PcoClient } from '@rachelallyson/planning-center-people-ts';
+
+// Enable at creation
+const client = new PcoClient({
+  auth: { type: 'personal_access_token', personalAccessToken: '...' },
+  debug: true,
+});
+
+// Or with options
+const client = new PcoClient({
+  auth: { ... },
+  debug: {
+    prefix: '[MyApp]',
+    includePayloads: false,  // set true to log request/response bodies (avoid in production)
+    onLog: (message, data) => myLogger.info(message, data),
+  },
+});
+
+// Toggle at runtime
+client.updateConfig({ debug: true });
+client.updateConfig({ debug: false });
+```
+
+With `debug: true`, every event is logged with a clear prefix (default `[PCO People]`), including:
+
+- `→` request start (method, endpoint, requestId)
+- `←` request complete (status, duration)
+- `✗` request error
+- auth success/failure/refresh
+- rate limit and rate available
+- cache hit/miss/set/invalidate
+- generic errors
+
 ### Authentication
 
 The client supports two authentication methods:
@@ -364,10 +402,10 @@ const people = await getPeople(client, { per_page: 10 }, {
 All functions are fully typed with TypeScript:
 
 ```typescript
-// TypeScript knows exactly what properties are available
+// TypeScript knows exactly what properties are available (flattened: attributes at top level)
 const person = await getPerson(client, 'person-id');
-console.log(person.data?.attributes?.first_name); // ✅ TypeScript knows this exists
-console.log(person.data?.attributes?.invalid_prop); // ❌ TypeScript error
+console.log(person.data?.first_name); // ✅ TypeScript knows this exists
+console.log(person.data?.invalid_prop); // ❌ TypeScript error
 
 // Creating resources is type-safe
 const newPerson = await createPerson(client, {

package/dist/auth.d.ts

@@ -43,7 +43,7 @@ export interface PcoClientConfigWithRefresh {
         maxRetries?: number;
         baseDelay?: number;
         maxDelay?: number;
-        onRetry?: (error: any, attempt: number) => void;
+        onRetry?: (error: unknown, attempt: number) => void;
     };
 }
 /**

package/dist/auth.js

@@ -4,6 +4,7 @@ exports.refreshAccessToken = refreshAccessToken;
 exports.updateClientTokens = updateClientTokens;
 exports.hasRefreshTokenCapability = hasRefreshTokenCapability;
 exports.attemptTokenRefresh = attemptTokenRefresh;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 /**
  * Refresh an OAuth access token using the refresh token
  */
@@ -59,25 +60,31 @@ async function attemptTokenRefresh(client, originalRequest) {
     if (!hasRefreshTokenCapability(client)) {
         throw new Error('No refresh token or callback configured');
     }
+    const logger = (0, planning_center_base_ts_1.createDebugLogger)(client.config);
+    if (logger.enabled)
+        logger.log('auth  attemptTokenRefresh start', {});
     try {
-        // Attempt to refresh the token
         const newTokens = await refreshAccessToken(client, client.config.refreshToken);
-        // Update the client with new tokens
         updateClientTokens(client, newTokens);
+        if (logger.enabled)
+            logger.log('auth  attemptTokenRefresh success', {});
         // Call the token refresh callback if provided
         if (client.config.onTokenRefresh) {
             try {
                 await client.config.onTokenRefresh(newTokens);
             }
             catch (callbackError) {
-                // Log callback error but don't fail the token refresh
-                console.warn('Token refresh callback failed:', callbackError);
+                const logger = (0, planning_center_base_ts_1.createDebugLogger)(client.config);
+                if (logger.enabled)
+                    logger.log('auth  token refresh callback failed', { error: String(callbackError) });
             }
         }
         // Retry the original request with the new token
         return await originalRequest();
     }
     catch (error) {
+        if (logger.enabled)
+            logger.log('auth  attemptTokenRefresh failed', { error: String(error) });
         const refreshError = new Error(`Token refresh failed: ${error instanceof Error ? error.message : String(error)}`);
         // Call the failure callback if provided
         if (client.config.onTokenRefreshFailure) {
@@ -89,8 +96,9 @@ async function attemptTokenRefresh(client, originalRequest) {
                 });
             }
             catch (callbackError) {
-                // Log callback error but don't fail the refresh error
-                console.warn('Token refresh failure callback failed:', callbackError);
+                const logger = (0, planning_center_base_ts_1.createDebugLogger)(client.config);
+                if (logger.enabled)
+                    logger.log('auth  token refresh failure callback failed', { error: String(callbackError) });
             }
         }
         throw refreshError;

package/dist/client.d.ts

@@ -1,8 +1,8 @@
 /**
  * v2.0.0 Main PcoClient Class
  */
-import type { PcoClientConfig } from './types/client';
-import type { EventEmitter, PcoEvent, EventHandler, EventType } from '@rachelallyson/planning-center-base-ts';
+import type { PeopleClientConfig } from './types/client';
+import type { EventEmitter as BaseEventEmitter, PcoEvent, EventHandler, EventType, EventRequestStartEvent, EventRequestCompleteEvent, RequestErrorEvent, AuthSuccessEvent, EventAuthFailureEvent, AuthRefreshEvent, EventRateLimitEvent, RateAvailableEvent, CacheHitEvent, CacheMissEvent, CacheSetEvent, CacheInvalidateEvent, EventErrorEvent } from '@rachelallyson/planning-center-base-ts';
 import { BatchExecutor } from '@rachelallyson/planning-center-base-ts';
 import { PeopleModule } from './modules/people';
 import { FieldsModule } from './modules/fields';
@@ -15,7 +15,7 @@ import { CampusModule } from './modules/campus';
 import { ServiceTimeModule } from './modules/service-time';
 import { FormsModule } from './modules/forms';
 import { ReportsModule } from './modules/reports';
-export declare class PcoClient implements EventEmitter {
+export declare class PcoClient implements BaseEventEmitter {
     people: PeopleModule;
     fields: FieldsModule;
     workflows: WorkflowsModule;
@@ -32,18 +32,43 @@ export declare class PcoClient implements EventEmitter {
     private paginationHelper;
     private eventEmitter;
     private config;
-    constructor(config: PcoClientConfig);
-    on<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
-    off<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
+    private debugUnsubscribe;
+    constructor(config: PeopleClientConfig);
+    on(eventType: 'request:start', handler: EventHandler<EventRequestStartEvent>): void;
+    on(eventType: 'request:complete', handler: EventHandler<EventRequestCompleteEvent>): void;
+    on(eventType: 'request:error', handler: EventHandler<RequestErrorEvent>): void;
+    on(eventType: 'auth:success', handler: EventHandler<AuthSuccessEvent>): void;
+    on(eventType: 'auth:failure', handler: EventHandler<EventAuthFailureEvent>): void;
+    on(eventType: 'auth:refresh', handler: EventHandler<AuthRefreshEvent>): void;
+    on(eventType: 'rate:limit', handler: EventHandler<EventRateLimitEvent>): void;
+    on(eventType: 'rate:available', handler: EventHandler<RateAvailableEvent>): void;
+    on(eventType: 'cache:hit', handler: EventHandler<CacheHitEvent>): void;
+    on(eventType: 'cache:miss', handler: EventHandler<CacheMissEvent>): void;
+    on(eventType: 'cache:set', handler: EventHandler<CacheSetEvent>): void;
+    on(eventType: 'cache:invalidate', handler: EventHandler<CacheInvalidateEvent>): void;
+    on(eventType: 'error', handler: EventHandler<EventErrorEvent>): void;
+    off(eventType: 'request:start', handler: EventHandler<EventRequestStartEvent>): void;
+    off(eventType: 'request:complete', handler: EventHandler<EventRequestCompleteEvent>): void;
+    off(eventType: 'request:error', handler: EventHandler<RequestErrorEvent>): void;
+    off(eventType: 'auth:success', handler: EventHandler<AuthSuccessEvent>): void;
+    off(eventType: 'auth:failure', handler: EventHandler<EventAuthFailureEvent>): void;
+    off(eventType: 'auth:refresh', handler: EventHandler<AuthRefreshEvent>): void;
+    off(eventType: 'rate:limit', handler: EventHandler<EventRateLimitEvent>): void;
+    off(eventType: 'rate:available', handler: EventHandler<RateAvailableEvent>): void;
+    off(eventType: 'cache:hit', handler: EventHandler<CacheHitEvent>): void;
+    off(eventType: 'cache:miss', handler: EventHandler<CacheMissEvent>): void;
+    off(eventType: 'cache:set', handler: EventHandler<CacheSetEvent>): void;
+    off(eventType: 'cache:invalidate', handler: EventHandler<CacheInvalidateEvent>): void;
+    off(eventType: 'error', handler: EventHandler<EventErrorEvent>): void;
     emit<T extends PcoEvent>(event: T): void;
     /**
      * Get the current configuration
      */
-    getConfig(): PcoClientConfig;
+    getConfig(): PeopleClientConfig;
     /**
      * Update the configuration
      */
-    updateConfig(updates: Partial<PcoClientConfig>): void;
+    updateConfig(updates: Partial<PeopleClientConfig>): void;
     /**
      * Get performance metrics
      */

package/dist/client.js

@@ -18,30 +18,38 @@ const forms_1 = require("./modules/forms");
 const reports_1 = require("./modules/reports");
 class PcoClient {
     constructor(config) {
+        this.debugUnsubscribe = null;
         this.config = config;
         this.eventEmitter = new planning_center_base_ts_1.PcoEventEmitter();
         this.httpClient = new planning_center_base_ts_1.PcoHttpClient(config, this.eventEmitter);
-        this.paginationHelper = new planning_center_base_ts_1.PaginationHelper(this.httpClient);
+        this.paginationHelper = new planning_center_base_ts_1.PaginationHelper(this.httpClient, () => this.getConfig());
         // Initialize modules
-        this.people = new people_1.PeopleModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.fields = new fields_1.FieldsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.workflows = new workflows_1.WorkflowsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.contacts = new contacts_1.ContactsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.households = new households_1.HouseholdsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.notes = new notes_1.NotesModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.lists = new lists_1.ListsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.campus = new campus_1.CampusModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.serviceTime = new service_time_1.ServiceTimeModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.forms = new forms_1.FormsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.reports = new reports_1.ReportsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.people = new people_1.PeopleModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.fields = new fields_1.FieldsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.workflows = new workflows_1.WorkflowsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.contacts = new contacts_1.ContactsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.households = new households_1.HouseholdsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.notes = new notes_1.NotesModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.lists = new lists_1.ListsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.campus = new campus_1.CampusModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.serviceTime = new service_time_1.ServiceTimeModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.forms = new forms_1.FormsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.reports = new reports_1.ReportsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
         this.batch = new planning_center_base_ts_1.BatchExecutor(this, this.eventEmitter);
-        // Set up event handlers from config
+        // Debug: subscribe to all events when debug is enabled (listener checks config each time so runtime toggle works)
+        if (config.debug) {
+            this.debugUnsubscribe = (0, planning_center_base_ts_1.attachDebugListener)(this, () => this.config);
+            (0, planning_center_base_ts_1.createDebugLogger)(config).log('client  debug enabled', { eventListener: true });
+        }
     }
-    // EventEmitter implementation
     on(eventType, handler) {
+        // TypeScript can't narrow T['type'] to specific literal types, but the runtime types match
+        // The overloads above handle the specific cases, this is for dynamic usage
         this.eventEmitter.on(eventType, handler);
     }
     off(eventType, handler) {
+        // TypeScript can't narrow T['type'] to specific literal types, but the runtime types match
+        // The overloads above handle the specific cases, this is for dynamic usage
         this.eventEmitter.off(eventType, handler);
     }
     emit(event) {
@@ -57,10 +65,23 @@ class PcoClient {
      * Update the configuration
      */
     updateConfig(updates) {
+        const hadDebug = Boolean(this.config.debug);
         this.config = { ...this.config, ...updates };
+        const hasDebug = Boolean(this.config.debug);
+        const logger = (0, planning_center_base_ts_1.createDebugLogger)(this.config);
+        if (logger.enabled)
+            logger.log('client.updateConfig', { updates });
+        // Attach or detach debug listener when debug is toggled
+        if (hadDebug && !hasDebug && this.debugUnsubscribe) {
+            this.debugUnsubscribe();
+            this.debugUnsubscribe = null;
+        }
+        else if (!hadDebug && hasDebug) {
+            this.debugUnsubscribe = (0, planning_center_base_ts_1.attachDebugListener)(this, () => this.config);
+        }
         // Recreate HTTP client with new config
         this.httpClient = new planning_center_base_ts_1.PcoHttpClient(this.config, this.eventEmitter);
-        this.paginationHelper = new planning_center_base_ts_1.PaginationHelper(this.httpClient);
+        this.paginationHelper = new planning_center_base_ts_1.PaginationHelper(this.httpClient, () => this.getConfig());
         // Update modules with new HTTP client
         this.updateModules();
     }
@@ -96,13 +117,17 @@ class PcoClient {
     }
     updateModules() {
         // Recreate modules with new HTTP client
-        this.people = new people_1.PeopleModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.fields = new fields_1.FieldsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.workflows = new workflows_1.WorkflowsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.contacts = new contacts_1.ContactsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.households = new households_1.HouseholdsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.notes = new notes_1.NotesModule(this.httpClient, this.paginationHelper, this.eventEmitter);
-        this.lists = new lists_1.ListsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.people = new people_1.PeopleModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.fields = new fields_1.FieldsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.workflows = new workflows_1.WorkflowsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.contacts = new contacts_1.ContactsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.households = new households_1.HouseholdsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.notes = new notes_1.NotesModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.lists = new lists_1.ListsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.campus = new campus_1.CampusModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.serviceTime = new service_time_1.ServiceTimeModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.forms = new forms_1.FormsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
+        this.reports = new reports_1.ReportsModule(this.httpClient, this.paginationHelper, this.eventEmitter, () => this.getConfig());
         this.batch = new planning_center_base_ts_1.BatchExecutor(this, this.eventEmitter);
     }
 }

package/dist/core.d.ts

@@ -37,6 +37,8 @@ export interface PcoClientConfig {
         maxDelay?: number;
         onRetry?: (error: PcoError, attempt: number) => void;
     };
+    /** Enable debug logging (same as base package; optional for v1 createPcoClient flow) */
+    debug?: boolean | import('@rachelallyson/planning-center-base-ts').PcoDebugOptions;
 }
 export { PcoApiError } from '@rachelallyson/planning-center-base-ts';
 export interface PcoClientState {
@@ -66,11 +68,11 @@ export declare function patch<TRes extends ResourceObject<string, any, any>, TIn
 /**
  * Make a DELETE request to the PCO API
  */
-export declare function del(client: PcoClientState, endpoint: string, params?: Record<string, any>, context?: Partial<ErrorContext>): Promise<void>;
+export declare function del(client: PcoClientState, endpoint: string, params?: Record<string, string | number | boolean | undefined>, context?: Partial<ErrorContext>): Promise<void>;
 /**
  * Get all pages of a paginated resource
  */
-export declare function getAllPages<T extends ResourceObject<string, any, any>>(client: PcoClientState, endpoint: string, params?: Record<string, any>, context?: Partial<ErrorContext>): Promise<T[]>;
+export declare function getAllPages<T extends ResourceObject<string, any, any>>(client: PcoClientState, endpoint: string, params?: Record<string, string | number | boolean | undefined>, context?: Partial<ErrorContext>): Promise<T[]>;
 /**
  * Get rate limit information
  */

package/dist/core.js

@@ -219,8 +219,9 @@ async function makeFetchRequest(client, method, endpoint, data, params, context)
                     return await (0, auth_1.attemptTokenRefresh)(client, () => makeFetchRequest(client, method, endpoint, data, params, context));
                 }
                 catch (refreshError) {
-                    // If token refresh fails, fall through to normal error handling
-                    console.warn('Token refresh failed:', refreshError);
+                    const logger = (0, planning_center_base_ts_1.createDebugLogger)(client.config);
+                    if (logger.enabled)
+                        logger.log('core  token refresh failed', { error: String(refreshError) });
                 }
             }
             let errorData;

package/dist/error-handling.d.ts

@@ -26,7 +26,7 @@ export interface ErrorContext {
     category?: ErrorCategory;
     severity?: ErrorSeverity;
     retryCount?: number;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 export declare class PcoError extends PcoApiError {
     readonly category: ErrorCategory;
@@ -35,14 +35,14 @@ export declare class PcoError extends PcoApiError {
     readonly retryable: boolean;
     constructor(message: string, status: number, statusText: string, errors: JsonApiError[], rateLimitHeaders?: Record<string, string | undefined>, context?: Partial<ErrorContext>);
     private categorizeError;
-    static fromFetchError(response: Response, data?: any, context?: Partial<ErrorContext>): PcoError;
+    static fromFetchError(response: Response, data?: unknown, context?: Partial<ErrorContext>): PcoError;
     static fromNetworkError(error: Error, context?: Partial<ErrorContext>): PcoError;
     static fromTimeoutError(timeoutMs: number, context?: Partial<ErrorContext>): PcoError;
     getRetryDelay(): number;
     shouldRetry(): boolean;
-    getErrorSummary(): Record<string, any>;
+    getErrorSummary(): Record<string, unknown>;
 }
-export declare function shouldNotRetry(error: any): boolean;
+export declare function shouldNotRetry(error: unknown): boolean;
 export declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: {
     maxRetries?: number;
     baseDelay?: number;

package/dist/error-handling.js

@@ -106,7 +106,9 @@ class PcoError extends planning_center_base_ts_1.PcoApiError {
     static fromFetchError(response, data, context = {}) {
         const status = response.status;
         const statusText = response.statusText;
-        const errors = data?.errors || [];
+        const errors = (data && typeof data === 'object' && data !== null && 'errors' in data)
+            ? (data.errors || [])
+            : [];
         const rateLimitHeaders = {
             'Retry-After': response.headers.get('retry-after') || undefined,
             'X-PCO-API-Request-Rate-Count': response.headers.get('x-pco-api-request-rate-count') || undefined,
@@ -115,7 +117,16 @@ class PcoError extends planning_center_base_ts_1.PcoApiError {
         };
         const message = errors.length > 0
             ? errors
-                .map((e) => e.detail || e.title || 'Unknown error')
+                .map((e) => {
+                if (e && typeof e === 'object' && 'detail' in e) {
+                    return e.detail;
+                }
+                if (e && typeof e === 'object' && 'title' in e) {
+                    return e.title;
+                }
+                return 'Unknown error';
+            })
+                .map((msg) => typeof msg === 'string' ? msg : 'Unknown error')
                 .join('; ')
             : statusText;
         return new PcoError(message, status, statusText, errors, rateLimitHeaders, context);

package/dist/error-scenarios.d.ts

@@ -41,15 +41,15 @@ export declare class CircuitBreaker {
 /**
  * Result of a bulk operation with individual item results
  */
-export interface BulkOperationResult<T> {
+export interface BulkOperationResult<R> {
     successful: {
         index: number;
-        data: T;
+        data: R;
     }[];
     failed: {
         index: number;
         error: Error;
-        data?: any;
+        data?: unknown;
     }[];
     totalProcessed: number;
     successRate: number;
@@ -80,7 +80,7 @@ export declare const TIMEOUT_CONFIG: {
 /**
  * Classify errors for appropriate handling
  */
-export declare function classifyError(error: any): {
+export declare function classifyError(error: unknown): {
     category: 'network' | 'authentication' | 'authorization' | 'validation' | 'rate_limit' | 'server' | 'unknown';
     severity: 'low' | 'medium' | 'high' | 'critical';
     retryable: boolean;
@@ -89,7 +89,7 @@ export declare function classifyError(error: any): {
 /**
  * Attempt to recover from common error scenarios
  */
-export declare function attemptRecovery<T>(operation: () => Promise<T>, error: any, context: {
+export declare function attemptRecovery<T>(operation: () => Promise<T>, error: unknown, context: {
     client: PcoClientState;
     operation: string;
     maxRetries?: number;
@@ -105,7 +105,11 @@ export interface ErrorReport {
         message: string;
         stack?: string;
         status?: number;
-        errors?: any[];
+        errors?: Array<{
+            detail?: string;
+            title?: string;
+            [key: string]: unknown;
+        }>;
     };
     context: {
         clientConfig: {
@@ -124,7 +128,7 @@ export interface ErrorReport {
 /**
  * Create detailed error report
  */
-export declare function createErrorReport(error: any, context: {
+export declare function createErrorReport(error: unknown, context: {
     operation: string;
     client: PcoClientState;
     requestInfo?: {