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

package/CHANGELOG.md

@@ -5,6 +5,132 @@ 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.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/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/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.0",
     "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",