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

package/dist/helpers.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TRUST_WINDOW = void 0;
-exports.buildQueryParams = buildQueryParams;
+exports.mapIncludedToRelationships = exports.DEFAULT_TRUST_WINDOW = void 0;
 exports.calculateAge = calculateAge;
 exports.calculateAgeSafe = calculateAgeSafe;
 exports.isAdult = isAdult;
@@ -30,37 +29,26 @@ exports.getListsWithCategories = getListsWithCategories;
 exports.getPersonWorkflowCardsWithNotes = getPersonWorkflowCardsWithNotes;
 exports.createWorkflowCardWithNote = createWorkflowCardWithNote;
 exports.exportAllPeopleData = exportAllPeopleData;
+exports.findIncluded = findIncluded;
+exports.resolveIncluded = resolveIncluded;
+exports.createIncludedLookup = createIncludedLookup;
 exports.extractFileUrl = extractFileUrl;
 exports.isFileUrl = isFileUrl;
 exports.getFileExtension = getFileExtension;
 exports.getFilename = getFilename;
 exports.isFileUpload = isFileUpload;
 exports.processFileValue = processFileValue;
-const people_1 = require("./people");
-/**
- * Transform complex params object into flat query params for API calls
- */
-function buildQueryParams(params) {
-    const queryParams = {};
-    if (params?.where) {
-        Object.entries(params.where).forEach(([key, value]) => {
-            queryParams[`where[${key}]`] = value;
-        });
-    }
-    if (params?.include) {
-        queryParams.include = params.include.join(',');
-    }
-    if (params?.per_page) {
-        queryParams.per_page = params.per_page;
-    }
-    if (params?.page) {
-        queryParams.page = params.page;
-    }
-    if (params?.filter) {
-        queryParams.filter = params.filter;
-    }
-    return queryParams;
-}
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+/** Log to debug stream when client has debug enabled; no-op otherwise */
+function debugLogIfEnabled(client, message, data) {
+    const config = 'getConfig' in client && typeof client.getConfig === 'function'
+        ? client.getConfig()
+        : undefined;
+    const logger = (0, planning_center_base_ts_1.createDebugLogger)(config);
+    if (logger.enabled)
+        logger.log(message, data);
+}
+const planning_center_base_ts_2 = require("@rachelallyson/planning-center-base-ts");
 /**
  * Calculate age from birthdate string
  */
@@ -321,7 +309,7 @@ exports.DEFAULT_TRUST_WINDOW = 60 * 60 * 1000; // 1 hour
  * @param trustWindow - Trust window in milliseconds (default: 1 hour)
  * @returns Object with trust decision, age, and reason
  *
- * @example
+ * @gmail.com
  * ```typescript
  * const trust = calculateTrust(pcoInfo.personIdCreatedAt);
  * if (trust.shouldTrust) {
@@ -438,42 +426,69 @@ function validatePersonData(data) {
 /**
  * Get primary contact information for a person
  */
-async function getPrimaryContact(client, personId, context) {
+async function getPrimaryContact(client, personId) {
+    debugLogIfEnabled(client, 'helpers  getPrimaryContact', { personId });
     const [emails, phones, addresses] = await Promise.all([
-        (0, people_1.getPersonEmails)(client, personId, context),
-        (0, people_1.getPersonPhoneNumbers)(client, personId, context),
-        (0, people_1.getPersonAddresses)(client, personId, context)
+        client.people.getEmails(personId),
+        client.people.getPhoneNumbers(personId),
+        client.people.getAddresses(personId)
     ]);
-    const primaryEmail = emails.data.find((e) => e.attributes.primary);
-    const primaryPhone = phones.data.find((p) => p.attributes.primary);
-    const primaryAddress = addresses.data.find((a) => a.attributes.primary);
+    const primaryEmail = emails.data.find((e) => e.primary);
+    const primaryPhone = phones.data.find((p) => p.primary);
+    const primaryAddress = addresses.data.find((a) => a.primary);
+    const addressValue = primaryAddress?.street_line_1 ?? addresses.data[0]?.street_line_1;
+    const addressString = typeof addressValue === 'string' ? addressValue : undefined;
     return {
-        email: primaryEmail?.attributes?.address || emails.data[0]?.attributes?.address,
-        phone: primaryPhone?.attributes?.number || phones.data[0]?.attributes?.number,
-        address: (primaryAddress?.attributes?.street || addresses.data[0]?.attributes?.street)
+        email: primaryEmail?.address ?? emails.data[0]?.address,
+        phone: primaryPhone?.number ?? phones.data[0]?.number,
+        address: addressString
     };
 }
 /**
  * Create a person with contact information
  */
-async function createPersonWithContact(client, personData, contactData, context) {
-    const person = await (0, people_1.createPerson)(client, personData, context);
+async function createPersonWithContact(client, personData, contactData) {
+    debugLogIfEnabled(client, 'helpers  createPersonWithContact', { firstName: personData.first_name, lastName: personData.last_name });
+    const createData = {};
+    if (personData.first_name)
+        createData.firstName = personData.first_name;
+    if (personData.last_name)
+        createData.lastName = personData.last_name;
+    if (personData.nickname !== null && personData.nickname !== undefined) {
+        createData.nickname = personData.nickname;
+    }
+    const person = await client.people.create(createData);
     const results = { person };
     if (contactData?.email) {
-        results.email = await (0, people_1.createPersonEmail)(client, person.data.id, contactData.email, context);
+        // Ensure required fields are present
+        if (contactData.email.address && contactData.email.location) {
+            results.email = await client.people.addEmail(person.id, {
+                address: contactData.email.address,
+                location: contactData.email.location,
+                primary: contactData.email.primary,
+            });
+        }
     }
     if (contactData?.phone) {
-        results.phone = await (0, people_1.createPersonPhoneNumber)(client, person.data.id, contactData.phone, context);
+        // Ensure required fields are present
+        if (contactData.phone.number && contactData.phone.location) {
+            results.phone = await client.people.addPhoneNumber(person.id, {
+                number: contactData.phone.number,
+                location: contactData.phone.location,
+                primary: contactData.phone.primary,
+            });
+        }
     }
     if (contactData?.address) {
-        results.address = await (0, people_1.createPersonAddress)(client, person.data.id, contactData.address, context);
+        results.address = await client.people.addAddress(person.id, contactData.address);
     }
     return results;
 }
 /**
  * Search people by multiple criteria
  */
-async function searchPeople(client, criteria, context) {
+async function searchPeople(client, criteria) {
+    debugLogIfEnabled(client, 'helpers  searchPeople', { criteria });
     const where = {};
     if (criteria.status) {
         where.status = criteria.status;
@@ -485,37 +500,63 @@ async function searchPeople(client, criteria, context) {
     else if (criteria.name) {
         where.search_name = criteria.name;
     }
-    return (0, people_1.getPeople)(client, {
-        where,
-        per_page: criteria.per_page || 25
-    }, context);
+    // If pagination options are provided, use getPage instead of getAll
+    if (criteria.perPage !== undefined || criteria.page !== undefined) {
+        const result = await client.people.getPage({
+            where,
+            perPage: criteria.perPage,
+            page: criteria.page,
+        });
+        return result;
+    }
+    const result = await client.people.getAll({ where });
+    return result;
 }
 /**
  * Get people by household
  */
-async function getPeopleByHousehold(client, householdId, context) {
-    return (0, people_1.getPeople)(client, {
-        where: { household_id: householdId },
-        include: ['household']
-    }, context);
+async function getPeopleByHousehold(client, householdId) {
+    debugLogIfEnabled(client, 'helpers  getPeopleByHousehold', { householdId });
+    const result = await client.people.getAll({
+        include: ['households']
+    });
+    // Filter by household_id manually since it's not in the where clause
+    // getAll returns PaginationResult with FlattenedPersonResource[], so return the same type
+    const filtered = {
+        ...result,
+        data: result.data.filter((p) => {
+            const household = p.household;
+            if (!household)
+                return false;
+            // household can be a HouseholdResource, ResourceIdentifier, or array at runtime (types say to-one only)
+            if (Array.isArray(household)) {
+                return household.some((h) => h && 'id' in h && h.id === householdId);
+            }
+            // Check if it has an id property (both ResourceIdentifier and HouseholdResource have it)
+            const h = household;
+            return 'id' in h && h.id === householdId;
+        })
+    };
+    return filtered;
 }
 /**
  * Get complete person profile with all related data
  */
-async function getCompletePersonProfile(client, personId, context) {
+async function getCompletePersonProfile(client, personId) {
+    debugLogIfEnabled(client, 'helpers  getCompletePersonProfile', { personId });
     const [person, emails, phones, addresses, fieldData, workflowCards] = await Promise.all([
-        (0, people_1.getPerson)(client, personId, ['household'], context),
-        (0, people_1.getPersonEmails)(client, personId, context),
-        (0, people_1.getPersonPhoneNumbers)(client, personId, context),
-        (0, people_1.getPersonAddresses)(client, personId, context),
-        (0, people_1.getPersonFieldData)(client, personId, context),
-        (0, people_1.getWorkflowCards)(client, personId, context)
+        client.people.getById(personId, ['households']),
+        client.people.getEmails(personId),
+        client.people.getPhoneNumbers(personId),
+        client.people.getAddresses(personId),
+        client.people.getFieldData(personId),
+        client.people.getWorkflowCards(personId)
     ]);
     return {
         person,
-        emails,
-        phones,
-        addresses,
+        emails: emails,
+        phones: phones,
+        addresses: addresses,
         fieldData,
         workflowCards
     };
@@ -523,15 +564,15 @@ async function getCompletePersonProfile(client, personId, context) {
 /**
  * Get organization info with statistics
  */
-async function getOrganizationInfo(client, context) {
-    const [organization, people, households, lists] = await Promise.all([
-        (0, people_1.getOrganization)(client, undefined, context),
-        (0, people_1.getPeople)(client, { per_page: 1 }, context),
-        (0, people_1.getHouseholds)(client, { per_page: 1 }, context),
-        (0, people_1.getLists)(client, { per_page: 1 }, context)
+async function getOrganizationInfo(client) {
+    debugLogIfEnabled(client, 'helpers  getOrganizationInfo', {});
+    const [people, households, lists] = await Promise.all([
+        client.people.getPage({ perPage: 1 }),
+        client.households.getPage({ perPage: 1 }),
+        client.lists.getPage({ perPage: 1 })
     ]);
     return {
-        organization,
+        organization: null,
         stats: {
             totalPeople: Number(people.meta?.total_count) || 0,
             totalHouseholds: Number(households.meta?.total_count) || 0,
@@ -542,22 +583,27 @@ async function getOrganizationInfo(client, context) {
 /**
  * Get lists with their categories
  */
-async function getListsWithCategories(client, context) {
+async function getListsWithCategories(client) {
+    debugLogIfEnabled(client, 'helpers  getListsWithCategories', {});
     const [lists, categories] = await Promise.all([
-        (0, people_1.getLists)(client, { include: ['list_category'] }, context),
-        (0, people_1.getListCategories)(client, undefined, context)
+        client.lists.getAll(),
+        client.lists.getListCategories()
     ]);
-    return { lists, categories };
+    return {
+        lists: lists,
+        categories: categories
+    };
 }
 /**
  * Get workflow cards with notes for a person
  */
-async function getPersonWorkflowCardsWithNotes(client, personId, context) {
-    const workflowCards = await (0, people_1.getWorkflowCards)(client, personId, context);
+async function getPersonWorkflowCardsWithNotes(client, personId) {
+    debugLogIfEnabled(client, 'helpers  getPersonWorkflowCardsWithNotes', { personId });
+    const workflowCards = await client.people.getWorkflowCards(personId);
     const notes = {};
     for (const card of workflowCards.data) {
         try {
-            notes[card.id] = await (0, people_1.getWorkflowCardNotes)(client, personId, card.id, context);
+            notes[card.id] = await client.workflows.getWorkflowCardNotes(personId, card.id);
         }
         catch (error) {
             notes[card.id] = { data: [], meta: { total_count: 0 } };
@@ -568,42 +614,140 @@ async function getPersonWorkflowCardsWithNotes(client, personId, context) {
 /**
  * Create a workflow card with a note
  */
-async function createWorkflowCardWithNote(client, workflowId, personId, noteData, context) {
-    const workflowCard = await (0, people_1.createWorkflowCard)(client, workflowId, personId, context);
-    const note = await (0, people_1.createWorkflowCardNote)(client, personId, workflowCard.data.id, noteData, context);
-    return { workflowCard, note };
+async function createWorkflowCardWithNote(client, workflowId, personId, noteData) {
+    debugLogIfEnabled(client, 'helpers  createWorkflowCardWithNote', { workflowId, personId });
+    const workflowCard = await client.workflows.createWorkflowCard(workflowId, personId);
+    const note = await client.workflows.createWorkflowCardNote(personId, workflowCard.id, noteData);
+    return {
+        workflowCard,
+        note
+    };
 }
 /**
  * Export all people data in a structured format
  */
-async function exportAllPeopleData(client, options = {}, context) {
-    const { includeInactive = false, includeFieldData = false, includeWorkflowCards = false, perPage = 100 } = options;
+async function exportAllPeopleData(client, options = {}) {
+    debugLogIfEnabled(client, 'helpers  exportAllPeopleData', options);
+    const { includeInactive = false, includeFieldData = false, includeWorkflowCards = false } = options;
     const where = {};
     if (!includeInactive) {
         where.status = 'active';
     }
-    const include = ['household'];
+    const include = ['households'];
     if (includeFieldData) {
         include.push('field_data');
     }
-    if (includeWorkflowCards) {
-        include.push('workflow_cards');
-    }
-    const [people, households, lists, organization] = await Promise.all([
-        (0, people_1.getPeople)(client, { where, include, per_page: perPage }, context),
-        (0, people_1.getHouseholds)(client, { per_page: perPage }, context),
-        (0, people_1.getLists)(client, { per_page: perPage }, context),
-        (0, people_1.getOrganization)(client, undefined, context)
+    // Note: workflow_cards is not a valid PersonInclude, so we'll fetch it separately if needed
+    const [people, households, lists] = await Promise.all([
+        client.people.getAll({ where, include }),
+        client.households.getAll(),
+        client.lists.getAll()
     ]);
+    // Try to get organization info, but it may not be available
+    let organization = null;
+    try {
+        const orgInfo = await getOrganizationInfo(client);
+        organization = orgInfo.organization;
+    }
+    catch {
+        // Organization endpoint may not be available
+        organization = null;
+    }
     return {
         people: people.data,
         households: households.data,
         lists: lists.data,
-        organization: organization.data,
+        organization,
         exportDate: new Date().toISOString(),
         totalCount: Number(people.meta?.total_count) || 0
     };
 }
+// ===== JSON:API Included Resources Helpers =====
+/**
+ * Find an included resource by type and id
+ *
+ * In JSON:API, relationships contain resource identifiers like { type: 'Email', id: '456' }
+ * This helper finds the full resource object from the included array.
+ *
+ * @param included - Array of included resources from JSON:API response
+ * @param type - Resource type to find
+ * @param id - Resource id to find
+ * @returns The matching resource object, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const person = await client.people.getPage({ include: ['emails'] });
+ * // Data is flattened: person.data[0].emails is the resolved array
+ * const email = person.data[0].emails?.[0];
+ * console.log(email?.address); // 'john@gmail.com'
+ * ```
+ */
+function findIncluded(included, type, id) {
+    if (!included || !Array.isArray(included)) {
+        return undefined;
+    }
+    return included.find((resource) => resource.type === type && resource.id === id);
+}
+/**
+ * Resolve all resources from a relationship to their full included objects
+ *
+ * Takes a relationship's data array (which contains resource identifiers)
+ * and resolves them to full resource objects from the included array.
+ *
+ * @param included - Array of included resources from JSON:API response
+ * @param relationshipData - Relationship data array (from relationships.xxx.data)
+ * @returns Array of full resource objects, or empty array if none found
+ *
+ * @example
+ * ```typescript
+ * const person = await client.people.getPage({ include: ['emails', 'phone_numbers'] });
+ * // Data is flattened: person.data[0].emails is the resolved array
+ * const emails = person.data[0].emails ?? [];
+ * emails.forEach(email => console.log(email.address));
+ * ```
+ */
+function resolveIncluded(included, relationshipData) {
+    if (!included || !Array.isArray(included) || !relationshipData) {
+        return [];
+    }
+    const identifiers = Array.isArray(relationshipData) ? relationshipData : [relationshipData];
+    return identifiers
+        .map((ref) => findIncluded(included, ref.type, ref.id))
+        .filter((resource) => resource !== undefined);
+}
+/**
+ * Create a lookup map for included resources by type and id
+ *
+ * This is more efficient than calling findIncluded() multiple times.
+ *
+ * @param included - Array of included resources from JSON:API response
+ * @returns Map with key format "type:id" -> resource object
+ *
+ * @gmail.com
+ * ```typescript
+ * const person = await client.people.getPage({ include: ['emails', 'phone_numbers'] });
+ * const lookup = createIncludedLookup(person.included);
+ * const email = lookup.get('Email:456'); // Fast lookup
+ * ```
+ */
+function createIncludedLookup(included) {
+    const lookup = new Map();
+    if (!included || !Array.isArray(included)) {
+        return lookup;
+    }
+    for (const resource of included) {
+        const key = `${resource.type}:${resource.id}`;
+        lookup.set(key, resource);
+    }
+    return lookup;
+}
+/**
+ * Automatically map included resources to their relationships
+ *
+ * Re-exported from @rachelallyson/planning-center-base-ts for convenience.
+ * The mapping is now automatically applied in getList()/getPage() methods.
+ */
+exports.mapIncludedToRelationships = planning_center_base_ts_2.mapIncludedToRelationships;
 // ===== File Handling Utilities =====
 /**
  * Extracts clean URL from HTML markup that contains file links

package/dist/index.d.ts

@@ -1,29 +1,31 @@
 export { PcoClient } from './client';
 export { PcoClientManager } from './client-manager';
-export type { PcoClientConfig, PcoAuthConfig, PersonalAccessTokenAuth, OAuthAuth } from './types/client';
+export type { PcoClientConfig, PcoAuthConfig, PersonalAccessTokenAuth, OAuthAuth, PeopleClientConfig, PcoDebugOptions, } from './types/client';
+export { attachDebugListener, createDebugLogger, formatDebugEvent, } from '@rachelallyson/planning-center-base-ts';
+export type { PcoDebugListenable } from '@rachelallyson/planning-center-base-ts';
 export type { PcoEvent, EventHandler, EventType } from '@rachelallyson/planning-center-base-ts';
 export type { BatchOperation, BatchResult, BatchOptions, BatchSummary } from '@rachelallyson/planning-center-base-ts';
 export type { Paginated, Relationship, ResourceIdentifier, ResourceObject, } from '@rachelallyson/planning-center-base-ts';
 export type { PersonResource, PersonAttributes, PersonSingle, PeopleList, EmailResource, EmailAttributes, PhoneNumberResource, PhoneNumberAttributes, AddressResource, AddressAttributes, SocialProfileResource, SocialProfileAttributes, } from './types';
 export type { FieldDefinitionResource, FieldDefinitionAttributes, FieldDatumResource, FieldDatumAttributes, FieldOptionResource, FieldOptionAttributes, TabResource, TabAttributes, } from './types';
 export type { WorkflowResource, WorkflowAttributes, WorkflowCardResource, WorkflowCardAttributes, WorkflowCardNoteResource, WorkflowCardNoteAttributes, } from './types';
-export type { HouseholdResource, HouseholdAttributes, NoteResource, NoteAttributes, ListResource, ListAttributes, OrganizationResource, OrganizationAttributes, CampusResource, CampusAttributes, CampusesList, ServiceTimeResource, ServiceTimeAttributes, ServiceTimesList, FormResource, FormAttributes, FormsList, FormCategoryResource, FormCategoryAttributes, FormFieldResource, FormFieldAttributes, FormFieldOptionResource, FormFieldOptionAttributes, FormSubmissionResource, FormSubmissionAttributes, FormSubmissionValueResource, FormSubmissionValueAttributes, ReportResource, ReportAttributes, ReportsList, } from './types';
+export type { HouseholdResource, HouseholdAttributes, NoteResource, NoteAttributes, ListResource, ListAttributes, ListRuleResource, ListRuleAttributes, ListRulesList, OrganizationResource, OrganizationAttributes, CampusResource, CampusAttributes, CampusesList, ServiceTimeResource, ServiceTimeAttributes, ServiceTimesList, FormResource, FormAttributes, FormsList, FormCategoryResource, FormCategoryAttributes, FormFieldResource, FormFieldAttributes, FormFieldOptionResource, FormFieldOptionAttributes, FormSubmissionResource, FormSubmissionAttributes, FormSubmissionValueResource, FormSubmissionValueAttributes, ReportResource, ReportAttributes, ReportsList, } from './types';
+export { createPcoClient, getRateLimitInfo } from './core';
+export type { PcoClientState, PcoClientConfig as CorePcoClientConfig } from './core';
+export { attemptTokenRefresh, refreshAccessToken, updateClientTokens, hasRefreshTokenCapability } from './auth';
+export type { TokenResponse, PcoClientConfigWithRefresh } from './auth';
 export * from './types';
-export type { PcoClientConfig as PcoClientConfigV1, PcoClientState } from './core';
-export { createPcoClient, del, getAllPages, getList, getRateLimitInfo, getSingle, patch, post, } from './core';
-export type { TokenResponse, TokenRefreshCallback, TokenRefreshFailureCallback } from './auth';
-export { attemptTokenRefresh, hasRefreshTokenCapability, refreshAccessToken, updateClientTokens, } from './auth';
 export { PcoApiError } from '@rachelallyson/planning-center-base-ts';
 export type { RateLimitHeaders, RateLimitInfo } from '@rachelallyson/planning-center-base-ts';
 export { PcoRateLimiter } from '@rachelallyson/planning-center-base-ts';
 export type { ErrorContext } from '@rachelallyson/planning-center-base-ts';
 export { ErrorCategory, ErrorSeverity, handleNetworkError, handleTimeoutError, handleValidationError, PcoError, retryWithBackoff, shouldNotRetry, withErrorBoundary, } from '@rachelallyson/planning-center-base-ts';
-export { createFieldDefinition, createFieldOption, createPerson, createPersonAddress, createPersonEmail, createPersonFieldData, createPersonPhoneNumber, createPersonSocialProfile, createWorkflowCard, createWorkflowCardNote, deleteFieldDefinition, deletePerson, deletePersonFieldData, deleteSocialProfile, getFieldDefinitions, getFieldOptions, getHousehold, getHouseholds, getTabs, getTab, getListById, getListCategories, getLists, runList, getNote, getNoteCategories, getNotes, getOrganization, getPeople, getPerson, getPersonAddresses, getPersonEmails, getPersonFieldData, getPersonPhoneNumbers, getPersonSocialProfiles, getWorkflow, getWorkflowCardNotes, getWorkflowCards, getWorkflows, updatePerson, updatePersonAddress, } from './people';
 export { attemptRecovery, CircuitBreaker, classifyError, createErrorReport, DEFAULT_RETRY_CONFIG, executeBulkOperation, retryWithExponentialBackoff, TIMEOUT_CONFIG, withTimeout, } from './error-scenarios';
-export { buildQueryParams, calculateAge, calculateTrust, createPersonWithContact, createWorkflowCardWithNote, DEFAULT_TRUST_WINDOW, emailDomainsMatch, exportAllPeopleData, extractEmailDomain, extractFileUrl, formatDate, formatPersonName, getCompletePersonProfile, getFileExtension, getFilename, getListsWithCategories, getOrganizationInfo, getPeopleByHousehold, getPersonWorkflowCardsWithNotes, getPrimaryContact, isFileUpload, isFileUrl, isValidEmail, isValidPhone, normalizeEmail, normalizePhone, phoneNumbersSimilar, processFileValue, searchPeople, validateContactSimilarity, validatePersonData, } from './helpers';
+export { calculateAge, calculateTrust, createPersonWithContact, createWorkflowCardWithNote, DEFAULT_TRUST_WINDOW, emailDomainsMatch, exportAllPeopleData, extractEmailDomain, extractFileUrl, formatDate, formatPersonName, getCompletePersonProfile, getFileExtension, getFilename, getListsWithCategories, getOrganizationInfo, getPeopleByHousehold, getPersonWorkflowCardsWithNotes, getPrimaryContact, isFileUpload, isFileUrl, isValidEmail, isValidPhone, normalizeEmail, normalizePhone, phoneNumbersSimilar, processFileValue, searchPeople, validateContactSimilarity, validatePersonData, findIncluded, resolveIncluded, createIncludedLookup, } from './helpers';
 export type { TrustResult } from './helpers';
 export { DEFAULT_INITIAL_RETRY_CONFIG, DEFAULT_AGGRESSIVE_RETRY_CONFIG, } from './modules/people';
 export type { RetryConfig, PersonMatchOptions } from './modules/people';
+export type { PersonListOptions, PersonPageOptions, PersonInclude, PersonOrderField, PersonWhereClause, FieldDefinitionListOptions, FieldDefinitionInclude, FieldDefinitionOrderField, FieldDefinitionWhereClause, WorkflowListOptions, WorkflowPageOptions, WorkflowInclude, WorkflowOrderField, WorkflowWhereClause, NoteListOptions, NotePageOptions, NoteInclude, NoteOrderField, NoteWhereClause, ListListOptions, ListPageOptions, ListInclude, ListOrderField, ListWhereClause, HouseholdListOptions, HouseholdPageOptions, HouseholdInclude, HouseholdOrderField, HouseholdWhereClause, CampusListOptions, CampusPageOptions, CampusInclude, CampusOrderField, CampusWhereClause, FormListOptions, FormPageOptions, ReportListOptions, ReportPageOptions, ServiceTimeListOptions, ServiceTimePageOptions, } from './types/api-options';
 export { AdaptiveRateLimiter, ApiCache, batchFetchPersonDetails, fetchAllPages, getCachedPeople, monitorPerformance, PerformanceMonitor, processInBatches, processLargeDataset, streamPeopleData, } from './performance';
 export { MockPcoClient, MockResponseBuilder, RequestRecorder, createMockClient, createRecordingClient, createTestClient, createErrorMockClient, createSlowMockClient, } from './testing';
 export type { MockClientConfig, RecordingConfig } from './testing';