@rachelallyson/planning-center-people-ts 1.0.0 → 2.0.0

package/dist/modules/notes.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * v2.0.0 Notes Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotesModule = void 0;
+const base_1 = require("./base");
+class NotesModule extends base_1.BaseModule {
+    /**
+     * Get all notes
+     */
+    async getAll(options = {}) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        if (options.perPage) {
+            params.per_page = options.perPage;
+        }
+        if (options.page) {
+            params.page = options.page;
+        }
+        return this.getList('/notes', params);
+    }
+    /**
+     * Get all notes across all pages
+     */
+    async getAllPagesPaginated(options = {}, paginationOptions) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        return this.getAllPages('/notes', params, paginationOptions);
+    }
+    /**
+     * Get a single note by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/notes/${id}`, params);
+    }
+    /**
+     * Get notes for a specific person
+     */
+    async getNotesForPerson(personId, options = {}) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        if (options.perPage) {
+            params.per_page = options.perPage;
+        }
+        if (options.page) {
+            params.page = options.page;
+        }
+        return this.getList(`/people/${personId}/notes`, params);
+    }
+    /**
+     * Create a note for a person
+     */
+    async create(personId, data) {
+        return this.createResource(`/people/${personId}/notes`, data);
+    }
+    /**
+     * Update a note
+     */
+    async update(id, data) {
+        return this.updateResource(`/notes/${id}`, data);
+    }
+    /**
+     * Delete a note
+     */
+    async delete(id) {
+        return this.deleteResource(`/notes/${id}`);
+    }
+    /**
+     * Get all note categories
+     */
+    async getNoteCategories() {
+        return this.getList('/note_categories');
+    }
+    /**
+     * Get a single note category by ID
+     */
+    async getNoteCategoryById(id) {
+        return this.getSingle(`/note_categories/${id}`);
+    }
+    /**
+     * Create a note category
+     */
+    async createNoteCategory(data) {
+        return this.createResource('/note_categories', data);
+    }
+    /**
+     * Update a note category
+     */
+    async updateNoteCategory(id, data) {
+        return this.updateResource(`/note_categories/${id}`, data);
+    }
+    /**
+     * Delete a note category
+     */
+    async deleteNoteCategory(id) {
+        return this.deleteResource(`/note_categories/${id}`);
+    }
+}
+exports.NotesModule = NotesModule;

package/dist/modules/people.d.ts

@@ -0,0 +1,196 @@
+/**
+ * v2.0.0 People Module
+ */
+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 { PersonResource, EmailResource, EmailAttributes, PhoneNumberResource, PhoneNumberAttributes, AddressResource, AddressAttributes, SocialProfileResource, SocialProfileAttributes } from '../types';
+export interface PeopleListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export interface PersonCreateOptions {
+    firstName?: string;
+    lastName?: string;
+    givenName?: string;
+    middleName?: string;
+    nickname?: string;
+    birthdate?: string;
+    anniversary?: string;
+    gender?: string;
+    grade?: string;
+    child?: boolean;
+    status?: string;
+    medicalNotes?: string;
+    jobTitle?: string;
+    employer?: string;
+    school?: string;
+    graduationYear?: string;
+    avatar?: string;
+    siteAdministrator?: boolean;
+    accountingAdministrator?: boolean;
+    peoplePermissions?: string;
+    directoryStatus?: string;
+    loginIdentifier?: string;
+    membership?: string;
+    remoteId?: string;
+    demographicAvatarUrl?: string;
+    inactivatedAt?: string;
+    resourcePermissionFlags?: Record<string, boolean>;
+}
+export interface PersonMatchOptions {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    matchStrategy?: 'exact' | 'fuzzy' | 'aggressive';
+    campus?: string;
+    createIfNotFound?: boolean;
+}
+export declare class PeopleModule extends BaseModule {
+    private personMatcher;
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all people with optional filtering
+     */
+    getAll(options?: PeopleListOptions): Promise<{
+        data: PersonResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all people across all pages
+     */
+    getAllPagesPaginated(options?: PeopleListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<PersonResource>>;
+    /**
+     * Get a single person by ID
+     */
+    getById(id: string, include?: string[]): Promise<PersonResource>;
+    /**
+     * Create a new person
+     */
+    create(data: PersonCreateOptions): Promise<PersonResource>;
+    /**
+     * Update a person
+     */
+    update(id: string, data: Partial<PersonCreateOptions>): Promise<PersonResource>;
+    /**
+     * Delete a person
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Find or create a person with smart matching
+     */
+    findOrCreate(options: PersonMatchOptions): Promise<PersonResource>;
+    /**
+     * Search people by multiple criteria
+     */
+    search(criteria: {
+        name?: string;
+        email?: string;
+        phone?: string;
+        status?: string;
+        perPage?: number;
+    }): Promise<{
+        data: PersonResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get person's emails
+     */
+    getEmails(personId: string): Promise<{
+        data: EmailResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Add an email to a person
+     */
+    addEmail(personId: string, data: EmailAttributes): Promise<EmailResource>;
+    /**
+     * Update a person's email
+     */
+    updateEmail(personId: string, emailId: string, data: Partial<EmailAttributes>): Promise<EmailResource>;
+    /**
+     * Delete a person's email
+     */
+    deleteEmail(personId: string, emailId: string): Promise<void>;
+    /**
+     * Get person's phone numbers
+     */
+    getPhoneNumbers(personId: string): Promise<{
+        data: PhoneNumberResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Add a phone number to a person
+     */
+    addPhoneNumber(personId: string, data: PhoneNumberAttributes): Promise<PhoneNumberResource>;
+    /**
+     * Update a person's phone number
+     */
+    updatePhoneNumber(personId: string, phoneId: string, data: Partial<PhoneNumberAttributes>): Promise<PhoneNumberResource>;
+    /**
+     * Delete a person's phone number
+     */
+    deletePhoneNumber(personId: string, phoneId: string): Promise<void>;
+    /**
+     * Get person's addresses
+     */
+    getAddresses(personId: string): Promise<{
+        data: AddressResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Add an address to a person
+     */
+    addAddress(personId: string, data: AddressAttributes): Promise<AddressResource>;
+    /**
+     * Update a person's address
+     */
+    updateAddress(personId: string, addressId: string, data: Partial<AddressAttributes>): Promise<AddressResource>;
+    /**
+     * Delete a person's address
+     */
+    deleteAddress(personId: string, addressId: string): Promise<void>;
+    /**
+     * Get person's social profiles
+     */
+    getSocialProfiles(personId: string): Promise<{
+        data: SocialProfileResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Add a social profile to a person
+     */
+    addSocialProfile(personId: string, data: SocialProfileAttributes): Promise<SocialProfileResource>;
+    /**
+     * Update a person's social profile
+     */
+    updateSocialProfile(personId: string, profileId: string, data: Partial<SocialProfileAttributes>): Promise<SocialProfileResource>;
+    /**
+     * Delete a person's social profile
+     */
+    deleteSocialProfile(personId: string, profileId: string): Promise<void>;
+    /**
+     * Create a person with contact information
+     */
+    createWithContacts(personData: PersonCreateOptions, contacts?: {
+        email?: EmailAttributes;
+        phone?: PhoneNumberAttributes;
+        address?: AddressAttributes;
+    }): Promise<{
+        person: PersonResource;
+        email?: EmailResource;
+        phone?: PhoneNumberResource;
+        address?: AddressResource;
+    }>;
+}

package/dist/modules/people.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * v2.0.0 People Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeopleModule = void 0;
+const base_1 = require("./base");
+const matcher_1 = require("../matching/matcher");
+class PeopleModule extends base_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+        this.personMatcher = new matcher_1.PersonMatcher(this);
+    }
+    /**
+     * Get all people with optional filtering
+     */
+    async getAll(options = {}) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        if (options.perPage) {
+            params.per_page = options.perPage;
+        }
+        if (options.page) {
+            params.page = options.page;
+        }
+        return this.getList('/people', params);
+    }
+    /**
+     * Get all people across all pages
+     */
+    async getAllPagesPaginated(options = {}, paginationOptions) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        return this.getAllPages('/people', params, paginationOptions);
+    }
+    /**
+     * Get a single person by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/people/${id}`, params);
+    }
+    /**
+     * Create a new person
+     */
+    async create(data) {
+        return this.createResource('/people', data);
+    }
+    /**
+     * Update a person
+     */
+    async update(id, data) {
+        return this.updateResource(`/people/${id}`, data);
+    }
+    /**
+     * Delete a person
+     */
+    async delete(id) {
+        return this.deleteResource(`/people/${id}`);
+    }
+    /**
+     * Find or create a person with smart matching
+     */
+    async findOrCreate(options) {
+        return this.personMatcher.findOrCreate(options);
+    }
+    /**
+     * Search people by multiple criteria
+     */
+    async search(criteria) {
+        const where = {};
+        if (criteria.name) {
+            where.name = criteria.name;
+        }
+        if (criteria.email) {
+            where.email = criteria.email;
+        }
+        if (criteria.phone) {
+            where.phone = criteria.phone;
+        }
+        if (criteria.status) {
+            where.status = criteria.status;
+        }
+        return this.getAll({
+            where,
+            perPage: criteria.perPage || 25,
+        });
+    }
+    // Contact methods
+    /**
+     * Get person's emails
+     */
+    async getEmails(personId) {
+        return this.getList(`/people/${personId}/emails`);
+    }
+    /**
+     * Add an email to a person
+     */
+    async addEmail(personId, data) {
+        return this.createResource(`/people/${personId}/emails`, data);
+    }
+    /**
+     * Update a person's email
+     */
+    async updateEmail(personId, emailId, data) {
+        return this.updateResource(`/people/${personId}/emails/${emailId}`, data);
+    }
+    /**
+     * Delete a person's email
+     */
+    async deleteEmail(personId, emailId) {
+        return this.deleteResource(`/people/${personId}/emails/${emailId}`);
+    }
+    /**
+     * Get person's phone numbers
+     */
+    async getPhoneNumbers(personId) {
+        return this.getList(`/people/${personId}/phone_numbers`);
+    }
+    /**
+     * Add a phone number to a person
+     */
+    async addPhoneNumber(personId, data) {
+        return this.createResource(`/people/${personId}/phone_numbers`, data);
+    }
+    /**
+     * Update a person's phone number
+     */
+    async updatePhoneNumber(personId, phoneId, data) {
+        return this.updateResource(`/people/${personId}/phone_numbers/${phoneId}`, data);
+    }
+    /**
+     * Delete a person's phone number
+     */
+    async deletePhoneNumber(personId, phoneId) {
+        return this.deleteResource(`/people/${personId}/phone_numbers/${phoneId}`);
+    }
+    /**
+     * Get person's addresses
+     */
+    async getAddresses(personId) {
+        return this.getList(`/people/${personId}/addresses`);
+    }
+    /**
+     * Add an address to a person
+     */
+    async addAddress(personId, data) {
+        return this.createResource(`/people/${personId}/addresses`, data);
+    }
+    /**
+     * Update a person's address
+     */
+    async updateAddress(personId, addressId, data) {
+        return this.updateResource(`/people/${personId}/addresses/${addressId}`, data);
+    }
+    /**
+     * Delete a person's address
+     */
+    async deleteAddress(personId, addressId) {
+        return this.deleteResource(`/people/${personId}/addresses/${addressId}`);
+    }
+    /**
+     * Get person's social profiles
+     */
+    async getSocialProfiles(personId) {
+        return this.getList(`/people/${personId}/social_profiles`);
+    }
+    /**
+     * Add a social profile to a person
+     */
+    async addSocialProfile(personId, data) {
+        return this.createResource(`/people/${personId}/social_profiles`, data);
+    }
+    /**
+     * Update a person's social profile
+     */
+    async updateSocialProfile(personId, profileId, data) {
+        return this.updateResource(`/people/${personId}/social_profiles/${profileId}`, data);
+    }
+    /**
+     * Delete a person's social profile
+     */
+    async deleteSocialProfile(personId, profileId) {
+        return this.deleteResource(`/people/${personId}/social_profiles/${profileId}`);
+    }
+    /**
+     * Create a person with contact information
+     */
+    async createWithContacts(personData, contacts) {
+        const person = await this.create(personData);
+        const result = { person };
+        if (contacts?.email) {
+            result.email = await this.addEmail(person.id, contacts.email);
+        }
+        if (contacts?.phone) {
+            result.phone = await this.addPhoneNumber(person.id, contacts.phone);
+        }
+        if (contacts?.address) {
+            result.address = await this.addAddress(person.id, contacts.address);
+        }
+        return result;
+    }
+}
+exports.PeopleModule = PeopleModule;

package/dist/modules/workflows.d.ts

@@ -0,0 +1,131 @@
+/**
+ * v2.0.0 Workflows Module
+ */
+import { BaseModule } from './base';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { WorkflowResource, WorkflowAttributes, WorkflowCardResource, WorkflowCardAssignableAttributes, WorkflowCardSnoozeAttributes, WorkflowCardEmailAttributes, WorkflowCardNoteResource, WorkflowCardNoteAttributes } from '../types';
+export interface WorkflowListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export interface AddPersonToWorkflowOptions {
+    note?: string;
+    skipIfExists?: boolean;
+    skipIfActive?: boolean;
+    noteTemplate?: string;
+}
+export declare class WorkflowsModule extends BaseModule {
+    /**
+     * Get all workflows
+     */
+    getAll(options?: WorkflowListOptions): Promise<{
+        data: WorkflowResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all workflows across all pages
+     */
+    getAllPagesPaginated(options?: WorkflowListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<WorkflowResource>>;
+    /**
+     * Get a single workflow by ID
+     */
+    getById(id: string, include?: string[]): Promise<WorkflowResource>;
+    /**
+     * Create a workflow
+     */
+    create(data: WorkflowAttributes): Promise<WorkflowResource>;
+    /**
+     * Update a workflow
+     */
+    update(id: string, data: Partial<WorkflowAttributes>): Promise<WorkflowResource>;
+    /**
+     * Delete a workflow
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get workflow cards for a person
+     */
+    getPersonWorkflowCards(personId: string): Promise<{
+        data: WorkflowCardResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Add a person to a workflow with smart duplicate detection
+     */
+    addPersonToWorkflow(personId: string, workflowId: string, options?: AddPersonToWorkflowOptions): Promise<WorkflowCardResource>;
+    /**
+     * Create a workflow card
+     */
+    createWorkflowCard(workflowId: string, personId: string): Promise<WorkflowCardResource>;
+    /**
+     * Update a workflow card
+     */
+    updateWorkflowCard(workflowCardId: string, data: Partial<WorkflowCardAssignableAttributes>, personId?: string): Promise<WorkflowCardResource>;
+    /**
+     * Get workflow card notes
+     */
+    getWorkflowCardNotes(personId: string, workflowCardId: string): Promise<{
+        data: WorkflowCardNoteResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Create a workflow card note
+     */
+    createWorkflowCardNote(personId: string, workflowCardId: string, data: WorkflowCardNoteAttributes): Promise<WorkflowCardNoteResource>;
+    /**
+     * Update a workflow card note
+     */
+    updateWorkflowCardNote(personId: string, workflowCardId: string, noteId: string, data: Partial<WorkflowCardNoteAttributes>): Promise<WorkflowCardNoteResource>;
+    /**
+     * Delete a workflow card note
+     */
+    deleteWorkflowCardNote(personId: string, workflowCardId: string, noteId: string): Promise<void>;
+    /**
+     * Create a workflow card with a note
+     */
+    createWorkflowCardWithNote(workflowId: string, personId: string, noteData: WorkflowCardNoteAttributes): Promise<{
+        workflowCard: WorkflowCardResource;
+        note: WorkflowCardNoteResource;
+    }>;
+    /**
+     * Move a workflow card back to the previous step
+     */
+    goBackWorkflowCard(personId: string, workflowCardId: string): Promise<WorkflowCardResource>;
+    /**
+     * Move a workflow card to the next step
+     */
+    promoteWorkflowCard(personId: string, workflowCardId: string): Promise<WorkflowCardResource>;
+    /**
+     * Remove a workflow card
+     */
+    removeWorkflowCard(personId: string, workflowCardId: string): Promise<WorkflowCardResource>;
+    /**
+     * Restore a workflow card
+     */
+    restoreWorkflowCard(personId: string, workflowCardId: string): Promise<WorkflowCardResource>;
+    /**
+     * Send an email to the subject of the workflow card
+     */
+    sendEmailWorkflowCard(personId: string, workflowCardId: string, data: WorkflowCardEmailAttributes): Promise<WorkflowCardResource>;
+    /**
+     * Move a workflow card to the next step without completing the current step
+     */
+    skipStepWorkflowCard(personId: string, workflowCardId: string): Promise<WorkflowCardResource>;
+    /**
+     * Snooze a workflow card for a specific duration
+     */
+    snoozeWorkflowCard(personId: string, workflowCardId: string, data: WorkflowCardSnoozeAttributes): Promise<WorkflowCardResource>;
+    /**
+     * Unsnooze a workflow card
+     */
+    unsnoozeWorkflowCard(personId: string, workflowCardId: string): Promise<WorkflowCardResource>;
+    /**
+     * Format note template with variables
+     */
+    private formatNoteTemplate;
+}