@rachelallyson/planning-center-people-ts 2.8.0 → 2.9.1

package/dist/matching/matcher.js

@@ -11,17 +11,30 @@ class PersonMatcher {
     constructor(peopleModule) {
         this.peopleModule = peopleModule;
         this.strategies = new strategies_1.MatchStrategies();
-        this.scorer = new scoring_1.MatchScorer();
+        this.scorer = new scoring_1.MatchScorer(peopleModule);
     }
     /**
      * Find or create a person with smart matching
+     *
+     * Uses intelligent matching logic that:
+     * - Verifies email/phone matches by checking actual contact information
+     * - Only uses name matching when appropriate (multiple people share contact info, or no contact info provided)
+     * - Can automatically add missing contact information when a match is found (if addMissingContactInfo is true)
+     *
+     * @param options - Matching options
+     * @param options.addMissingContactInfo - If true, automatically adds missing email/phone to matched person's profile
      */
     async findOrCreate(options) {
-        const { createIfNotFound = true, matchStrategy = 'fuzzy', ...searchOptions } = options;
+        const { createIfNotFound = true, matchStrategy = 'fuzzy', addMissingContactInfo = false, ...searchOptions } = options;
         // Try to find existing person
         const match = await this.findMatch({ ...searchOptions, matchStrategy });
         if (match) {
-            return match.person;
+            const person = match.person;
+            // Add missing contact information if requested
+            if (addMissingContactInfo) {
+                await this.addMissingContactInfo(person, options);
+            }
+            return person;
         }
         // Create new person if not found and creation is enabled
         if (createIfNotFound) {
@@ -33,26 +46,103 @@ class PersonMatcher {
      * Find the best match for a person
      */
     async findMatch(options) {
-        const { matchStrategy = 'fuzzy' } = options;
-        // Get all potential matches
-        const candidates = await this.getCandidates(options);
-        if (candidates.length === 0) {
+        const { matchStrategy = 'fuzzy', email, phone, firstName, lastName } = options;
+        // Step 1: Try email/phone search first
+        const emailPhoneMatches = [];
+        const nameOnlyMatches = [];
+        // Search by email
+        if (email) {
+            try {
+                const emailResults = await this.peopleModule.search({ email });
+                emailPhoneMatches.push(...emailResults.data);
+            }
+            catch (error) {
+                console.warn('Email search failed:', error);
+            }
+        }
+        // Search by phone
+        if (phone) {
+            try {
+                const phoneResults = await this.peopleModule.search({ phone });
+                emailPhoneMatches.push(...phoneResults.data);
+            }
+            catch (error) {
+                console.warn('Phone search failed:', error);
+            }
+        }
+        // Remove duplicates
+        const uniqueEmailPhoneMatches = emailPhoneMatches.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        // Step 2: Verify email/phone actually match
+        const verifiedMatches = [];
+        for (const candidate of uniqueEmailPhoneMatches) {
+            let emailMatches = false;
+            let phoneMatches = false;
+            if (email) {
+                emailMatches = await this.verifyEmailMatch(candidate, email);
+            }
+            if (phone) {
+                phoneMatches = await this.verifyPhoneMatch(candidate, phone);
+            }
+            // Only include if email OR phone matches (at least one required)
+            if (emailMatches || phoneMatches) {
+                verifiedMatches.push(candidate);
+            }
+        }
+        // Step 3: Only search by name if:
+        //   - Email/phone search found multiple verified results (need name to distinguish), OR
+        //   - No email/phone was provided (name-only matching is OK)
+        //   NOTE: Do NOT search by name if email/phone were provided but don't match
+        if (verifiedMatches.length > 1 || (!email && !phone)) {
+            if (firstName && lastName) {
+                try {
+                    const nameResults = await this.peopleModule.search({
+                        name: `${firstName} ${lastName}`
+                    });
+                    nameOnlyMatches.push(...nameResults.data);
+                }
+                catch (error) {
+                    console.warn('Name search failed:', error);
+                }
+            }
+        }
+        // Step 4: Combine verified email/phone matches with name matches
+        // Prioritize email/phone matches over name-only matches
+        const allCandidates = [...verifiedMatches, ...nameOnlyMatches];
+        // Remove duplicates
+        const uniqueCandidates = allCandidates.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        // Filter by age preferences
+        const ageFilteredCandidates = this.filterByAgePreferences(uniqueCandidates, options);
+        if (ageFilteredCandidates.length === 0) {
             return null;
         }
         // Score and rank candidates
-        const scoredCandidates = candidates.map(candidate => ({
+        const scoredCandidates = await Promise.all(ageFilteredCandidates.map(async (candidate) => ({
             person: candidate,
-            score: this.scorer.scoreMatch(candidate, options),
-            reason: this.scorer.getMatchReason(candidate, options),
-        }));
-        // Sort by score (highest first)
-        scoredCandidates.sort((a, b) => b.score - a.score);
+            score: await this.scorer.scoreMatch(candidate, options),
+            reason: await this.scorer.getMatchReason(candidate, options),
+            // Mark if this is a verified email/phone match
+            isVerifiedContactMatch: verifiedMatches.some(v => v.id === candidate.id)
+        })));
+        // Sort by verified match first, then by score
+        scoredCandidates.sort((a, b) => {
+            if (a.isVerifiedContactMatch && !b.isVerifiedContactMatch)
+                return -1;
+            if (!a.isVerifiedContactMatch && b.isVerifiedContactMatch)
+                return 1;
+            return b.score - a.score;
+        });
+        // For "exact" strategy, only return verified email/phone matches
+        if (matchStrategy === 'exact') {
+            const exactMatches = scoredCandidates.filter(c => c.isVerifiedContactMatch && c.score >= 0.8);
+            return exactMatches.length > 0 ? exactMatches[0] : null;
+        }
         // Apply strategy-specific filtering
         const bestMatch = this.strategies.selectBestMatch(scoredCandidates, matchStrategy);
         return bestMatch;
     }
     /**
      * Get potential matching candidates
+     * @deprecated Use findMatch which has improved logic for separating verified matches from name-only matches
      */
     async getCandidates(options) {
         const candidates = [];
@@ -107,6 +197,78 @@ class PersonMatcher {
         const ageFilteredCandidates = this.filterByAgePreferences(uniqueCandidates, options);
         return ageFilteredCandidates;
     }
+    /**
+     * Verify if a person's email actually matches the search email
+     */
+    async verifyEmailMatch(person, email) {
+        try {
+            const personEmails = await this.peopleModule.getEmails(person.id);
+            const normalizedSearchEmail = email.toLowerCase().trim();
+            const emails = personEmails.data?.map(e => e.attributes?.address?.toLowerCase().trim()).filter(Boolean) || [];
+            return emails.includes(normalizedSearchEmail);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Verify if a person's phone actually matches the search phone
+     */
+    async verifyPhoneMatch(person, phone) {
+        try {
+            const personPhones = await this.peopleModule.getPhoneNumbers(person.id);
+            const normalizePhone = (num) => {
+                const digits = num.replace(/\D/g, '');
+                return digits.length === 10 ? `+1${digits}` :
+                    digits.length === 11 && digits.startsWith('1') ? `+${digits}` :
+                        `+${digits}`;
+            };
+            const normalizedSearchPhone = normalizePhone(phone);
+            const phones = personPhones.data?.map(p => normalizePhone(p.attributes?.number || '')).filter(Boolean) || [];
+            return phones.includes(normalizedSearchPhone);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Add missing contact information to a person's profile
+     */
+    async addMissingContactInfo(person, options) {
+        const { email, phone } = options;
+        // Check and add email if provided and missing
+        if (email) {
+            try {
+                const hasEmail = await this.verifyEmailMatch(person, email);
+                if (!hasEmail) {
+                    await this.peopleModule.addEmail(person.id, {
+                        address: email,
+                        location: 'Home',
+                        primary: false // Don't override existing primary email
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to add email contact for person ${person.id}:`, error);
+            }
+        }
+        // Check and add phone if provided and missing
+        if (phone) {
+            try {
+                const hasPhone = await this.verifyPhoneMatch(person, phone);
+                if (!hasPhone) {
+                    await this.peopleModule.addPhoneNumber(person.id, {
+                        number: phone,
+                        location: 'Home',
+                        primary: false // Don't override existing primary phone
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to add phone contact for person ${person.id}:`, error);
+            }
+        }
+    }
     /**
      * Filter candidates by age preferences
      */
@@ -181,24 +343,93 @@ class PersonMatcher {
      * Get all potential matches with detailed scoring
      */
     async getAllMatches(options) {
-        const candidates = await this.getCandidates(options);
-        return candidates.map(candidate => ({
+        // Use the improved matching logic from findMatch
+        const { matchStrategy = 'fuzzy', email, phone, firstName, lastName } = options;
+        const emailPhoneMatches = [];
+        const nameOnlyMatches = [];
+        if (email) {
+            try {
+                const emailResults = await this.peopleModule.search({ email });
+                emailPhoneMatches.push(...emailResults.data);
+            }
+            catch (error) {
+                console.warn('Email search failed:', error);
+            }
+        }
+        if (phone) {
+            try {
+                const phoneResults = await this.peopleModule.search({ phone });
+                emailPhoneMatches.push(...phoneResults.data);
+            }
+            catch (error) {
+                console.warn('Phone search failed:', error);
+            }
+        }
+        const uniqueEmailPhoneMatches = emailPhoneMatches.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        const verifiedMatches = [];
+        for (const candidate of uniqueEmailPhoneMatches) {
+            let emailMatches = false;
+            let phoneMatches = false;
+            if (email) {
+                emailMatches = await this.verifyEmailMatch(candidate, email);
+            }
+            if (phone) {
+                phoneMatches = await this.verifyPhoneMatch(candidate, phone);
+            }
+            if (emailMatches || phoneMatches) {
+                verifiedMatches.push(candidate);
+            }
+        }
+        if (verifiedMatches.length > 1 || (!email && !phone)) {
+            if (firstName && lastName) {
+                try {
+                    const nameResults = await this.peopleModule.search({
+                        name: `${firstName} ${lastName}`
+                    });
+                    nameOnlyMatches.push(...nameResults.data);
+                }
+                catch (error) {
+                    console.warn('Name search failed:', error);
+                }
+            }
+        }
+        const allCandidates = [...verifiedMatches, ...nameOnlyMatches];
+        const uniqueCandidates = allCandidates.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        const ageFilteredCandidates = this.filterByAgePreferences(uniqueCandidates, options);
+        const scoredCandidates = await Promise.all(ageFilteredCandidates.map(async (candidate) => ({
             person: candidate,
-            score: this.scorer.scoreMatch(candidate, options),
-            reason: this.scorer.getMatchReason(candidate, options),
-        })).sort((a, b) => b.score - a.score);
+            score: await this.scorer.scoreMatch(candidate, options),
+            reason: await this.scorer.getMatchReason(candidate, options),
+            isVerifiedContactMatch: verifiedMatches.some(v => v.id === candidate.id)
+        })));
+        return scoredCandidates.sort((a, b) => {
+            if (a.isVerifiedContactMatch && !b.isVerifiedContactMatch)
+                return -1;
+            if (!a.isVerifiedContactMatch && b.isVerifiedContactMatch)
+                return 1;
+            return b.score - a.score;
+        });
     }
     /**
      * Check if a person matches the given criteria
      */
     async isMatch(personId, options) {
         const person = await this.peopleModule.getById(personId);
-        const score = this.scorer.scoreMatch(person, options);
+        const score = await this.scorer.scoreMatch(person, options);
         if (score > 0.5) { // Threshold for considering it a match
+            // Check if this is a verified contact match
+            let isVerifiedContactMatch = false;
+            if (options.email) {
+                isVerifiedContactMatch = await this.verifyEmailMatch(person, options.email);
+            }
+            if (!isVerifiedContactMatch && options.phone) {
+                isVerifiedContactMatch = await this.verifyPhoneMatch(person, options.phone);
+            }
             return {
                 person,
                 score,
-                reason: this.scorer.getMatchReason(person, options),
+                reason: await this.scorer.getMatchReason(person, options),
+                isVerifiedContactMatch,
             };
         }
         return null;

package/dist/matching/scoring.d.ts

@@ -2,24 +2,26 @@
  * v2.0.0 Person Match Scoring
  */
 import type { PersonResource } from '../types';
-import type { PersonMatchOptions } from '../modules/people';
+import type { PersonMatchOptions, PeopleModule } from '../modules/people';
 export declare class MatchScorer {
+    private peopleModule;
+    constructor(peopleModule: PeopleModule);
     /**
      * Score a person match based on various criteria
      */
-    scoreMatch(person: PersonResource, options: PersonMatchOptions): number;
+    scoreMatch(person: PersonResource, options: PersonMatchOptions): Promise<number>;
     /**
      * Get a human-readable reason for the match
      */
-    getMatchReason(person: PersonResource, options: PersonMatchOptions): string;
+    getMatchReason(person: PersonResource, options: PersonMatchOptions): Promise<string>;
     /**
-     * Score email matching
+     * Score email matching - verifies actual email matches
      */
-    private scoreEmailMatch;
+    scoreEmailMatch(person: PersonResource, email: string): Promise<number>;
     /**
-     * Score phone matching
+     * Score phone matching - verifies actual phone matches
      */
-    private scorePhoneMatch;
+    scorePhoneMatch(person: PersonResource, phone: string): Promise<number>;
     /**
      * Score name matching - only exact matches
      */

package/dist/matching/scoring.js

@@ -6,21 +6,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MatchScorer = void 0;
 const helpers_1 = require("../helpers");
 class MatchScorer {
+    constructor(peopleModule) {
+        this.peopleModule = peopleModule;
+    }
     /**
      * Score a person match based on various criteria
      */
-    scoreMatch(person, options) {
+    async scoreMatch(person, options) {
         let totalScore = 0;
         let maxScore = 0;
         // Email matching (highest weight)
         if (options.email) {
-            const emailScore = this.scoreEmailMatch(person, options.email);
+            const emailScore = await this.scoreEmailMatch(person, options.email);
             totalScore += emailScore * 0.35;
             maxScore += 0.35;
         }
         // Phone matching (high weight)
         if (options.phone) {
-            const phoneScore = this.scorePhoneMatch(person, options.phone);
+            const phoneScore = await this.scorePhoneMatch(person, options.phone);
             totalScore += phoneScore * 0.25;
             maxScore += 0.25;
         }
@@ -45,13 +48,19 @@ class MatchScorer {
     /**
      * Get a human-readable reason for the match
      */
-    getMatchReason(person, options) {
+    async getMatchReason(person, options) {
         const reasons = [];
-        if (options.email && this.scoreEmailMatch(person, options.email) > 0.8) {
-            reasons.push('exact email match');
+        if (options.email) {
+            const emailScore = await this.scoreEmailMatch(person, options.email);
+            if (emailScore > 0.8) {
+                reasons.push('exact email match');
+            }
         }
-        if (options.phone && this.scorePhoneMatch(person, options.phone) > 0.8) {
-            reasons.push('exact phone match');
+        if (options.phone) {
+            const phoneScore = await this.scorePhoneMatch(person, options.phone);
+            if (phoneScore > 0.8) {
+                reasons.push('exact phone match');
+            }
         }
         if (options.firstName || options.lastName) {
             const nameScore = this.scoreNameMatch(person, options);
@@ -84,22 +93,42 @@ class MatchScorer {
         return reasons.join(', ');
     }
     /**
-     * Score email matching
+     * Score email matching - verifies actual email matches
      */
-    scoreEmailMatch(person, email) {
-        // Check if the person has the email in their relationships or attributes
-        // For now, we'll assume if the search found this person by email, it's a match
-        // In a more sophisticated implementation, we'd fetch and compare actual emails
-        return 1.0; // Perfect match since search found this person by email
+    async scoreEmailMatch(person, email) {
+        try {
+            const personEmails = await this.peopleModule.getEmails(person.id);
+            const normalizedSearchEmail = email.toLowerCase().trim();
+            // Check if any of the person's emails match
+            const emails = personEmails.data?.map(e => e.attributes?.address?.toLowerCase().trim()).filter(Boolean) || [];
+            return emails.includes(normalizedSearchEmail) ? 1.0 : 0.0;
+        }
+        catch (error) {
+            console.warn(`Failed to verify email match for person ${person.id}:`, error);
+            return 0.0;
+        }
     }
     /**
-     * Score phone matching
+     * Score phone matching - verifies actual phone matches
      */
-    scorePhoneMatch(person, phone) {
-        // Check if the person has the phone in their relationships or attributes
-        // For now, we'll assume if the search found this person by phone, it's a match
-        // In a more sophisticated implementation, we'd fetch and compare actual phones
-        return 1.0; // Perfect match since search found this person by phone
+    async scorePhoneMatch(person, phone) {
+        try {
+            const personPhones = await this.peopleModule.getPhoneNumbers(person.id);
+            // Normalize phone numbers for comparison
+            const normalizePhone = (num) => {
+                const digits = num.replace(/\D/g, '');
+                return digits.length === 10 ? `+1${digits}` :
+                    digits.length === 11 && digits.startsWith('1') ? `+${digits}` :
+                        `+${digits}`;
+            };
+            const normalizedSearchPhone = normalizePhone(phone);
+            const phones = personPhones.data?.map(p => normalizePhone(p.attributes?.number || '')).filter(Boolean) || [];
+            return phones.includes(normalizedSearchPhone) ? 1.0 : 0.0;
+        }
+        catch (error) {
+            console.warn(`Failed to verify phone match for person ${person.id}:`, error);
+            return 0.0;
+        }
     }
     /**
      * Score name matching - only exact matches

package/dist/matching/strategies.d.ts

@@ -10,6 +10,7 @@ export declare class MatchStrategies {
     selectBestMatch(candidates: MatchResult[], strategy: MatchStrategy): MatchResult | null;
     /**
      * Exact matching strategy - only return matches with very high confidence
+     * Requires verified email/phone matches unless multiple people share the same contact info
      */
     private selectExactMatch;
     /**

package/dist/matching/strategies.js

@@ -25,10 +25,23 @@ class MatchStrategies {
     }
     /**
      * Exact matching strategy - only return matches with very high confidence
+     * Requires verified email/phone matches unless multiple people share the same contact info
      */
     selectExactMatch(candidates) {
-        // Only return matches with score >= 0.8 (lowered from 0.9)
-        const exactMatches = candidates.filter(c => c.score >= 0.8);
+        // For exact match, require verified email/phone match
+        // Only allow name-only matches if multiple people share same email/phone (to distinguish)
+        const verifiedMatches = candidates.filter(c => c.isVerifiedContactMatch);
+        const verifiedCount = verifiedMatches.length;
+        const exactMatches = candidates.filter(c => {
+            // Must have score >= 0.8
+            if (c.score < 0.8)
+                return false;
+            // Must be a verified contact match (email/phone), OR
+            // Must be a name-only match with multiple verified matches (to distinguish)
+            const isNameMatch = c.reason.includes('name match');
+            return c.isVerifiedContactMatch ||
+                (isNameMatch && verifiedCount > 1);
+        });
         return exactMatches.length > 0 ? exactMatches[0] : null;
     }
     /**

package/dist/modules/campus.d.ts

@@ -1,8 +1,8 @@
-import { BaseModule } from './base';
-import type { PcoHttpClient } from '../core/http';
-import type { PaginationHelper } from '../core/pagination';
-import type { PcoEventEmitter } from '../monitoring';
-import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PcoHttpClient } from '@rachelallyson/planning-center-base-ts';
+import type { PaginationHelper } from '@rachelallyson/planning-center-base-ts';
+import type { PcoEventEmitter } from '@rachelallyson/planning-center-base-ts';
+import type { PaginationOptions, PaginationResult } from '@rachelallyson/planning-center-base-ts';
 import type { CampusResource, CampusAttributes, CampusesList } from '../types';
 /**
  * Campus module for managing campus-related operations

package/dist/modules/campus.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CampusModule = void 0;
-const base_1 = require("./base");
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 /**
  * Campus module for managing campus-related operations
  */
-class CampusModule extends base_1.BaseModule {
+class CampusModule extends planning_center_base_ts_1.BaseModule {
     constructor(httpClient, paginationHelper, eventEmitter) {
         super(httpClient, paginationHelper, eventEmitter);
     }

package/dist/modules/contacts.d.ts

@@ -1,7 +1,7 @@
 /**
  * v2.0.0 Contacts Module
  */
-import { BaseModule } from './base';
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
 import type { EmailResource, EmailAttributes, PhoneNumberResource, PhoneNumberAttributes, AddressResource, AddressAttributes, SocialProfileResource, SocialProfileAttributes } from '../types';
 export declare class ContactsModule extends BaseModule {
     /**

package/dist/modules/contacts.js

@@ -4,8 +4,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContactsModule = void 0;
-const base_1 = require("./base");
-class ContactsModule extends base_1.BaseModule {
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class ContactsModule extends planning_center_base_ts_1.BaseModule {
     /**
      * Get all emails
      */

package/dist/modules/fields.d.ts

@@ -1,10 +1,10 @@
 /**
  * v2.0.0 Fields Module
  */
-import { BaseModule } from './base';
-import type { PcoHttpClient } from '../core/http';
-import type { PaginationHelper } from '../core/pagination';
-import type { PcoEventEmitter } from '../monitoring';
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PcoHttpClient } from '@rachelallyson/planning-center-base-ts';
+import type { PaginationHelper } from '@rachelallyson/planning-center-base-ts';
+import type { PcoEventEmitter } from '@rachelallyson/planning-center-base-ts';
 import type { FieldDefinitionResource, FieldDefinitionAttributes, FieldDatumResource, FieldOptionResource, FieldOptionAttributes, TabResource, TabAttributes } from '../types';
 export interface FieldDefinitionCache {
     byId: Map<string, FieldDefinitionResource>;

package/dist/modules/fields.js

@@ -4,8 +4,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldsModule = void 0;
-const base_1 = require("./base");
-class FieldsModule extends base_1.BaseModule {
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class FieldsModule extends planning_center_base_ts_1.BaseModule {
     constructor(httpClient, paginationHelper, eventEmitter) {
         super(httpClient, paginationHelper, eventEmitter);
         this.fieldDefinitionCache = null;

package/dist/modules/forms.d.ts

@@ -1,7 +1,10 @@
-import { BaseModule } from './base';
-import type { PcoHttpClient } from '../core/http';
-import type { PaginationHelper } from '../core/pagination';
-import type { PcoEventEmitter } from '../monitoring';
+/**
+ * v2.0.0 Forms Module
+ */
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PcoHttpClient } from '@rachelallyson/planning-center-base-ts';
+import type { PaginationHelper } from '@rachelallyson/planning-center-base-ts';
+import type { PcoEventEmitter } from '@rachelallyson/planning-center-base-ts';
 import type { FormResource, FormsList, FormCategoryResource, FormFieldResource, FormFieldOptionResource, FormSubmissionResource, FormSubmissionValueResource } from '../types';
 /**
  * Forms module for managing form-related operations

package/dist/modules/forms.js

@@ -1,12 +1,15 @@
 "use strict";
+/**
+ * v2.0.0 Forms Module
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormsModule = void 0;
-const base_1 = require("./base");
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 /**
  * Forms module for managing form-related operations
  * Most operations are read-only based on API documentation
  */
-class FormsModule extends base_1.BaseModule {
+class FormsModule extends planning_center_base_ts_1.BaseModule {
     constructor(httpClient, paginationHelper, eventEmitter) {
         super(httpClient, paginationHelper, eventEmitter);
     }

package/dist/modules/households.d.ts

@@ -1,8 +1,8 @@
 /**
  * v2.0.0 Households Module
  */
-import { BaseModule } from './base';
-import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PaginationOptions, PaginationResult } from '@rachelallyson/planning-center-base-ts';
 import type { HouseholdResource, HouseholdAttributes } from '../types';
 export interface HouseholdListOptions {
     where?: Record<string, any>;

package/dist/modules/households.js

@@ -4,8 +4,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HouseholdsModule = void 0;
-const base_1 = require("./base");
-class HouseholdsModule extends base_1.BaseModule {
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class HouseholdsModule extends planning_center_base_ts_1.BaseModule {
     /**
      * Get all households
      */

package/dist/modules/lists.d.ts

@@ -1,8 +1,8 @@
 /**
  * v2.0.0 Lists Module
  */
-import { BaseModule } from './base';
-import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PaginationOptions, PaginationResult } from '@rachelallyson/planning-center-base-ts';
 import type { ListResource, ListCategoryResource, ListCategoryAttributes, PersonResource } from '../types';
 export interface ListsListOptions {
     where?: Record<string, any>;