@rachelallyson/planning-center-people-ts 1.1.0 → 2.1.0

package/dist/modules/lists.d.ts

@@ -0,0 +1,62 @@
+/**
+ * v2.0.0 Lists Module
+ */
+import { BaseModule } from './base';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { ListResource, ListCategoryResource, ListCategoryAttributes, PersonResource } from '../types';
+export interface ListsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class ListsModule extends BaseModule {
+    /**
+     * Get all lists
+     */
+    getAll(options?: ListsListOptions): Promise<{
+        data: ListResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all lists across all pages
+     */
+    getAllPagesPaginated(options?: ListsListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<ListResource>>;
+    /**
+     * Get a single list by ID
+     */
+    getById(id: string, include?: string[]): Promise<ListResource>;
+    /**
+     * Get all list categories
+     */
+    getListCategories(): Promise<{
+        data: ListCategoryResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single list category by ID
+     */
+    getListCategoryById(id: string): Promise<ListCategoryResource>;
+    /**
+     * Create a new list category
+     */
+    createListCategory(data: ListCategoryAttributes): Promise<ListCategoryResource>;
+    /**
+     * Update an existing list category
+     */
+    updateListCategory(id: string, data: Partial<ListCategoryAttributes>): Promise<ListCategoryResource>;
+    /**
+     * Delete a list category
+     */
+    deleteListCategory(id: string): Promise<void>;
+    /**
+     * Get people in a list (via the people relationship)
+     */
+    getPeople(listId: string): Promise<{
+        data: PersonResource[];
+        meta?: any;
+        links?: any;
+    }>;
+}

package/dist/modules/lists.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * v2.0.0 Lists Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListsModule = void 0;
+const base_1 = require("./base");
+class ListsModule extends base_1.BaseModule {
+    /**
+     * Get all lists
+     */
+    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('/lists', params);
+    }
+    /**
+     * Get all lists 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('/lists', params, paginationOptions);
+    }
+    /**
+     * Get a single list by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/lists/${id}`, params);
+    }
+    /**
+     * Get all list categories
+     */
+    async getListCategories() {
+        return this.getList('/list_categories');
+    }
+    /**
+     * Get a single list category by ID
+     */
+    async getListCategoryById(id) {
+        return this.getSingle(`/list_categories/${id}`);
+    }
+    /**
+     * Create a new list category
+     */
+    async createListCategory(data) {
+        return this.createResource('/list_categories', data);
+    }
+    /**
+     * Update an existing list category
+     */
+    async updateListCategory(id, data) {
+        return this.updateResource(`/list_categories/${id}`, data);
+    }
+    /**
+     * Delete a list category
+     */
+    async deleteListCategory(id) {
+        return this.deleteResource(`/list_categories/${id}`);
+    }
+    /**
+     * Get people in a list (via the people relationship)
+     */
+    async getPeople(listId) {
+        return this.getList(`/lists/${listId}/people`);
+    }
+}
+exports.ListsModule = ListsModule;

package/dist/modules/notes.d.ts

@@ -0,0 +1,74 @@
+/**
+ * v2.0.0 Notes Module
+ */
+import { BaseModule } from './base';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { NoteResource, NoteAttributes, NoteCategoryResource, NoteCategoryAttributes } from '../types';
+export interface NotesListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class NotesModule extends BaseModule {
+    /**
+     * Get all notes
+     */
+    getAll(options?: NotesListOptions): Promise<{
+        data: NoteResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all notes across all pages
+     */
+    getAllPagesPaginated(options?: NotesListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<NoteResource>>;
+    /**
+     * Get a single note by ID
+     */
+    getById(id: string, include?: string[]): Promise<NoteResource>;
+    /**
+     * Get notes for a specific person
+     */
+    getNotesForPerson(personId: string, options?: NotesListOptions): Promise<{
+        data: NoteResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Create a note for a person
+     */
+    create(personId: string, data: NoteAttributes): Promise<NoteResource>;
+    /**
+     * Update a note
+     */
+    update(id: string, data: Partial<NoteAttributes>): Promise<NoteResource>;
+    /**
+     * Delete a note
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get all note categories
+     */
+    getNoteCategories(): Promise<{
+        data: NoteCategoryResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single note category by ID
+     */
+    getNoteCategoryById(id: string): Promise<NoteCategoryResource>;
+    /**
+     * Create a note category
+     */
+    createNoteCategory(data: NoteCategoryAttributes): Promise<NoteCategoryResource>;
+    /**
+     * Update a note category
+     */
+    updateNoteCategory(id: string, data: Partial<NoteCategoryAttributes>): Promise<NoteCategoryResource>;
+    /**
+     * Delete a note category
+     */
+    deleteNoteCategory(id: string): Promise<void>;
+}

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;
+    }>;
+}