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

package/dist/modules/fields.d.ts

@@ -2,16 +2,9 @@
  * v2.0.0 Fields 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 { FieldDefinitionResource, FieldDefinitionAttributes, FieldDatumResource, FieldOptionResource, FieldOptionAttributes, TabResource, TabAttributes } from '../types';
-export interface FieldDefinitionCache {
-    byId: Map<string, FieldDefinitionResource>;
-    bySlug: Map<string, FieldDefinitionResource>;
-    byName: Map<string, FieldDefinitionResource>;
-    lastUpdated: number;
-}
+import type { FieldDefinitionResource, FieldDefinitionAttributes, FieldDatumAttributes, FlattenedFieldDatumResource, FieldOptionAttributes, TabAttributes, Meta, TopLevelLinks } from '../types';
+import type { FieldDataOptions, FieldDefinitionListOptions } from '../types/api-options';
+import type { FlattenedResource } from '@rachelallyson/planning-center-base-ts';
 export interface FieldSetOptions {
     /** Field definition ID */
     fieldId?: string;
@@ -25,33 +18,40 @@ export interface FieldSetOptions {
     handleFileUploads?: boolean;
 }
 export declare class FieldsModule extends BaseModule {
-    private fieldDefinitionCache;
-    private cacheTtl;
-    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
     /**
-     * Get all field definitions with caching
+     * Get all field definitions
+     * @param include - Optional array of relationships to include (defaults to ['tab'])
+     *   Valid values: 'tab', 'field_options'
+     * @param options - Optional additional options
+     *   - includeDeleted: If true, includes deleted field definitions (default: false)
+     *   - where: Optional object for filtering field definitions
+     *     Valid keys: config, data_type, deleted_at, name, sequence, slug, tab_id
+     *     Example: { tab_id: '123', data_type: 'string' }
+     *   - order: Optional field name to order by (prefix with '-' to reverse order)
+     *     Valid values: config, data_type, deleted_at, name, sequence, slug, tab_id
+     *     Example: 'sequence' or '-name' for descending
      */
-    getAllFieldDefinitions(useCache?: boolean): Promise<FieldDefinitionResource[]>;
+    getAllFieldDefinitions(options?: FieldDefinitionListOptions): Promise<import("@rachelallyson/planning-center-base-ts").PaginationResult<FieldDefinitionResource, import("@rachelallyson/planning-center-base-ts").ResourceObject<string, any, any>, Record<string, never>>>;
     /**
      * Get a single field definition by ID
      */
-    getFieldDefinition(id: string): Promise<FieldDefinitionResource>;
+    getFieldDefinition(id: string): Promise<FlattenedResource<"FieldDefinition", FieldDefinitionAttributes, import("../types").FieldDefinitionRelationships>>;
     /**
      * Get field definition by slug
      */
-    getFieldDefinitionBySlug(slug: string): Promise<FieldDefinitionResource | null>;
+    getFieldDefinitionBySlug(slug: string): Promise<FlattenedResource<"FieldDefinition", FieldDefinitionAttributes, import("../types").FieldDefinitionRelationships, Record<string, never>> | null>;
     /**
      * Get field definition by name
      */
-    getFieldDefinitionByName(name: string): Promise<FieldDefinitionResource | null>;
+    getFieldDefinitionByName(name: string): Promise<FlattenedResource<"FieldDefinition", FieldDefinitionAttributes, import("../types").FieldDefinitionRelationships, Record<string, never>> | null>;
     /**
      * Create a field definition
      */
-    createFieldDefinition(tabId: string, data: FieldDefinitionAttributes): Promise<FieldDefinitionResource>;
+    createFieldDefinition(tabId: string, data: Partial<FieldDefinitionAttributes>): Promise<FlattenedResource<"FieldDefinition", FieldDefinitionAttributes, import("../types").FieldDefinitionRelationships>>;
     /**
      * Update a field definition
      */
-    updateFieldDefinition(id: string, data: Partial<FieldDefinitionAttributes>): Promise<FieldDefinitionResource>;
+    updateFieldDefinition(id: string, data: Partial<FieldDefinitionAttributes>): Promise<FlattenedResource<"FieldDefinition", FieldDefinitionAttributes, import("../types").FieldDefinitionRelationships>>;
     /**
      * Delete a field definition
      */
@@ -60,44 +60,44 @@ export declare class FieldsModule extends BaseModule {
      * Get field options for a field definition
      */
     getFieldOptions(fieldDefinitionId: string): Promise<{
-        data: FieldOptionResource[];
-        meta?: any;
-        links?: any;
+        data: FlattenedResource<"FieldOption", FieldOptionAttributes, import("../types").FieldOptionRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
     }>;
     /**
      * Create a field option
      */
-    createFieldOption(fieldDefinitionId: string, data: FieldOptionAttributes): Promise<FieldOptionResource>;
+    createFieldOption(fieldDefinitionId: string, data: FieldOptionAttributes): Promise<FlattenedResource<"FieldOption", FieldOptionAttributes, import("../types").FieldOptionRelationships>>;
     /**
      * Get person's field data
      */
-    getPersonFieldData(personId: string): Promise<{
-        data: FieldDatumResource[];
-        meta?: any;
-        links?: any;
+    getPersonFieldData(personId: string, options?: FieldDataOptions): Promise<{
+        data: FlattenedFieldDatumResource[];
+        meta?: Meta;
+        links?: TopLevelLinks;
     }>;
     /**
      * Set a person's field value with automatic field lookup
      */
-    setPersonField(personId: string, options: FieldSetOptions): Promise<FieldDatumResource>;
+    setPersonField(personId: string, options: FieldSetOptions): Promise<FlattenedResource<"FieldDatum", FieldDatumAttributes, import("../types").FieldDatumRelationships>>;
     /**
      * Set a person's field value by field definition ID
      */
-    setPersonFieldById(personId: string, fieldId: string, value: string): Promise<FieldDatumResource>;
+    setPersonFieldById(personId: string, fieldId: string, value: string): Promise<FlattenedResource<"FieldDatum", FieldDatumAttributes, import("../types").FieldDatumRelationships>>;
     /**
      * Set a person's field value by field slug
      */
-    setPersonFieldBySlug(personId: string, fieldSlug: string, value: string): Promise<FieldDatumResource>;
+    setPersonFieldBySlug(personId: string, fieldSlug: string, value: string): Promise<FlattenedResource<"FieldDatum", FieldDatumAttributes, import("../types").FieldDatumRelationships>>;
     /**
      * Set a person's field value by field name
      */
-    setPersonFieldByName(personId: string, fieldName: string, value: string): Promise<FieldDatumResource>;
+    setPersonFieldByName(personId: string, fieldName: string, value: string): Promise<FlattenedResource<"FieldDatum", FieldDatumAttributes, import("../types").FieldDatumRelationships>>;
     /**
      * Create field data for a person
      */
     createPersonFieldData(personId: string, fieldDefinitionId: string, value: string, options?: {
         handleFileUploads?: boolean;
-    }): Promise<FieldDatumResource>;
+    }): Promise<FlattenedResource<"FieldDatum", FieldDatumAttributes, import("../types").FieldDatumRelationships>>;
     /**
      * Delete person's field data
      */
@@ -106,22 +106,22 @@ export declare class FieldsModule extends BaseModule {
      * Get all tabs
      */
     getTabs(): Promise<{
-        data: TabResource[];
-        meta?: any;
-        links?: any;
+        data: FlattenedResource<"Tab", TabAttributes, import("../types").TabRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
     }>;
     /**
      * Get a single tab by ID
      */
-    getTabById(id: string, include?: string[]): Promise<TabResource>;
+    getTabById(id: string, include?: string[]): Promise<FlattenedResource<"Tab", TabAttributes, import("../types").TabRelationships>>;
     /**
      * Create a tab
      */
-    createTab(data: TabAttributes): Promise<TabResource>;
+    createTab(data: TabAttributes): Promise<FlattenedResource<"Tab", TabAttributes, import("../types").TabRelationships>>;
     /**
      * Update a tab
      */
-    updateTab(id: string, data: Partial<TabAttributes>): Promise<TabResource>;
+    updateTab(id: string, data: Partial<TabAttributes>): Promise<FlattenedResource<"Tab", TabAttributes, import("../types").TabRelationships>>;
     /**
      * Delete a tab
      */
@@ -134,22 +134,6 @@ export declare class FieldsModule extends BaseModule {
      * Create field data for file uploads
      */
     private createPersonFileFieldData;
-    /**
-     * Check if cache is valid
-     */
-    private isCacheValid;
-    /**
-     * Ensure cache is loaded
-     */
-    private ensureCacheLoaded;
-    /**
-     * Update field definition cache
-     */
-    private updateFieldDefinitionCache;
-    /**
-     * Invalidate cache
-     */
-    private invalidateCache;
     /**
      * Check if a value is a file URL
      */

package/dist/modules/fields.js

@@ -6,104 +6,93 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldsModule = void 0;
 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;
-        this.cacheTtl = 300000; // 5 minutes
-    }
     /**
-     * Get all field definitions with caching
+     * Get all field definitions
+     * @param include - Optional array of relationships to include (defaults to ['tab'])
+     *   Valid values: 'tab', 'field_options'
+     * @param options - Optional additional options
+     *   - includeDeleted: If true, includes deleted field definitions (default: false)
+     *   - where: Optional object for filtering field definitions
+     *     Valid keys: config, data_type, deleted_at, name, sequence, slug, tab_id
+     *     Example: { tab_id: '123', data_type: 'string' }
+     *   - order: Optional field name to order by (prefix with '-' to reverse order)
+     *     Valid values: config, data_type, deleted_at, name, sequence, slug, tab_id
+     *     Example: 'sequence' or '-name' for descending
      */
-    async getAllFieldDefinitions(useCache = true) {
-        if (useCache && this.isCacheValid()) {
-            return Array.from(this.fieldDefinitionCache.byId.values());
-        }
-        const result = await this.getAllPages('/field_definitions', {
-            include: ['tab'],
-        });
-        // Update cache
-        this.updateFieldDefinitionCache(result.data);
-        return result.data;
+    async getAllFieldDefinitions(options) {
+        this.debugLog('fields.getAllFieldDefinitions', { options });
+        return this.getAllPages('/field_definitions', options);
     }
     /**
      * Get a single field definition by ID
      */
     async getFieldDefinition(id) {
+        this.debugLog('fields.getFieldDefinition', { id });
         return this.getSingle(`/field_definitions/${id}`);
     }
     /**
      * Get field definition by slug
      */
     async getFieldDefinitionBySlug(slug) {
-        await this.ensureCacheLoaded();
-        return this.fieldDefinitionCache?.bySlug.get(slug) || null;
+        this.debugLog('fields.getFieldDefinitionBySlug', { slug });
+        const allFieldDefinitions = await this.getAllFieldDefinitions();
+        return allFieldDefinitions.data.find((fd) => fd.slug === slug) || null;
     }
     /**
      * Get field definition by name
      */
     async getFieldDefinitionByName(name) {
-        await this.ensureCacheLoaded();
-        return this.fieldDefinitionCache?.byName.get(name) || null;
+        this.debugLog('fields.getFieldDefinitionByName', { name });
+        const allFieldDefinitions = await this.getAllFieldDefinitions();
+        return allFieldDefinitions.data.find((fd) => fd.name === name) || null;
     }
     /**
      * Create a field definition
      */
     async createFieldDefinition(tabId, data) {
-        const fieldDef = await this.createResource(`/tabs/${tabId}/field_definitions`, data);
-        // Invalidate cache
-        this.invalidateCache();
-        return fieldDef;
+        this.debugLog('fields.createFieldDefinition', { tabId, data });
+        return this.createResource(`/tabs/${tabId}/field_definitions`, data);
     }
     /**
      * Update a field definition
      */
     async updateFieldDefinition(id, data) {
-        const fieldDef = await this.updateResource(`/field_definitions/${id}`, data);
-        // Update cache
-        if (this.fieldDefinitionCache && fieldDef.attributes) {
-            this.fieldDefinitionCache.byId.set(id, fieldDef);
-            this.fieldDefinitionCache.bySlug.set(fieldDef.attributes.slug, fieldDef);
-            this.fieldDefinitionCache.byName.set(fieldDef.attributes.name, fieldDef);
-        }
-        return fieldDef;
+        this.debugLog('fields.updateFieldDefinition', { id, data });
+        return this.updateResource(`/field_definitions/${id}`, data);
     }
     /**
      * Delete a field definition
      */
     async deleteFieldDefinition(id) {
-        await this.deleteResource(`/field_definitions/${id}`);
-        // Remove from cache
-        if (this.fieldDefinitionCache) {
-            const fieldDef = this.fieldDefinitionCache.byId.get(id);
-            if (fieldDef && fieldDef.attributes) {
-                this.fieldDefinitionCache.byId.delete(id);
-                this.fieldDefinitionCache.bySlug.delete(fieldDef.attributes.slug);
-                this.fieldDefinitionCache.byName.delete(fieldDef.attributes.name);
-            }
-        }
+        this.debugLog('fields.deleteFieldDefinition', { id });
+        return this.deleteResource(`/field_definitions/${id}`);
     }
     /**
      * Get field options for a field definition
      */
     async getFieldOptions(fieldDefinitionId) {
+        this.debugLog('fields.getFieldOptions', { fieldDefinitionId });
         return this.getList(`/field_definitions/${fieldDefinitionId}/field_options`);
     }
     /**
      * Create a field option
      */
     async createFieldOption(fieldDefinitionId, data) {
+        this.debugLog('fields.createFieldOption', { fieldDefinitionId, data });
         return this.createResource(`/field_definitions/${fieldDefinitionId}/field_options`, data);
     }
     /**
      * Get person's field data
      */
-    async getPersonFieldData(personId) {
-        return this.getList(`/people/${personId}/field_data`);
+    async getPersonFieldData(personId, options) {
+        this.debugLog('fields.getPersonFieldData', { personId, options });
+        return this.getList(`/people/${personId}/field_data`, options);
     }
     /**
      * Set a person's field value with automatic field lookup
      */
     async setPersonField(personId, options) {
+        this.debugLog('fields.setPersonField', { personId, options });
         const fieldDef = await this.resolveFieldDefinition(options);
         if (!fieldDef) {
             throw new Error(`Field definition not found for: ${options.fieldId || options.fieldSlug || options.fieldName}`);
@@ -116,12 +105,14 @@ class FieldsModule extends planning_center_base_ts_1.BaseModule {
      * Set a person's field value by field definition ID
      */
     async setPersonFieldById(personId, fieldId, value) {
+        this.debugLog('fields.setPersonFieldById', { personId, fieldId });
         return this.createPersonFieldData(personId, fieldId, value);
     }
     /**
      * Set a person's field value by field slug
      */
     async setPersonFieldBySlug(personId, fieldSlug, value) {
+        this.debugLog('fields.setPersonFieldBySlug', { personId, fieldSlug, value });
         const fieldDef = await this.getFieldDefinitionBySlug(fieldSlug);
         if (!fieldDef) {
             throw new Error(`Field definition not found for slug: ${fieldSlug}`);
@@ -132,6 +123,7 @@ class FieldsModule extends planning_center_base_ts_1.BaseModule {
      * Set a person's field value by field name
      */
     async setPersonFieldByName(personId, fieldName, value) {
+        this.debugLog('fields.setPersonFieldByName', { personId, fieldName, value });
         const fieldDef = await this.getFieldDefinitionByName(fieldName);
         if (!fieldDef) {
             throw new Error(`Field definition not found for name: ${fieldName}`);
@@ -142,31 +134,38 @@ class FieldsModule extends planning_center_base_ts_1.BaseModule {
      * Create field data for a person
      */
     async createPersonFieldData(personId, fieldDefinitionId, value, options = {}) {
+        this.debugLog('fields.createPersonFieldData', { personId, fieldDefinitionId, options });
         const { handleFileUploads = true } = options;
         // Get field definition to determine type
         const fieldDef = await this.getFieldDefinition(fieldDefinitionId);
         // Check if this is a file field and handle accordingly
-        if (fieldDef.attributes && fieldDef.attributes.data_type === 'file' && handleFileUploads) {
+        if (fieldDef && (fieldDef).data_type === 'file' && handleFileUploads) {
             return this.createPersonFileFieldData(personId, fieldDefinitionId, value);
         }
         // For text fields, clean the value if it's a file URL
         const cleanValue = this.isFileUrl(value) ? this.extractFileUrl(value) : value;
         // Check if field data already exists for this person and field
-        try {
-            const existingFieldData = await this.getPersonFieldData(personId);
-            const existingDatum = existingFieldData.data.find(datum => {
-                const fieldDefData = datum.relationships?.field_definition?.data;
-                return Array.isArray(fieldDefData)
-                    ? fieldDefData.some(fd => fd.id === fieldDefinitionId)
-                    : fieldDefData?.id === fieldDefinitionId;
-            });
-            if (existingDatum) {
-                // Update existing field data
-                return this.updateResource(`/people/${personId}/field_data/${existingDatum.id}`, { value: cleanValue });
+        // Per test construction standards, we should fail explicitly if something is wrong
+        const existingFieldData = await this.getPersonFieldData(personId, { include: ['field_definition'] });
+        const existingDatum = existingFieldData.data.find(datum => {
+            // Check the relationship field_definition first
+            // When include: ['field_definition'] is used, this should be a full resource object
+            // When not included, it might be a ResourceIdentifier with just {type, id}
+            const fieldDefData = datum.field_definition;
+            if (fieldDefData && typeof fieldDefData === 'object' && 'id' in fieldDefData) {
+                // Compare as strings to handle number/string ID mismatches
+                return String(fieldDefData.id) === String(fieldDefinitionId);
             }
-        }
-        catch (error) {
-            // If we can't get existing field data, continue with creation
+            // Fallback: check if field_definition_id is available as an attribute
+            // (some API responses might include this even though it's not in the type definition)
+            if ('field_definition_id' in datum && datum.field_definition_id !== undefined) {
+                return String(datum.field_definition_id) === String(fieldDefinitionId);
+            }
+            return false;
+        });
+        if (existingDatum) {
+            // Update existing field data
+            return this.updateResource(`/people/${personId}/field_data/${existingDatum.id}`, { value: cleanValue });
         }
         return this.createResource(`/people/${personId}/field_data`, {
             field_definition_id: fieldDefinitionId,
@@ -177,40 +176,42 @@ class FieldsModule extends planning_center_base_ts_1.BaseModule {
      * Delete person's field data
      */
     async deletePersonFieldData(personId, fieldDataId) {
+        this.debugLog('fields.deletePersonFieldData', { personId, fieldDataId });
         return this.deleteResource(`/people/${personId}/field_data/${fieldDataId}`);
     }
     /**
      * Get all tabs
      */
     async getTabs() {
+        this.debugLog('fields.getTabs');
         return this.getList('/tabs');
     }
     /**
      * Get a single tab by ID
      */
     async getTabById(id, include) {
-        const params = {};
-        if (include) {
-            params.include = include.join(',');
-        }
-        return this.getSingle(`/tabs/${id}`, params);
+        this.debugLog('fields.getTabById', { id, include });
+        return this.getSingle(`/tabs/${id}`, include);
     }
     /**
      * Create a tab
      */
     async createTab(data) {
+        this.debugLog('fields.createTab', { data });
         return this.createResource('/tabs', data);
     }
     /**
      * Update a tab
      */
     async updateTab(id, data) {
+        this.debugLog('fields.updateTab', { id, data });
         return this.updateResource(`/tabs/${id}`, data);
     }
     /**
      * Delete a tab
      */
     async deleteTab(id) {
+        this.debugLog('fields.deleteTab', { id });
         return this.deleteResource(`/tabs/${id}`);
     }
     /**
@@ -289,47 +290,6 @@ class FieldsModule extends planning_center_base_ts_1.BaseModule {
             throw error;
         }
     }
-    /**
-     * Check if cache is valid
-     */
-    isCacheValid() {
-        if (!this.fieldDefinitionCache) {
-            return false;
-        }
-        return Date.now() - this.fieldDefinitionCache.lastUpdated < this.cacheTtl;
-    }
-    /**
-     * Ensure cache is loaded
-     */
-    async ensureCacheLoaded() {
-        if (!this.isCacheValid()) {
-            await this.getAllFieldDefinitions(false);
-        }
-    }
-    /**
-     * Update field definition cache
-     */
-    updateFieldDefinitionCache(fieldDefinitions) {
-        this.fieldDefinitionCache = {
-            byId: new Map(),
-            bySlug: new Map(),
-            byName: new Map(),
-            lastUpdated: Date.now(),
-        };
-        for (const fieldDef of fieldDefinitions) {
-            if (fieldDef.attributes) {
-                this.fieldDefinitionCache.byId.set(fieldDef.id, fieldDef);
-                this.fieldDefinitionCache.bySlug.set(fieldDef.attributes.slug, fieldDef);
-                this.fieldDefinitionCache.byName.set(fieldDef.attributes.name, fieldDef);
-            }
-        }
-    }
-    /**
-     * Invalidate cache
-     */
-    invalidateCache() {
-        this.fieldDefinitionCache = null;
-    }
     /**
      * Check if a value is a file URL
      */

package/dist/modules/forms.d.ts

@@ -2,82 +2,93 @@
  * 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';
+import type { FormResource, FormAttributes } from '../types';
+import type { FormListOptions, FormPageOptions } from '../types/api-options';
 /**
  * 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
+     * Get all forms across all pages
      */
-    getAll(params?: {
-        where?: Record<string, any>;
-        include?: string[];
-        per_page?: number;
-        page?: number;
-    }): Promise<FormsList>;
+    getAll(params?: FormListOptions): Promise<import("@rachelallyson/planning-center-base-ts").PaginationResult<FormResource, import("@rachelallyson/planning-center-base-ts").ResourceObject<string, any, any>, Record<string, never>>>;
+    /**
+     * Get a single page of forms with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param params - List parameters including where, include, perPage, page, and order
+     * @returns A single page of results with meta and links for pagination
+     */
+    getPage(params?: FormPageOptions): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Form", FormAttributes, import("../types").FormRelationships, Record<string, never>>[];
+        meta?: import("@rachelallyson/planning-center-base-ts").Meta;
+        links?: import("@rachelallyson/planning-center-base-ts").TopLevelLinks;
+    }>;
     /**
      * Get a specific form by ID
      */
-    getById(id: string, include?: string[]): Promise<FormResource>;
+    getById(id: string, include?: string[]): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Form", FormAttributes, import("../types").FormRelationships>>;
     /**
      * Get form category for a specific form
      */
-    getFormCategory(formId: string): Promise<FormCategoryResource>;
+    getFormCategory(formId: string): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"FormCategory", import("../types").FormCategoryAttributes, import("../types").FormCategoryRelationships>>;
     /**
      * Get form fields for a specific form
      */
     getFormFields(formId: string, params?: {
-        where?: Record<string, any>;
+        where?: Record<string, string | number | boolean | undefined>;
         include?: string[];
-        per_page?: number;
+        perPage?: number;
         page?: number;
     }): Promise<{
-        data: FormFieldResource[];
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"FormField", import("../types").FormFieldAttributes, import("../types").FormFieldRelationships, Record<string, never>>[];
+        meta?: import("@rachelallyson/planning-center-base-ts").Meta;
+        links?: import("@rachelallyson/planning-center-base-ts").TopLevelLinks;
     }>;
     /**
      * 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>;
+        where?: Record<string, string | number | boolean | undefined>;
         include?: string[];
         per_page?: number;
         page?: number;
     }): Promise<{
-        data: FormFieldOptionResource[];
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"FormFieldOption", import("../types").FormFieldOptionAttributes, import("../types").FormFieldOptionRelationships, Record<string, never>>[];
+        meta?: import("@rachelallyson/planning-center-base-ts").Meta;
+        links?: import("@rachelallyson/planning-center-base-ts").TopLevelLinks;
     }>;
     /**
      * Get form submissions for a specific form
      */
     getFormSubmissions(formId: string, params?: {
-        where?: Record<string, any>;
+        where?: Record<string, string | number | boolean | undefined>;
         include?: string[];
         per_page?: number;
         page?: number;
     }): Promise<{
-        data: FormSubmissionResource[];
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"FormSubmission", import("../types").FormSubmissionAttributes, import("../types").FormSubmissionRelationships, Record<string, never>>[];
+        meta?: import("@rachelallyson/planning-center-base-ts").Meta;
+        links?: import("@rachelallyson/planning-center-base-ts").TopLevelLinks;
     }>;
     /**
      * 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>;
+    getFormSubmissionById(formId: string, formSubmissionId: string, include?: string[]): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"FormSubmission", import("../types").FormSubmissionAttributes, import("../types").FormSubmissionRelationships>>;
     /**
      * 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>;
+        where?: Record<string, string | number | boolean | undefined>;
         include?: string[];
         per_page?: number;
         page?: number;
     }): Promise<{
-        data: FormSubmissionValueResource[];
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"FormSubmissionValue", import("../types").FormSubmissionValueAttributes, import("../types").FormSubmissionValueRelationships, Record<string, never>>[];
+        meta?: import("@rachelallyson/planning-center-base-ts").Meta;
+        links?: import("@rachelallyson/planning-center-base-ts").TopLevelLinks;
     }>;
 }