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

package/dist/modules/events.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Events Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class EventsModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all events 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/events', params);
+    }
+    /**
+     * Get a single event by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/events/${id}`, params);
+    }
+    // ===== Associations =====
+    /**
+     * Get attendance types for an event
+     */
+    async getAttendanceTypes(eventId) {
+        return this.getList(`/check-ins/v2/events/${eventId}/attendance_types`);
+    }
+    /**
+     * Get check-ins for an event
+     */
+    async getCheckIns(eventId, options = {}) {
+        const params = {};
+        // Apply filters: attendee, checked_out, first_time, guest, not_checked_out, 
+        // not_one_time_guest, one_time_guest, regular, volunteer
+        if (options.filter && options.filter.length > 0) {
+            options.filter.forEach(filter => {
+                params[filter] = 'true';
+            });
+        }
+        return this.getList(`/check-ins/v2/events/${eventId}/check_ins`, params);
+    }
+    /**
+     * Get current event times for an event
+     */
+    async getCurrentEventTimes(eventId) {
+        return this.getList(`/check-ins/v2/events/${eventId}/current_event_times`);
+    }
+    /**
+     * Get event labels for an event
+     */
+    async getEventLabels(eventId) {
+        return this.getList(`/check-ins/v2/events/${eventId}/event_labels`);
+    }
+    /**
+     * Get event periods for an event
+     */
+    async getEventPeriods(eventId) {
+        return this.getList(`/check-ins/v2/events/${eventId}/event_periods`);
+    }
+    /**
+     * Get integration links for an event
+     */
+    async getIntegrationLinks(eventId) {
+        return this.getList(`/check-ins/v2/events/${eventId}/integration_links`);
+    }
+    /**
+     * Get locations for an event
+     */
+    async getLocations(eventId) {
+        return this.getList(`/check-ins/v2/events/${eventId}/locations`);
+    }
+    /**
+     * Get person events for an event
+     */
+    async getPersonEvents(eventId) {
+        return this.getList(`/check-ins/v2/events/${eventId}/person_events`);
+    }
+}
+exports.EventsModule = EventsModule;

package/dist/modules/headcounts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Headcounts 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 { HeadcountResource } from '../types';
+export interface HeadcountsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class HeadcountsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all headcounts with optional filtering
+     */
+    getAll(options?: HeadcountsListOptions): Promise<{
+        data: HeadcountResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single headcount by ID
+     */
+    getById(id: string, include?: string[]): Promise<HeadcountResource>;
+}

package/dist/modules/headcounts.js

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

package/dist/modules/integration-links.d.ts

@@ -0,0 +1,27 @@
+/**
+ * IntegrationLinks 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 { IntegrationLinkResource } from '../types';
+export interface IntegrationLinksListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class IntegrationLinksModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all integration links with optional filtering
+     */
+    getAll(options?: IntegrationLinksListOptions): Promise<{
+        data: IntegrationLinkResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single integration link by ID
+     */
+    getById(id: string, include?: string[]): Promise<IntegrationLinkResource>;
+}

package/dist/modules/integration-links.js

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

package/dist/modules/labels.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Labels 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 { LabelResource, EventLabelResource, LocationLabelResource } from '../types';
+export interface LabelsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class LabelsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all labels with optional filtering
+     */
+    getAll(options?: LabelsListOptions): Promise<{
+        data: LabelResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single label by ID
+     */
+    getById(id: string, include?: string[]): Promise<LabelResource>;
+    /**
+     * Get all event labels
+     */
+    getEventLabels(options?: LabelsListOptions): Promise<{
+        data: EventLabelResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single event label by ID
+     */
+    getEventLabelById(id: string, include?: string[]): Promise<EventLabelResource>;
+    /**
+     * Get all location labels
+     */
+    getLocationLabels(options?: LabelsListOptions): Promise<{
+        data: LocationLabelResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single location label by ID
+     */
+    getLocationLabelById(id: string, include?: string[]): Promise<LocationLabelResource>;
+}

package/dist/modules/labels.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Labels Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelsModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class LabelsModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all labels 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/labels', params);
+    }
+    /**
+     * Get a single label by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/labels/${id}`, params);
+    }
+    // ===== Event Labels =====
+    /**
+     * Get all event labels
+     */
+    async getEventLabels(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_labels', params);
+    }
+    /**
+     * Get a single event label by ID
+     */
+    async getEventLabelById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/event_labels/${id}`, params);
+    }
+    // ===== Location Labels =====
+    /**
+     * Get all location labels
+     */
+    async getLocationLabels(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/location_labels', params);
+    }
+    /**
+     * Get a single location label by ID
+     */
+    async getLocationLabelById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/location_labels/${id}`, params);
+    }
+}
+exports.LabelsModule = LabelsModule;

package/dist/modules/locations.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Locations 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 { LocationResource, LocationEventPeriodResource, LocationEventTimeResource, LocationLabelResource } from '../types';
+export interface LocationsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class LocationsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all locations with optional filtering
+     */
+    getAll(options?: LocationsListOptions): Promise<{
+        data: LocationResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single location by ID
+     */
+    getById(id: string, include?: string[]): Promise<LocationResource>;
+    /**
+     * Get location event periods for a location
+     */
+    getLocationEventPeriods(locationId: string): Promise<{
+        data: LocationEventPeriodResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get location event times for a location
+     */
+    getLocationEventTimes(locationId: string): Promise<{
+        data: LocationEventTimeResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get location labels for a location
+     */
+    getLocationLabels(locationId: string): Promise<{
+        data: LocationLabelResource[];
+        meta?: any;
+        links?: any;
+    }>;
+}

package/dist/modules/locations.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Locations Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationsModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class LocationsModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get all locations 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/locations', params);
+    }
+    /**
+     * Get a single location by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/check-ins/v2/locations/${id}`, params);
+    }
+    // ===== Associations =====
+    /**
+     * Get location event periods for a location
+     */
+    async getLocationEventPeriods(locationId) {
+        return this.getList(`/check-ins/v2/locations/${locationId}/location_event_periods`);
+    }
+    /**
+     * Get location event times for a location
+     */
+    async getLocationEventTimes(locationId) {
+        return this.getList(`/check-ins/v2/locations/${locationId}/location_event_times`);
+    }
+    /**
+     * Get location labels for a location
+     */
+    async getLocationLabels(locationId) {
+        return this.getList(`/check-ins/v2/locations/${locationId}/location_labels`);
+    }
+}
+exports.LocationsModule = LocationsModule;

package/dist/modules/options.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Options 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 { OptionResource } from '../types';
+export interface OptionsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class OptionsModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all options with optional filtering
+     */
+    getAll(options?: OptionsListOptions): Promise<{
+        data: OptionResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single option by ID
+     */
+    getById(id: string, include?: string[]): Promise<OptionResource>;
+}

package/dist/modules/options.js

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

package/dist/modules/organization.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Organization 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 { OrganizationResource } from '../types';
+export declare class OrganizationModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get organization information
+     */
+    get(): Promise<OrganizationResource>;
+}

package/dist/modules/organization.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Organization Module for Check-Ins API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationModule = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+class OrganizationModule extends planning_center_base_ts_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+    }
+    /**
+     * Get organization information
+     */
+    async get() {
+        return this.getSingle('/check-ins/v2/organization');
+    }
+}
+exports.OrganizationModule = OrganizationModule;

package/dist/modules/passes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Passes 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 { PassResource } from '../types';
+export interface PassesListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class PassesModule extends BaseModule {
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all passes with optional filtering
+     */
+    getAll(options?: PassesListOptions): Promise<{
+        data: PassResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single pass by ID
+     */
+    getById(id: string, include?: string[]): Promise<PassResource>;
+}