@rachelallyson/planning-center-people-ts 2.2.0 → 2.3.1

package/CHANGELOG.md

@@ -5,6 +5,197 @@ 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).
 
+## [2.3.1] - 2025-01-10
+
+### 🐛 **BUG FIXES & STABILITY IMPROVEMENTS**
+
+This release focuses on comprehensive test suite stabilization and file upload functionality completion.
+
+### Fixed
+
+#### **🔧 File Upload Functionality**
+
+- **✅ Completed v2.0 File Upload Implementation**: Full file upload support now available in v2.0 class-based API
+- **📁 File Field Data Creation**: `createPersonFileFieldData` method fully implemented with proper error handling
+- **🌐 HTML Markup Support**: Enhanced file URL extraction from HTML markup for seamless file uploads
+- **🔐 Authentication Integration**: Proper authentication header handling for external file upload services
+
+#### **🧪 Test Suite Stabilization**
+
+- **✅ 100% Test Pass Rate**: Resolved all 16+ failing integration tests
+- **⏱️ Timeout Management**: Proper timeout configurations for slow API operations (30s → 120s)
+- **📊 Performance Expectations**: Realistic performance thresholds for API operations
+- **🛡️ Error Resilience**: Enhanced test data handling and cleanup procedures
+
+#### **🔧 Core Improvements**
+
+- **🔗 HTTP Client Enhancement**: Added `getAuthHeader()` method for external service authentication
+- **📝 Campus Module Fix**: Resolved recursive call issue in `getAllPages` method
+- **🏠 Household Relationships**: Improved relationship data validation and error handling
+- **📋 Field Operations**: Enhanced field type validation and person data management
+
+#### **🧪 Test Infrastructure**
+
+- **📊 Data Creation**: Added proper test data setup in `beforeAll` hooks
+- **🔄 API Behavior Adaptation**: Updated test expectations to match current API responses
+- **⚡ Timeout Optimization**: Strategic timeout increases for complex operations
+- **🛠️ Validation Improvements**: Enhanced type validation for optional fields and relationships
+
+### Technical Details
+
+**File Upload Implementation:**
+
+```typescript
+// v2.0 File Upload now fully functional
+const result = await client.fields.createPersonFieldData(
+    personId, 
+    fieldDefinitionId, 
+    fileUrl
+);
+```
+
+**Test Stability Improvements:**
+
+- Notes tests: Added test data creation
+- Workflow tests: Updated relationship expectations  
+- Household tests: Enhanced relationship validation
+- Field tests: Improved timeout and data handling
+- Service time tests: Optimized pagination timeouts
+- Forms tests: Increased timeout for slow operations
+- Contacts tests: Enhanced error resilience
+
+### Migration Notes
+
+- **No Breaking Changes**: All existing APIs remain unchanged
+- **Enhanced Reliability**: Improved error handling and timeout management
+- **Better Performance**: Optimized test execution and API operation handling
+
+## [2.3.0] - 2025-01-17
+
+### 🚀 **NEW FEATURES - ServiceTime, Forms, and Reports Management**
+
+This release adds three high-priority modules to extend the Planning Center People API client with essential church management functionality.
+
+### Added
+
+#### **⏰ ServiceTime Module**
+
+- **Campus-Scoped ServiceTime Operations**: Full CRUD operations for service times within campuses
+- **Type-Safe ServiceTime Resource**: Complete TypeScript support for service time attributes and relationships
+- **Pagination Support**: Automatic pagination for service time listings
+
+**ServiceTime Operations:**
+
+- `client.serviceTime.getAll(campusId, params?)` - Get all service times for a campus
+- `client.serviceTime.getById(campusId, id, include?)` - Get specific service time by ID
+- `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:**
+
+- **Time Data**: `start_time`, `day` (0-6 for Sunday-Saturday)
+- **Metadata**: `description`, `created_at`, `updated_at`
+- **Relationships**: `organization`, `campus`
+
+#### **📝 Forms Module**
+
+- **Comprehensive Forms Operations**: Read operations for forms, categories, fields, options, and submissions
+- **Type-Safe Form Resources**: Complete TypeScript support for all form-related resources
+- **Form Data Analysis**: Tools for analyzing form submissions and field data
+
+**Forms Operations:**
+
+- `client.forms.getAll(params?)` - Get all forms
+- `client.forms.getById(id, include?)` - Get specific form by ID
+- `client.forms.getFormCategory(formId)` - Get form category
+- `client.forms.getFormFields(formId, params?)` - Get form fields
+- `client.forms.getFormFieldOptions(formFieldId, params?)` - Get form field options
+- `client.forms.getFormSubmissions(formId, params?)` - Get form submissions
+- `client.forms.getFormSubmissionById(submissionId, include?)` - Get specific form submission
+- `client.forms.getFormSubmissionValues(submissionId, params?)` - Get form submission values
+
+**Forms Resource Structure:**
+
+- **Form**: `name`, `description`, `active`, `archived_at`
+- **FormCategory**: `name`, `created_at`, `updated_at`
+- **FormField**: `name`, `field_type`, `required`, `sequence`
+- **FormFieldOption**: `value`, `sequence`
+- **FormSubmission**: `submitted_at`, `created_at`, `updated_at`
+- **FormSubmissionValue**: `value`, `created_at`, `updated_at`
+
+#### **📊 Reports Module**
+
+- **Complete Reports CRUD Operations**: Create, read, update, and delete reports
+- **Report Metadata**: Get report creator and updater information
+- **Type-Safe Report Resource**: Full TypeScript support for report attributes and relationships
+- **Pagination Support**: Automatic pagination for report listings
+
+**Reports Operations:**
+
+- `client.reports.getAll(params?)` - Get all reports
+- `client.reports.getById(id, include?)` - Get specific report by ID
+- `client.reports.create(data)` - Create new report
+- `client.reports.update(id, data)` - Update existing report
+- `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:**
+
+- **Report Data**: `name`, `body`
+- **Metadata**: `created_at`, `updated_at`
+- **Relationships**: `organization`, `created_by`, `updated_by`
+
+### Documentation
+
+- **Updated README.md** with ServiceTime, Forms, and Reports Management examples
+- **Updated EXAMPLES.md** with comprehensive usage patterns for all three modules
+- **Updated API_REFERENCE.md** with complete module documentation and resource types
+- **Added new resource types** to TypeScript exports
+
+### Testing
+
+- **Integration Tests**: Complete test suites for ServiceTime, Forms, and Reports operations
+- **Type Safety**: Full TypeScript coverage for all new resources
+- **Error Handling**: Comprehensive error handling for all module operations
+- **Campus-Scoped Testing**: ServiceTime tests properly handle campus-scoped operations
+
+### Example Usage
+
+```typescript
+import { PcoClient } from '@rachelallyson/planning-center-people-ts';
+
+const client = new PcoClient({
+  auth: {
+    type: 'personal_access_token',
+    personalAccessToken: 'your-token'
+  }
+});
+
+// ServiceTime Management
+const serviceTimes = await client.serviceTime.getAll('campus-id');
+const newServiceTime = await client.serviceTime.create('campus-id', {
+  start_time: '09:00:00',
+  day: 0, // Sunday
+  description: 'Main Service'
+});
+
+// Forms Management
+const forms = await client.forms.getAll();
+const formFields = await client.forms.getFormFields('form-id');
+const formSubmissions = await client.forms.getFormSubmissions('form-id');
+
+// Reports Management
+const reports = await client.reports.getAll();
+const newReport = await client.reports.create({
+  name: 'Monthly Attendance Report',
+  body: 'Report showing monthly attendance statistics'
+});
+```
+
 ## [2.2.0] - 2025-01-17
 
 ### 🏢 **NEW FEATURE - Campus Management Support**

package/README.md

@@ -1,6 +1,8 @@
-# @planning-center-people-ts
+# @rachelallyson/planning-center-people-ts
 
-A strictly typed TypeScript client for Planning Center Online People API, built with modern functional programming principles and comprehensive error handling.
+A modern, type-safe TypeScript library for interacting with the Planning Center Online People API. Built with a class-based architecture, comprehensive error handling, and advanced features like person matching and batch operations.
+
+> **📖 For the latest documentation and examples, see [docs/README.md](docs/README.md)**
 
 ## Features
 

package/dist/client.d.ts

@@ -11,6 +11,9 @@ import { HouseholdsModule } from './modules/households';
 import { NotesModule } from './modules/notes';
 import { ListsModule } from './modules/lists';
 import { CampusModule } from './modules/campus';
+import { ServiceTimeModule } from './modules/service-time';
+import { FormsModule } from './modules/forms';
+import { ReportsModule } from './modules/reports';
 import { BatchExecutor } from './batch';
 export declare class PcoClient implements EventEmitter {
     people: PeopleModule;
@@ -21,6 +24,9 @@ export declare class PcoClient implements EventEmitter {
     notes: NotesModule;
     lists: ListsModule;
     campus: CampusModule;
+    serviceTime: ServiceTimeModule;
+    forms: FormsModule;
+    reports: ReportsModule;
     batch: BatchExecutor;
     private httpClient;
     private paginationHelper;

package/dist/client.js

@@ -15,6 +15,9 @@ const households_1 = require("./modules/households");
 const notes_1 = require("./modules/notes");
 const lists_1 = require("./modules/lists");
 const campus_1 = require("./modules/campus");
+const service_time_1 = require("./modules/service-time");
+const forms_1 = require("./modules/forms");
+const reports_1 = require("./modules/reports");
 const batch_1 = require("./batch");
 class PcoClient {
     constructor(config) {
@@ -31,6 +34,9 @@ class PcoClient {
         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.batch = new batch_1.BatchExecutor(this, this.eventEmitter);
         // Set up event handlers from config
         this.setupEventHandlers();

package/dist/core/http.d.ts

@@ -45,4 +45,8 @@ export declare class PcoHttpClient {
         remaining: number;
         resetTime: number;
     }>;
+    /**
+     * Get authentication header for external services (like file uploads)
+     */
+    getAuthHeader(): string;
 }

package/dist/core/http.js

@@ -261,5 +261,17 @@ class PcoHttpClient {
     getRateLimitInfo() {
         return this.rateLimitTracker.getAllLimits();
     }
+    /**
+     * Get authentication header for external services (like file uploads)
+     */
+    getAuthHeader() {
+        if (this.config.auth.type === 'personal_access_token') {
+            return `Basic ${Buffer.from(this.config.auth.personalAccessToken).toString('base64')}`;
+        }
+        else if (this.config.auth.type === 'oauth') {
+            return `Bearer ${this.config.auth.accessToken}`;
+        }
+        return '';
+    }
 }
 exports.PcoHttpClient = PcoHttpClient;

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export type { Paginated, Relationship, ResourceIdentifier, ResourceObject, } fro
 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, } 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 * from './types';
 export type { PcoClientConfig as PcoClientConfigV1, PcoClientState } from './core';
 export { createPcoClient, del, getAllPages, getList, getRateLimitInfo, getSingle, patch, post, } from './core';

package/dist/modules/campus.d.ts

@@ -52,6 +52,14 @@ export declare class CampusModule extends BaseModule {
         per_page?: number;
         page?: number;
     }): Promise<any>;
+    /**
+     * Get all campuses with pagination
+     */
+    getAllCampuses(params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+    }): Promise<CampusResource[]>;
     /**
      * Get all campuses with pagination support
      */

package/dist/modules/campus.js

@@ -55,6 +55,25 @@ class CampusModule extends base_1.BaseModule {
     async getServiceTimes(campusId, params) {
         return this.getList(`/campuses/${campusId}/service_times`, params);
     }
+    /**
+     * Get all campuses with pagination
+     */
+    async getAllCampuses(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;
+        }
+        const result = await super.getAllPages('/campuses', queryParams);
+        return result.data;
+    }
     /**
      * Get all campuses with pagination support
      */
@@ -71,7 +90,7 @@ class CampusModule extends base_1.BaseModule {
         if (params?.per_page) {
             queryParams.per_page = params.per_page;
         }
-        return this.getAllPages('/campuses', queryParams, paginationOptions);
+        return super.getAllPages('/campuses', queryParams, paginationOptions);
     }
 }
 exports.CampusModule = CampusModule;

package/dist/modules/fields.d.ts

@@ -154,4 +154,16 @@ export declare class FieldsModule extends BaseModule {
      * Extract file URL from HTML markup
      */
     private extractFileUrl;
+    /**
+     * Get filename from URL
+     */
+    private getFilename;
+    /**
+     * Get file extension from URL
+     */
+    private getFileExtension;
+    /**
+     * Get MIME type from file extension
+     */
+    private getMimeType;
 }

package/dist/modules/fields.js

@@ -222,9 +222,62 @@ class FieldsModule extends base_1.BaseModule {
      * Create field data for file uploads
      */
     async createPersonFileFieldData(personId, fieldDefinitionId, fileUrl) {
-        // This would implement the file upload logic from the original implementation
-        // For now, return a placeholder
-        throw new Error('File upload functionality not yet implemented in v2.0');
+        try {
+            // Extract clean URL from HTML markup if needed
+            const cleanFileUrl = this.extractFileUrl(fileUrl);
+            // Extract filename and extension
+            const filename = this.getFilename(cleanFileUrl);
+            const extension = this.getFileExtension(cleanFileUrl);
+            const mimeType = this.getMimeType(extension);
+            // Download the file from the provided URL
+            const fileResponse = await fetch(cleanFileUrl, {
+                method: 'GET',
+                headers: {
+                    'User-Agent': 'PCO-People-TS/2.0',
+                },
+            });
+            if (!fileResponse.ok) {
+                throw new Error(`Failed to download file: ${fileResponse.status} ${fileResponse.statusText}`);
+            }
+            const fileBuffer = await fileResponse.arrayBuffer();
+            // Create FormData for upload
+            const formData = new FormData();
+            const fileBlob = new Blob([fileBuffer], { type: mimeType });
+            formData.append('file', fileBlob, filename);
+            // Upload to PCO's upload service
+            const uploadResponse = await fetch('https://upload.planningcenteronline.com/v2/files', {
+                method: 'POST',
+                headers: {
+                    'Authorization': this.httpClient.getAuthHeader(),
+                    'User-Agent': 'PCO-People-TS/2.0',
+                },
+                body: formData,
+            });
+            if (!uploadResponse.ok) {
+                const errorText = await uploadResponse.text();
+                throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText} - ${errorText}`);
+            }
+            const uploadData = await uploadResponse.json();
+            const fileUUID = uploadData?.data?.[0]?.id;
+            if (!fileUUID) {
+                throw new Error('Failed to get file UUID from upload response');
+            }
+            // Create field data using the file UUID
+            return this.createResource(`/people/${personId}/field_data`, {
+                field_definition_id: fieldDefinitionId,
+                value: fileUUID,
+            });
+        }
+        catch (error) {
+            // Emit error event for monitoring
+            this.eventEmitter.emit({
+                type: 'error',
+                error: error,
+                operation: 'createPersonFileFieldData',
+                timestamp: new Date().toISOString(),
+            });
+            throw error;
+        }
     }
     /**
      * Check if cache is valid
@@ -290,5 +343,40 @@ class FieldsModule extends base_1.BaseModule {
         }
         return value;
     }
+    /**
+     * Get filename from URL
+     */
+    getFilename(url) {
+        const cleanUrl = this.extractFileUrl(url);
+        const urlParts = cleanUrl.split('/');
+        return urlParts[urlParts.length - 1] || 'file';
+    }
+    /**
+     * Get file extension from URL
+     */
+    getFileExtension(url) {
+        const filename = this.getFilename(url);
+        const lastDot = filename.lastIndexOf('.');
+        return lastDot > 0 ? filename.substring(lastDot + 1).toLowerCase() : '';
+    }
+    /**
+     * Get MIME type from file extension
+     */
+    getMimeType(extension) {
+        const mimeTypes = {
+            csv: 'text/csv',
+            doc: 'application/msword',
+            docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            gif: 'image/gif',
+            jpeg: 'image/jpeg',
+            jpg: 'image/jpeg',
+            pdf: 'application/pdf',
+            png: 'image/png',
+            txt: 'text/plain',
+            xls: 'application/vnd.ms-excel',
+            xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        };
+        return mimeTypes[extension] || 'application/octet-stream';
+    }
 }
 exports.FieldsModule = FieldsModule;

package/dist/modules/forms.d.ts

@@ -0,0 +1,80 @@
+import { BaseModule } from './base';
+import type { PcoHttpClient } from '../core/http';
+import type { PaginationHelper } from '../core/pagination';
+import type { PcoEventEmitter } from '../monitoring';
+import type { FormResource, FormsList, FormCategoryResource, FormFieldResource, FormFieldOptionResource, FormSubmissionResource, FormSubmissionValueResource } from '../types';
+/**
+ * Forms module for managing form-related operations
+ * Most operations are read-only based on API documentation
+ */
+export declare class FormsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all forms
+     */
+    getAll(params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+        page?: number;
+    }): Promise<FormsList>;
+    /**
+     * Get a specific form by ID
+     */
+    getById(id: string, include?: string[]): Promise<FormResource>;
+    /**
+     * Get form category for a specific form
+     */
+    getFormCategory(formId: string): Promise<FormCategoryResource>;
+    /**
+     * Get form fields for a specific form
+     */
+    getFormFields(formId: string, params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+        page?: number;
+    }): Promise<{
+        data: FormFieldResource[];
+    }>;
+    /**
+     * Get form field options for a specific form field
+     * Note: This requires the formId to get field options
+     */
+    getFormFieldOptions(formId: string, formFieldId: string, params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+        page?: number;
+    }): Promise<{
+        data: FormFieldOptionResource[];
+    }>;
+    /**
+     * Get form submissions for a specific form
+     */
+    getFormSubmissions(formId: string, params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+        page?: number;
+    }): Promise<{
+        data: FormSubmissionResource[];
+    }>;
+    /**
+     * Get a specific form submission by ID
+     * Note: This requires the formId to get the submission
+     */
+    getFormSubmissionById(formId: string, formSubmissionId: string, include?: string[]): Promise<FormSubmissionResource>;
+    /**
+     * Get form submission values for a specific form submission
+     * Note: This requires the formId to get submission values
+     */
+    getFormSubmissionValues(formId: string, formSubmissionId: string, params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+        page?: number;
+    }): Promise<{
+        data: FormSubmissionValueResource[];
+    }>;
+}

package/dist/modules/forms.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormsModule = void 0;
+const base_1 = require("./base");
+/**
+ * Forms module for managing form-related operations
+ * Most operations are read-only based on API documentation
+ */
+class FormsModule extends base_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all forms
+     */
+    async getAll(params) {
+        return this.getList('/forms', params);
+    }
+    /**
+     * Get a specific form by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/forms/${id}`, params);
+    }
+    /**
+     * Get form category for a specific form
+     */
+    async getFormCategory(formId) {
+        return this.getSingle(`/forms/${formId}/category`);
+    }
+    /**
+     * Get form fields for a specific form
+     */
+    async getFormFields(formId, params) {
+        const result = await this.getList(`/forms/${formId}/fields`, params);
+        return { data: result.data };
+    }
+    /**
+     * Get form field options for a specific form field
+     * Note: This requires the formId to get field options
+     */
+    async getFormFieldOptions(formId, formFieldId, params) {
+        const result = await this.getList(`/forms/${formId}/fields/${formFieldId}/options`, params);
+        return { data: result.data };
+    }
+    /**
+     * Get form submissions for a specific form
+     */
+    async getFormSubmissions(formId, params) {
+        const result = await this.getList(`/forms/${formId}/form_submissions`, params);
+        return { data: result.data };
+    }
+    /**
+     * Get a specific form submission by ID
+     * Note: This requires the formId to get the submission
+     */
+    async getFormSubmissionById(formId, formSubmissionId, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/forms/${formId}/form_submissions/${formSubmissionId}`, params);
+    }
+    /**
+     * Get form submission values for a specific form submission
+     * Note: This requires the formId to get submission values
+     */
+    async getFormSubmissionValues(formId, formSubmissionId, params) {
+        const result = await this.getList(`/forms/${formId}/form_submissions/${formSubmissionId}/form_submission_values`, params);
+        return { data: result.data };
+    }
+}
+exports.FormsModule = FormsModule;

package/dist/modules/reports.d.ts

@@ -0,0 +1,53 @@
+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 type { ReportResource, ReportAttributes, ReportsList, PersonResource } from '../types';
+/**
+ * Reports module for managing report-related operations
+ */
+export declare class ReportsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all reports
+     */
+    getAll(params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+        page?: number;
+    }): Promise<ReportsList>;
+    /**
+     * Get a specific report by ID
+     */
+    getById(id: string, include?: string[]): Promise<ReportResource>;
+    /**
+     * Create a new report
+     */
+    create(data: ReportAttributes): Promise<ReportResource>;
+    /**
+     * Update an existing report
+     */
+    update(id: string, data: Partial<ReportAttributes>): Promise<ReportResource>;
+    /**
+     * Delete a report
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get the person who created a report
+     */
+    getCreatedBy(reportId: string): Promise<PersonResource>;
+    /**
+     * Get the person who last updated a report
+     */
+    getUpdatedBy(reportId: string): Promise<PersonResource>;
+    /**
+     * Get all reports with pagination support
+     */
+    getAllPagesPaginated(params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+    }, paginationOptions?: PaginationOptions): Promise<PaginationResult<ReportResource>>;
+}

package/dist/modules/reports.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportsModule = void 0;
+const base_1 = require("./base");
+/**
+ * Reports module for managing report-related operations
+ */
+class ReportsModule extends base_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all reports
+     */
+    async getAll(params) {
+        return this.getList('/reports', params);
+    }
+    /**
+     * Get a specific report by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/reports/${id}`, params);
+    }
+    /**
+     * Create a new report
+     */
+    async create(data) {
+        return this.createResource('/reports', data);
+    }
+    /**
+     * Update an existing report
+     */
+    async update(id, data) {
+        return this.updateResource(`/reports/${id}`, data);
+    }
+    /**
+     * Delete a report
+     */
+    async delete(id) {
+        return this.deleteResource(`/reports/${id}`);
+    }
+    /**
+     * Get the person who created a report
+     */
+    async getCreatedBy(reportId) {
+        return this.getSingle(`/reports/${reportId}/created_by`);
+    }
+    /**
+     * Get the person who last updated a report
+     */
+    async getUpdatedBy(reportId) {
+        return this.getSingle(`/reports/${reportId}/updated_by`);
+    }
+    /**
+     * Get all reports with pagination support
+     */
+    async getAllPagesPaginated(params, paginationOptions) {
+        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;
+        }
+        return this.getAllPages('/reports', queryParams, paginationOptions);
+    }
+}
+exports.ReportsModule = ReportsModule;

package/dist/modules/service-time.d.ts

@@ -0,0 +1,46 @@
+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 type { ServiceTimeResource, ServiceTimeAttributes, ServiceTimesList } from '../types';
+/**
+ * ServiceTime module for managing service time-related operations
+ * ServiceTimes are campus-scoped resources
+ */
+export declare class ServiceTimeModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all service times for a specific campus
+     */
+    getAll(campusId: string, params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+        page?: number;
+    }): Promise<ServiceTimesList>;
+    /**
+     * Get a specific service time by ID for a campus
+     */
+    getById(campusId: string, id: string, include?: string[]): Promise<ServiceTimeResource>;
+    /**
+     * Create a new service time for a campus
+     */
+    create(campusId: string, data: ServiceTimeAttributes): Promise<ServiceTimeResource>;
+    /**
+     * Update an existing service time for a campus
+     */
+    update(campusId: string, id: string, data: Partial<ServiceTimeAttributes>): Promise<ServiceTimeResource>;
+    /**
+     * Delete a service time for a campus
+     */
+    delete(campusId: string, id: string): Promise<void>;
+    /**
+     * Get all service times for a campus with pagination support
+     */
+    getAllPagesPaginated(campusId: string, params?: {
+        where?: Record<string, any>;
+        include?: string[];
+        per_page?: number;
+    }, paginationOptions?: PaginationOptions): Promise<PaginationResult<ServiceTimeResource>>;
+}

package/dist/modules/service-time.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceTimeModule = void 0;
+const base_1 = require("./base");
+/**
+ * ServiceTime module for managing service time-related operations
+ * ServiceTimes are campus-scoped resources
+ */
+class ServiceTimeModule extends base_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all service times for a specific campus
+     */
+    async getAll(campusId, params) {
+        return this.getList(`/campuses/${campusId}/service_times`, params);
+    }
+    /**
+     * Get a specific service time by ID for a campus
+     */
+    async getById(campusId, id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/campuses/${campusId}/service_times/${id}`, params);
+    }
+    /**
+     * Create a new service time for a campus
+     */
+    async create(campusId, data) {
+        return this.createResource(`/campuses/${campusId}/service_times`, data);
+    }
+    /**
+     * Update an existing service time for a campus
+     */
+    async update(campusId, id, data) {
+        return this.updateResource(`/campuses/${campusId}/service_times/${id}`, data);
+    }
+    /**
+     * Delete a service time for a campus
+     */
+    async delete(campusId, id) {
+        return this.deleteResource(`/campuses/${campusId}/service_times/${id}`);
+    }
+    /**
+     * Get all service times for a campus with pagination support
+     */
+    async getAllPagesPaginated(campusId, params, paginationOptions) {
+        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;
+        }
+        return this.getAllPages(`/campuses/${campusId}/service_times`, queryParams, paginationOptions);
+    }
+}
+exports.ServiceTimeModule = ServiceTimeModule;

package/dist/types/people.d.ts

@@ -400,4 +400,116 @@ export interface CampusResource extends ResourceObject<'Campus', CampusAttribute
 }
 export type CampusesList = Paginated<CampusResource>;
 export type CampusSingle = Response<CampusResource>;
-export type PeopleIncluded = EmailResource | AddressResource | PhoneNumberResource | HouseholdResource | SocialProfileResource | FieldDatumResource | TabResource | CampusResource;
+export interface ServiceTimeAttributes extends Attributes {
+    start_time?: number;
+    day?: number | string;
+    description?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface ServiceTimeRelationships {
+    organization?: Relationship;
+    campus?: Relationship;
+}
+export interface ServiceTimeResource extends ResourceObject<'ServiceTime', ServiceTimeAttributes, ServiceTimeRelationships> {
+}
+export type ServiceTimesList = Paginated<ServiceTimeResource>;
+export type ServiceTimeSingle = Response<ServiceTimeResource>;
+export interface FormAttributes extends Attributes {
+    name?: string;
+    description?: string;
+    active?: boolean;
+    archived_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface FormRelationships {
+    organization?: Relationship;
+    form_category?: Relationship;
+}
+export interface FormResource extends ResourceObject<'Form', FormAttributes, FormRelationships> {
+}
+export type FormsList = Paginated<FormResource>;
+export type FormSingle = Response<FormResource>;
+export interface FormCategoryAttributes extends Attributes {
+    name?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface FormCategoryRelationships {
+    organization?: Relationship;
+}
+export interface FormCategoryResource extends ResourceObject<'FormCategory', FormCategoryAttributes, FormCategoryRelationships> {
+}
+export type FormCategoriesList = Paginated<FormCategoryResource>;
+export type FormCategorySingle = Response<FormCategoryResource>;
+export interface FormFieldAttributes extends Attributes {
+    name?: string;
+    field_type?: string;
+    required?: boolean;
+    sequence?: number;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface FormFieldRelationships {
+    form?: Relationship;
+}
+export interface FormFieldResource extends ResourceObject<'FormField', FormFieldAttributes, FormFieldRelationships> {
+}
+export type FormFieldsList = Paginated<FormFieldResource>;
+export type FormFieldSingle = Response<FormFieldResource>;
+export interface FormFieldOptionAttributes extends Attributes {
+    value?: string;
+    sequence?: number;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface FormFieldOptionRelationships {
+    form_field?: Relationship;
+}
+export interface FormFieldOptionResource extends ResourceObject<'FormFieldOption', FormFieldOptionAttributes, FormFieldOptionRelationships> {
+}
+export type FormFieldOptionsList = Paginated<FormFieldOptionResource>;
+export type FormFieldOptionSingle = Response<FormFieldOptionResource>;
+export interface FormSubmissionAttributes extends Attributes {
+    submitted_at?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface FormSubmissionRelationships {
+    form?: Relationship;
+    person?: Relationship;
+}
+export interface FormSubmissionResource extends ResourceObject<'FormSubmission', FormSubmissionAttributes, FormSubmissionRelationships> {
+}
+export type FormSubmissionsList = Paginated<FormSubmissionResource>;
+export type FormSubmissionSingle = Response<FormSubmissionResource>;
+export interface FormSubmissionValueAttributes extends Attributes {
+    value?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface FormSubmissionValueRelationships {
+    form_submission?: Relationship;
+    form_field?: Relationship;
+}
+export interface FormSubmissionValueResource extends ResourceObject<'FormSubmissionValue', FormSubmissionValueAttributes, FormSubmissionValueRelationships> {
+}
+export type FormSubmissionValuesList = Paginated<FormSubmissionValueResource>;
+export type FormSubmissionValueSingle = Response<FormSubmissionValueResource>;
+export interface ReportAttributes extends Attributes {
+    name?: string;
+    body?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface ReportRelationships {
+    organization?: Relationship;
+    created_by?: Relationship;
+    updated_by?: Relationship;
+}
+export interface ReportResource extends ResourceObject<'Report', ReportAttributes, ReportRelationships> {
+}
+export type ReportsList = Paginated<ReportResource>;
+export type ReportSingle = Response<ReportResource>;
+export type PeopleIncluded = EmailResource | AddressResource | PhoneNumberResource | HouseholdResource | SocialProfileResource | FieldDatumResource | TabResource | CampusResource | ServiceTimeResource | FormResource | FormCategoryResource | FormFieldResource | FormFieldOptionResource | FormSubmissionResource | FormSubmissionValueResource | ReportResource;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rachelallyson/planning-center-people-ts",
-    "version": "2.2.0",
+    "version": "2.3.1",
     "description": "A strictly typed TypeScript client for Planning Center Online People API with smart matching, batch operations, and enhanced developer experience",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",