@rachelallyson/planning-center-check-ins-ts 1.0.0

package/dist/modules/check-in-times.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * CheckInTimes Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckInTimesModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class CheckInTimesModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all check-in times 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('/check-ins/v2/check_in_times', params);
+    }
+    /**
+     * Get a single check-in time by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/check_in_times/${id}`, params);
+    }
+}
+exports.CheckInTimesModule = CheckInTimesModule;

package/dist/modules/check-ins.d.ts

@@ -0,0 +1,88 @@
+/**
+ * CheckIns Module for Check-Ins API
+ */
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PcoHttpClient, PaginationHelper, PcoEventEmitter } from '@rachelallyson/planning-center-base-ts';
+import type { CheckInResource, CheckInGroupResource, CheckInTimeResource, StationResource, EventResource, EventPeriodResource, EventTimeResource, LocationResource, OptionResource } from '../types';
+export interface CheckInsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+    filter?: string[];
+}
+export declare class CheckInsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all check-ins with optional filtering
+     */
+    getAll(options?: CheckInsListOptions): Promise<{
+        data: CheckInResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single check-in by ID
+     */
+    getById(id: string, include?: string[]): Promise<CheckInResource>;
+    /**
+     * Get check-in group for a check-in
+     */
+    getCheckInGroup(checkInId: string): Promise<CheckInGroupResource | null>;
+    /**
+     * Get check-in times for a check-in
+     */
+    getCheckInTimes(checkInId: string): Promise<{
+        data: CheckInTimeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get station where check-in occurred (checked_in_at)
+     */
+    getCheckedInAt(checkInId: string): Promise<StationResource | null>;
+    /**
+     * Get person who checked in (checked_in_by)
+     */
+    getCheckedInBy(checkInId: string): Promise<any | null>;
+    /**
+     * Get person who checked out (checked_out_by)
+     */
+    getCheckedOutBy(checkInId: string): Promise<any | null>;
+    /**
+     * Get event for a check-in
+     */
+    getEvent(checkInId: string): Promise<EventResource>;
+    /**
+     * Get event period for a check-in
+     */
+    getEventPeriod(checkInId: string): Promise<EventPeriodResource>;
+    /**
+     * Get event times for a check-in
+     */
+    getEventTimes(checkInId: string): Promise<{
+        data: EventTimeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get locations for a check-in
+     */
+    getLocations(checkInId: string): Promise<{
+        data: LocationResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get options for a check-in
+     */
+    getOptions(checkInId: string): Promise<{
+        data: OptionResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get person for a check-in
+     */
+    getPerson(checkInId: string): Promise<any | null>;
+}

package/dist/modules/check-ins.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * CheckIns Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckInsModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class CheckInsModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all check-ins 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;
+        }
+        // Apply filters if provided
+        if (options.filter && options.filter.length > 0) {
+            options.filter.forEach(filter => {
+                params[filter] = 'true';
+            });
+        }
+        return this.getList('/check-ins/v2/check_ins', params);
+    }
+    /**
+     * Get a single check-in by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/check_ins/${id}`, params);
+    }
+    // ===== Associations =====
+    /**
+     * Get check-in group for a check-in
+     */
+    async getCheckInGroup(checkInId) {
+        try {
+            return await this.getSingle(`/check-ins/v2/check_ins/${checkInId}/check_in_group`);
+        }
+        catch (error) {
+            if (error?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get check-in times for a check-in
+     */
+    async getCheckInTimes(checkInId) {
+        return this.getList(`/check-ins/v2/check_ins/${checkInId}/check_in_times`);
+    }
+    /**
+     * Get station where check-in occurred (checked_in_at)
+     */
+    async getCheckedInAt(checkInId) {
+        try {
+            return await this.getSingle(`/check-ins/v2/check_ins/${checkInId}/checked_in_at`);
+        }
+        catch (error) {
+            if (error?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get person who checked in (checked_in_by)
+     */
+    async getCheckedInBy(checkInId) {
+        try {
+            return await this.getSingle(`/check-ins/v2/check_ins/${checkInId}/checked_in_by`);
+        }
+        catch (error) {
+            if (error?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get person who checked out (checked_out_by)
+     */
+    async getCheckedOutBy(checkInId) {
+        try {
+            return await this.getSingle(`/check-ins/v2/check_ins/${checkInId}/checked_out_by`);
+        }
+        catch (error) {
+            if (error?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get event for a check-in
+     */
+    async getEvent(checkInId) {
+        return this.getSingle(`/check-ins/v2/check_ins/${checkInId}/event`);
+    }
+    /**
+     * Get event period for a check-in
+     */
+    async getEventPeriod(checkInId) {
+        return this.getSingle(`/check-ins/v2/check_ins/${checkInId}/event_period`);
+    }
+    /**
+     * Get event times for a check-in
+     */
+    async getEventTimes(checkInId) {
+        return this.getList(`/check-ins/v2/check_ins/${checkInId}/event_times`);
+    }
+    /**
+     * Get locations for a check-in
+     */
+    async getLocations(checkInId) {
+        return this.getList(`/check-ins/v2/check_ins/${checkInId}/locations`);
+    }
+    /**
+     * Get options for a check-in
+     */
+    async getOptions(checkInId) {
+        return this.getList(`/check-ins/v2/check_ins/${checkInId}/options`);
+    }
+    /**
+     * Get person for a check-in
+     */
+    async getPerson(checkInId) {
+        try {
+            return await this.getSingle(`/check-ins/v2/check_ins/${checkInId}/person`);
+        }
+        catch (error) {
+            if (error?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+}
+exports.CheckInsModule = CheckInsModule;

package/dist/modules/event-periods.d.ts

@@ -0,0 +1,57 @@
+/**
+ * EventPeriods Module for Check-Ins API
+ */
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PcoHttpClient, PaginationHelper, PcoEventEmitter } from '@rachelallyson/planning-center-base-ts';
+import type { EventPeriodResource, EventResource, EventTimeResource, CheckInResource, LocationEventPeriodResource } from '../types';
+export interface EventPeriodsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class EventPeriodsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all event periods with optional filtering
+     */
+    getAll(options?: EventPeriodsListOptions): Promise<{
+        data: EventPeriodResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single event period by ID
+     */
+    getById(id: string, include?: string[]): Promise<EventPeriodResource>;
+    /**
+     * Get event for an event period
+     */
+    getEvent(eventPeriodId: string): Promise<EventResource>;
+    /**
+     * Get event times for an event period
+     */
+    getEventTimes(eventPeriodId: string): Promise<{
+        data: EventTimeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get check-ins for an event period
+     */
+    getCheckIns(eventPeriodId: string, options?: {
+        filter?: string[];
+    }): Promise<{
+        data: CheckInResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get location event periods for an event period
+     */
+    getLocationEventPeriods(eventPeriodId: string): Promise<{
+        data: LocationEventPeriodResource[];
+        meta?: any;
+        links?: any;
+    }>;
+}

package/dist/modules/event-periods.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * EventPeriods Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPeriodsModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class EventPeriodsModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all event periods 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('/check-ins/v2/event_periods', params);
+    }
+    /**
+     * Get a single event period by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/event_periods/${id}`, params);
+    }
+    // ===== Associations =====
+    /**
+     * Get event for an event period
+     */
+    async getEvent(eventPeriodId) {
+        return this.getSingle(`/check-ins/v2/event_periods/${eventPeriodId}/event`);
+    }
+    /**
+     * Get event times for an event period
+     */
+    async getEventTimes(eventPeriodId) {
+        return this.getList(`/check-ins/v2/event_periods/${eventPeriodId}/event_times`);
+    }
+    /**
+     * Get check-ins for an event period
+     */
+    async getCheckIns(eventPeriodId, options = {}) {
+        const params = {};
+        if (options.filter && options.filter.length > 0) {
+            options.filter.forEach(filter => {
+                params[filter] = 'true';
+            });
+        }
+        return this.getList(`/check-ins/v2/event_periods/${eventPeriodId}/check_ins`, params);
+    }
+    /**
+     * Get location event periods for an event period
+     */
+    async getLocationEventPeriods(eventPeriodId) {
+        return this.getList(`/check-ins/v2/event_periods/${eventPeriodId}/location_event_periods`);
+    }
+}
+exports.EventPeriodsModule = EventPeriodsModule;

package/dist/modules/event-times.d.ts

@@ -0,0 +1,51 @@
+/**
+ * EventTimes Module for Check-Ins API
+ */
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PcoHttpClient, PaginationHelper, PcoEventEmitter } from '@rachelallyson/planning-center-base-ts';
+import type { EventTimeResource, EventResource, EventPeriodResource, LocationEventTimeResource, CheckInResource } from '../types';
+export interface EventTimesListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class EventTimesModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all event times with optional filtering
+     */
+    getAll(options?: EventTimesListOptions): Promise<{
+        data: EventTimeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single event time by ID
+     */
+    getById(id: string, include?: string[]): Promise<EventTimeResource>;
+    /**
+     * Get event for an event time
+     */
+    getEvent(eventTimeId: string): Promise<EventResource>;
+    /**
+     * Get event period for an event time
+     */
+    getEventPeriod(eventTimeId: string): Promise<EventPeriodResource>;
+    /**
+     * Get location event times for an event time
+     */
+    getLocationEventTimes(eventTimeId: string): Promise<{
+        data: LocationEventTimeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get check-ins for an event time
+     */
+    getCheckIns(eventTimeId: string): Promise<{
+        data: CheckInResource[];
+        meta?: any;
+        links?: any;
+    }>;
+}

package/dist/modules/event-times.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * EventTimes Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTimesModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class EventTimesModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all event times 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('/check-ins/v2/event_times', params);
+    }
+    /**
+     * Get a single event time by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/event_times/${id}`, params);
+    }
+    // ===== Associations =====
+    /**
+     * Get event for an event time
+     */
+    async getEvent(eventTimeId) {
+        return this.getSingle(`/check-ins/v2/event_times/${eventTimeId}/event`);
+    }
+    /**
+     * Get event period for an event time
+     */
+    async getEventPeriod(eventTimeId) {
+        return this.getSingle(`/check-ins/v2/event_times/${eventTimeId}/event_period`);
+    }
+    /**
+     * Get location event times for an event time
+     */
+    async getLocationEventTimes(eventTimeId) {
+        return this.getList(`/check-ins/v2/event_times/${eventTimeId}/location_event_times`);
+    }
+    /**
+     * Get check-ins for an event time
+     */
+    async getCheckIns(eventTimeId) {
+        return this.getList(`/check-ins/v2/event_times/${eventTimeId}/check_ins`);
+    }
+}
+exports.EventTimesModule = EventTimesModule;

package/dist/modules/events.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Events Module for Check-Ins API
+ */
+import { BaseModule } from '@rachelallyson/planning-center-base-ts';
+import type { PcoHttpClient, PaginationHelper, PcoEventEmitter } from '@rachelallyson/planning-center-base-ts';
+import type { EventResource, EventPeriodResource, EventTimeResource, AttendanceTypeResource, CheckInResource, EventLabelResource, LocationResource, PersonEventResource, IntegrationLinkResource } from '../types';
+export interface EventsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class EventsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all events with optional filtering
+     */
+    getAll(options?: EventsListOptions): Promise<{
+        data: EventResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single event by ID
+     */
+    getById(id: string, include?: string[]): Promise<EventResource>;
+    /**
+     * Get attendance types for an event
+     */
+    getAttendanceTypes(eventId: string): Promise<{
+        data: AttendanceTypeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get check-ins for an event
+     */
+    getCheckIns(eventId: string, options?: {
+        filter?: string[];
+    }): Promise<{
+        data: CheckInResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get current event times for an event
+     */
+    getCurrentEventTimes(eventId: string): Promise<{
+        data: EventTimeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get event labels for an event
+     */
+    getEventLabels(eventId: string): Promise<{
+        data: EventLabelResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get event periods for an event
+     */
+    getEventPeriods(eventId: string): Promise<{
+        data: EventPeriodResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get integration links for an event
+     */
+    getIntegrationLinks(eventId: string): Promise<{
+        data: IntegrationLinkResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get locations for an event
+     */
+    getLocations(eventId: string): Promise<{
+        data: LocationResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get person events for an event
+     */
+    getPersonEvents(eventId: string): Promise<{
+        data: PersonEventResource[];
+        meta?: any;
+        links?: any;
+    }>;
+}