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

package/dist/testing/simple-factories.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * Simplified Testing Factory Functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleMockPcoClient = void 0;
+exports.createSimpleMockClient = createSimpleMockClient;
+exports.createTestClient = createTestClient;
+exports.createErrorMockClient = createErrorMockClient;
+exports.createSlowMockClient = createSlowMockClient;
+const simple_builders_1 = require("./simple-builders");
+class SimpleMockPcoClient {
+    constructor(config, mockConfig = {}) {
+        this.config = config;
+        this.mockConfig = mockConfig;
+        // Initialize modules with mock implementations
+        this.people = this.createPeopleModule();
+        this.fields = this.createFieldsModule();
+        this.workflows = this.createWorkflowsModule();
+        this.contacts = this.createContactsModule();
+        this.households = this.createHouseholdsModule();
+        this.notes = this.createNotesModule();
+        this.lists = this.createListsModule();
+        this.batch = this.createBatchModule();
+    }
+    createPeopleModule() {
+        return {
+            getAll: this.mockConfig.people?.getAll || (() => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([simple_builders_1.SimpleMockResponseBuilder.person()]))),
+            getById: this.mockConfig.people?.getById || ((id) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.person({ id }))),
+            create: this.mockConfig.people?.create || ((data) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.person(data))),
+            update: this.mockConfig.people?.update || ((id, data) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.person({ id, ...data }))),
+            delete: this.mockConfig.people?.delete || (() => Promise.resolve()),
+            findOrCreate: this.mockConfig.people?.findOrCreate || ((options) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.person({
+                first_name: options.firstName,
+                last_name: options.lastName,
+            }))),
+            createWithContacts: this.mockConfig.people?.createWithContacts || ((personData, contacts) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.person({
+                first_name: personData.firstName,
+                last_name: personData.lastName,
+            }))),
+            search: this.mockConfig.people?.search || ((criteria) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([simple_builders_1.SimpleMockResponseBuilder.person()]))),
+            getAllPages: this.mockConfig.people?.getAllPages || (() => Promise.resolve({
+                data: [simple_builders_1.SimpleMockResponseBuilder.person()],
+                totalCount: 1,
+                pagesFetched: 1,
+                duration: 100,
+            })),
+            addEmail: this.mockConfig.people?.addEmail || ((personId, data) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.email(data))),
+            addPhoneNumber: this.mockConfig.people?.addPhoneNumber || ((personId, data) => Promise.resolve({ type: 'PhoneNumber', id: 'phone_123', attributes: data })),
+            addAddress: this.mockConfig.people?.addAddress || ((personId, data) => Promise.resolve({ type: 'Address', id: 'address_123', attributes: data })),
+            addSocialProfile: this.mockConfig.people?.addSocialProfile || ((personId, data) => Promise.resolve({ type: 'SocialProfile', id: 'social_123', attributes: data })),
+        };
+    }
+    createFieldsModule() {
+        return {
+            getAllFieldDefinitions: this.mockConfig.fields?.getAllFieldDefinitions || (() => Promise.resolve([{ type: 'FieldDefinition', id: 'field_1', attributes: { name: 'Birthdate', slug: 'birthdate' } }])),
+            getFieldDefinition: this.mockConfig.fields?.getFieldDefinition || ((id) => Promise.resolve({ type: 'FieldDefinition', id, attributes: { name: 'Test Field' } })),
+            getFieldDefinitionBySlug: this.mockConfig.fields?.getFieldDefinitionBySlug || ((slug) => Promise.resolve({ type: 'FieldDefinition', id: 'field_1', attributes: { slug } })),
+            getFieldDefinitionByName: this.mockConfig.fields?.getFieldDefinitionByName || ((name) => Promise.resolve({ type: 'FieldDefinition', id: 'field_1', attributes: { name } })),
+            setPersonField: this.mockConfig.fields?.setPersonField || (() => Promise.resolve({ id: 'field_data_123', value: 'test' })),
+            setPersonFieldById: this.mockConfig.fields?.setPersonFieldById || (() => Promise.resolve({ id: 'field_data_123', value: 'test' })),
+            setPersonFieldBySlug: this.mockConfig.fields?.setPersonFieldBySlug || ((personId, slug, value) => Promise.resolve({ id: 'field_data_123', value })),
+            setPersonFieldByName: this.mockConfig.fields?.setPersonFieldByName || (() => Promise.resolve({ id: 'field_data_123', value: 'test' })),
+        };
+    }
+    createWorkflowsModule() {
+        return {
+            getAll: this.mockConfig.workflows?.getAll || (() => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([simple_builders_1.SimpleMockResponseBuilder.workflow()]))),
+            getById: this.mockConfig.workflows?.getById || ((id) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.workflow({ id }))),
+            create: this.mockConfig.workflows?.create || ((data) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.workflow(data))),
+            update: this.mockConfig.workflows?.update || ((id, data) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.workflow({ id, ...data }))),
+            delete: this.mockConfig.workflows?.delete || (() => Promise.resolve()),
+            getAllPages: this.mockConfig.workflows?.getAllPages || (() => Promise.resolve({
+                data: [simple_builders_1.SimpleMockResponseBuilder.workflow()],
+                totalCount: 1,
+                pagesFetched: 1,
+                duration: 100,
+            })),
+            addPersonToWorkflow: this.mockConfig.workflows?.addPersonToWorkflow || (() => Promise.resolve({ type: 'WorkflowCard', id: 'workflow_card_123', attributes: {} })),
+            createWorkflowCard: this.mockConfig.workflows?.createWorkflowCard || (() => Promise.resolve({ type: 'WorkflowCard', id: 'workflow_card_123', attributes: {} })),
+            createWorkflowCardNote: this.mockConfig.workflows?.createWorkflowCardNote || (() => Promise.resolve({ type: 'WorkflowCardNote', id: 'workflow_card_note_123', attributes: {} })),
+        };
+    }
+    createContactsModule() {
+        return {
+            getAllEmails: () => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([simple_builders_1.SimpleMockResponseBuilder.email()])),
+            createEmail: (data) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.email(data)),
+            getAllPhoneNumbers: () => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([])),
+            createPhoneNumber: (data) => Promise.resolve({ type: 'PhoneNumber', id: 'phone_123', attributes: data }),
+            getAllAddresses: () => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([])),
+            createAddress: (data) => Promise.resolve({ type: 'Address', id: 'address_123', attributes: data }),
+            getAllSocialProfiles: () => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([])),
+            createSocialProfile: (data) => Promise.resolve({ type: 'SocialProfile', id: 'social_123', attributes: data }),
+        };
+    }
+    createHouseholdsModule() {
+        return {
+            getAll: () => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([])),
+            getById: (id) => Promise.resolve({ type: 'Household', id, attributes: {} }),
+            create: (data) => Promise.resolve({ type: 'Household', id: 'household_123', attributes: data }),
+            update: (id, data) => Promise.resolve({ type: 'Household', id, attributes: data }),
+            delete: () => Promise.resolve(),
+        };
+    }
+    createNotesModule() {
+        return {
+            getAll: () => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([])),
+            getById: (id) => Promise.resolve({ type: 'Note', id, attributes: {} }),
+            create: (data) => Promise.resolve({ type: 'Note', id: 'note_123', attributes: data }),
+            update: (id, data) => Promise.resolve({ type: 'Note', id, attributes: data }),
+            delete: () => Promise.resolve(),
+        };
+    }
+    createListsModule() {
+        return {
+            getAll: () => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.paginated([])),
+            getById: (id) => Promise.resolve({ type: 'List', id, attributes: {} }),
+            create: (data) => Promise.resolve({ type: 'List', id: 'list_123', attributes: data }),
+            update: (id, data) => Promise.resolve({ type: 'List', id, attributes: data }),
+            delete: () => Promise.resolve(),
+        };
+    }
+    createBatchModule() {
+        return {
+            execute: this.mockConfig.batch?.execute || ((operations) => Promise.resolve({
+                total: operations.length,
+                successful: operations.length,
+                failed: 0,
+                successRate: 1.0,
+                duration: 100,
+                results: operations.map((op, index) => ({
+                    index,
+                    operation: op,
+                    success: true,
+                    data: { id: `result_${index}` },
+                })),
+            })),
+        };
+    }
+    // Event system methods (mock implementations)
+    on(eventType, handler) {
+        // Mock implementation - does nothing
+    }
+    off(eventType, handler) {
+        // Mock implementation - does nothing
+    }
+    emit(event) {
+        // Mock implementation - does nothing
+    }
+    getConfig() {
+        return this.config;
+    }
+    getPerformanceMetrics() {
+        return {};
+    }
+    getRateLimitInfo() {
+        return {};
+    }
+    removeAllListeners(eventType) {
+        // Mock implementation - does nothing
+    }
+    listenerCount(eventType) {
+        return 0;
+    }
+    eventTypes() {
+        return [];
+    }
+}
+exports.SimpleMockPcoClient = SimpleMockPcoClient;
+/**
+ * Create a simple mock client for testing
+ */
+function createSimpleMockClient(config, mockConfig = {}) {
+    return new SimpleMockPcoClient(config, mockConfig);
+}
+/**
+ * Create a test client with common mock responses
+ */
+function createTestClient(overrides = {}) {
+    const defaultConfig = {
+        auth: {
+            type: 'oauth',
+            accessToken: 'test-token',
+        },
+    };
+    const defaultMockConfig = {
+        people: {
+            getAll: () => Promise.resolve({
+                data: [
+                    simple_builders_1.SimpleMockResponseBuilder.person({ id: 'person_1', first_name: 'John', last_name: 'Doe' })
+                ],
+                meta: { total_count: 1 },
+                links: { self: '/people', next: null, prev: null },
+            }),
+            create: (data) => Promise.resolve(simple_builders_1.SimpleMockResponseBuilder.person({
+                id: 'person_new',
+                first_name: data.firstName || data.first_name || 'New',
+                last_name: data.lastName || data.last_name || 'Person',
+            })),
+        },
+        fields: {
+            getAllFieldDefinitions: () => Promise.resolve([
+                simple_builders_1.SimpleMockResponseBuilder.person({ type: 'FieldDefinition', id: 'field_1', attributes: { name: 'Birthdate', slug: 'birthdate' } })
+            ]),
+            setPersonFieldBySlug: (personId, slug, value) => Promise.resolve({ id: 'field_data_123', value }),
+        },
+        workflows: {
+            getAll: () => Promise.resolve({
+                data: [simple_builders_1.SimpleMockResponseBuilder.workflow({ id: 'workflow_1', name: 'New Member Workflow' })],
+                meta: { total_count: 1 },
+                links: { self: '/workflows', next: null, prev: null },
+            }),
+        },
+        batch: {
+            execute: (operations) => Promise.resolve({
+                total: operations.length,
+                successful: operations.length,
+                failed: 0,
+                successRate: 1.0,
+                duration: 100,
+                results: operations.map((op, index) => ({
+                    index,
+                    operation: op,
+                    success: true,
+                    data: { id: `result_${index}` },
+                })),
+            }),
+        },
+    };
+    // Merge with overrides
+    const mergedMockConfig = { ...defaultMockConfig, ...overrides };
+    return createSimpleMockClient(defaultConfig, mergedMockConfig);
+}
+/**
+ * Create a mock client that simulates errors
+ */
+function createErrorMockClient(errorType = 'network') {
+    const config = {
+        auth: {
+            type: 'oauth',
+            accessToken: 'test-token',
+        },
+    };
+    const errorMockConfig = {
+        people: {
+            getAll: () => {
+                const error = new Error(`Mock ${errorType} error`);
+                error.status = errorType === 'auth' ? 401 : errorType === 'rate_limit' ? 429 : 500;
+                return Promise.reject(error);
+            },
+        },
+    };
+    return createSimpleMockClient(config, errorMockConfig);
+}
+/**
+ * Create a mock client with specific response delays
+ */
+function createSlowMockClient(delayMs = 1000) {
+    const config = {
+        auth: {
+            type: 'oauth',
+            accessToken: 'test-token',
+        },
+    };
+    const slowMockConfig = {
+        people: {
+            getAll: () => new Promise(resolve => {
+                setTimeout(() => {
+                    resolve({
+                        data: [],
+                        meta: { total_count: 0 },
+                        links: { self: '/people', next: null, prev: null },
+                    });
+                }, delayMs);
+            }),
+        },
+    };
+    return createSimpleMockClient(config, slowMockConfig);
+}

package/dist/testing/types.d.ts

@@ -0,0 +1,160 @@
+/**
+ * v2.0.0 Testing Types
+ */
+import type { PcoClientConfig } from '../types/client';
+import type { PersonResource, EmailResource, PhoneNumberResource, AddressResource, SocialProfileResource, FieldDefinitionResource, WorkflowResource, WorkflowCardResource, WorkflowCardNoteResource, HouseholdResource, NoteResource, ListResource } from '../types';
+export interface MockClientConfig {
+    /** Mock responses for people operations */
+    people?: {
+        getAll?: () => Promise<{
+            data: PersonResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        getById?: (id: string) => Promise<PersonResource>;
+        create?: (data: any) => Promise<PersonResource>;
+        update?: (id: string, data: any) => Promise<PersonResource>;
+        delete?: (id: string) => Promise<void>;
+        findOrCreate?: (options: any) => Promise<PersonResource>;
+        search?: (criteria: any) => Promise<{
+            data: PersonResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        getAllPages?: (options?: any) => Promise<{
+            data: PersonResource[];
+            totalCount: number;
+            pagesFetched: number;
+            duration: number;
+        }>;
+        addEmail?: (personId: string, data: any) => Promise<EmailResource>;
+        addPhoneNumber?: (personId: string, data: any) => Promise<PhoneNumberResource>;
+        addAddress?: (personId: string, data: any) => Promise<AddressResource>;
+        addSocialProfile?: (personId: string, data: any) => Promise<SocialProfileResource>;
+    };
+    /** Mock responses for fields operations */
+    fields?: {
+        getAllFieldDefinitions?: () => Promise<FieldDefinitionResource[]>;
+        getFieldDefinition?: (id: string) => Promise<FieldDefinitionResource>;
+        getFieldDefinitionBySlug?: (slug: string) => Promise<FieldDefinitionResource | null>;
+        getFieldDefinitionByName?: (name: string) => Promise<FieldDefinitionResource | null>;
+        setPersonField?: (personId: string, options: any) => Promise<any>;
+        setPersonFieldById?: (personId: string, fieldId: string, value: string) => Promise<any>;
+        setPersonFieldBySlug?: (personId: string, slug: string, value: string) => Promise<any>;
+        setPersonFieldByName?: (personId: string, name: string, value: string) => Promise<any>;
+    };
+    /** Mock responses for workflows operations */
+    workflows?: {
+        getAll?: (options?: any) => Promise<{
+            data: WorkflowResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        getById?: (id: string) => Promise<WorkflowResource>;
+        create?: (data: any) => Promise<WorkflowResource>;
+        update?: (id: string, data: any) => Promise<WorkflowResource>;
+        delete?: (id: string) => Promise<void>;
+        getAllPages?: (options?: any) => Promise<{
+            data: WorkflowResource[];
+            totalCount: number;
+            pagesFetched: number;
+            duration: number;
+        }>;
+        addPersonToWorkflow?: (personId: string, workflowId: string, options?: any) => Promise<WorkflowCardResource>;
+        createWorkflowCard?: (workflowId: string, personId: string) => Promise<WorkflowCardResource>;
+        createWorkflowCardNote?: (personId: string, workflowCardId: string, data: any) => Promise<WorkflowCardNoteResource>;
+    };
+    /** Mock responses for contacts operations */
+    contacts?: {
+        getAllEmails?: () => Promise<{
+            data: EmailResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        createEmail?: (data: any) => Promise<EmailResource>;
+        getAllPhoneNumbers?: () => Promise<{
+            data: PhoneNumberResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        createPhoneNumber?: (data: any) => Promise<PhoneNumberResource>;
+        getAllAddresses?: () => Promise<{
+            data: AddressResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        createAddress?: (data: any) => Promise<AddressResource>;
+        getAllSocialProfiles?: () => Promise<{
+            data: SocialProfileResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        createSocialProfile?: (data: any) => Promise<SocialProfileResource>;
+    };
+    /** Mock responses for households operations */
+    households?: {
+        getAll?: (options?: any) => Promise<{
+            data: HouseholdResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        getById?: (id: string) => Promise<HouseholdResource>;
+        create?: (data: any) => Promise<HouseholdResource>;
+        update?: (id: string, data: any) => Promise<HouseholdResource>;
+        delete?: (id: string) => Promise<void>;
+    };
+    /** Mock responses for notes operations */
+    notes?: {
+        getAll?: (options?: any) => Promise<{
+            data: NoteResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        getById?: (id: string) => Promise<NoteResource>;
+        create?: (data: any) => Promise<NoteResource>;
+        update?: (id: string, data: any) => Promise<NoteResource>;
+        delete?: (id: string) => Promise<void>;
+    };
+    /** Mock responses for lists operations */
+    lists?: {
+        getAll?: (options?: any) => Promise<{
+            data: ListResource[];
+            meta?: any;
+            links?: any;
+        }>;
+        getById?: (id: string) => Promise<ListResource>;
+        create?: (data: any) => Promise<ListResource>;
+        update?: (id: string, data: any) => Promise<ListResource>;
+        delete?: (id: string) => Promise<void>;
+    };
+    /** Mock responses for batch operations */
+    batch?: {
+        execute?: (operations: any[]) => Promise<any>;
+    };
+}
+export interface RecordingConfig {
+    /** Path to save recorded requests/responses */
+    recordPath: string;
+    /** Whether to record new requests or replay existing ones */
+    mode: 'record' | 'replay' | 'auto';
+    /** Filter which requests to record */
+    filter?: (endpoint: string, method: string) => boolean;
+    /** Transform recorded responses */
+    transform?: (response: any) => any;
+}
+export interface RecordedRequest {
+    endpoint: string;
+    method: string;
+    params?: Record<string, any>;
+    data?: any;
+    response: any;
+    timestamp: string;
+}
+export interface RecordedSession {
+    requests: RecordedRequest[];
+    metadata: {
+        recordedAt: string;
+        version: string;
+        config: PcoClientConfig;
+    };
+}

package/dist/testing/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * v2.0.0 Testing Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/batch.d.ts

@@ -0,0 +1,50 @@
+/**
+ * v2.0.0 Batch Operations Types
+ */
+export interface BatchOperation {
+    type: string;
+    data?: any;
+    dependencies?: string[];
+    [key: string]: any;
+}
+export interface BatchResult<T = any> {
+    index: number;
+    operation: BatchOperation;
+    success: boolean;
+    data?: T;
+    error?: Error;
+}
+export interface BatchOptions {
+    /** Continue processing other operations if one fails */
+    continueOnError?: boolean;
+    /** Maximum number of operations to run in parallel */
+    maxConcurrency?: number;
+    /** Enable automatic rollback on failure */
+    enableRollback?: boolean;
+    /** Callback for each completed operation */
+    onOperationComplete?: (result: BatchResult) => void;
+    /** Callback for batch completion */
+    onBatchComplete?: (results: BatchResult[]) => void;
+}
+export interface BatchSummary {
+    total: number;
+    successful: number;
+    failed: number;
+    successRate: number;
+    duration: number;
+    results: BatchResult[];
+}
+export interface OperationReference {
+    /** Reference to a previous operation result using $index.path syntax */
+    reference: string;
+    /** The operation index being referenced */
+    index: number;
+    /** The path within the result object */
+    path: string;
+}
+export interface ResolvedBatchOperation extends BatchOperation {
+    /** Resolved data with references replaced */
+    resolvedData?: any;
+    /** Dependencies on other operations */
+    dependencies?: string[];
+}

package/dist/types/batch.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * v2.0.0 Batch Operations Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/client.d.ts

@@ -0,0 +1,81 @@
+/**
+ * v2.0.0 Client Configuration Types
+ */
+export interface PcoClientConfig {
+    /** Authentication configuration */
+    auth: {
+        type: 'oauth' | 'personal_access_token';
+        accessToken?: string;
+        refreshToken?: string;
+        personalAccessToken?: string;
+        onRefresh?: (tokens: {
+            accessToken: string;
+            refreshToken?: string;
+        }) => void | Promise<void>;
+        onRefreshFailure?: (error: Error) => void | Promise<void>;
+    };
+    /** Caching configuration */
+    caching?: {
+        fieldDefinitions?: boolean;
+        ttl?: number;
+        maxSize?: number;
+    };
+    /** Retry configuration */
+    retry?: {
+        enabled?: boolean;
+        maxRetries?: number;
+        baseDelay?: number;
+        maxDelay?: number;
+        backoff?: 'linear' | 'exponential';
+    };
+    /** Event handlers */
+    events?: {
+        onError?: (event: ErrorEvent) => void | Promise<void>;
+        onAuthFailure?: (event: AuthFailureEvent) => void | Promise<void>;
+        onRequestStart?: (event: RequestStartEvent) => void | Promise<void>;
+        onRequestComplete?: (event: RequestCompleteEvent) => void | Promise<void>;
+        onRateLimit?: (event: RateLimitEvent) => void | Promise<void>;
+    };
+    /** Base URL override */
+    baseURL?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+export interface ErrorEvent {
+    error: Error;
+    operation: string;
+    timestamp: string;
+    context?: Record<string, any>;
+}
+export interface AuthFailureEvent {
+    error: Error;
+    timestamp: string;
+    authType: 'oauth' | 'basic';
+}
+export interface RequestStartEvent {
+    endpoint: string;
+    method: string;
+    timestamp: string;
+    requestId: string;
+}
+export interface RequestCompleteEvent {
+    endpoint: string;
+    method: string;
+    status: number;
+    duration: number;
+    timestamp: string;
+    requestId: string;
+}
+export interface RateLimitEvent {
+    limit: number;
+    remaining: number;
+    resetTime: string;
+    timestamp: string;
+}
+export interface CacheEvent {
+    key: string;
+    operation: 'hit' | 'miss' | 'set' | 'invalidate';
+    timestamp: string;
+}

package/dist/types/client.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * v2.0.0 Client Configuration Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/events.d.ts

@@ -0,0 +1,85 @@
+/**
+ * v2.0.0 Event System Types
+ */
+export type EventType = 'request:start' | 'request:complete' | 'request:error' | 'auth:success' | 'auth:failure' | 'auth:refresh' | 'rate:limit' | 'rate:available' | 'cache:hit' | 'cache:miss' | 'cache:set' | 'cache:invalidate' | 'error';
+export interface BaseEvent {
+    type: EventType;
+    timestamp: string;
+    requestId?: string;
+}
+export interface RequestStartEvent extends BaseEvent {
+    type: 'request:start';
+    endpoint: string;
+    method: string;
+    requestId: string;
+}
+export interface RequestCompleteEvent extends BaseEvent {
+    type: 'request:complete';
+    endpoint: string;
+    method: string;
+    status: number;
+    duration: number;
+    requestId: string;
+}
+export interface RequestErrorEvent extends BaseEvent {
+    type: 'request:error';
+    endpoint: string;
+    method: string;
+    error: Error;
+    requestId: string;
+}
+export interface AuthSuccessEvent extends BaseEvent {
+    type: 'auth:success';
+    authType: 'oauth' | 'basic';
+}
+export interface AuthFailureEvent extends BaseEvent {
+    type: 'auth:failure';
+    authType: 'oauth' | 'basic';
+    error: Error;
+}
+export interface AuthRefreshEvent extends BaseEvent {
+    type: 'auth:refresh';
+    authType: 'oauth';
+    success: boolean;
+}
+export interface RateLimitEvent extends BaseEvent {
+    type: 'rate:limit';
+    limit: number;
+    remaining: number;
+    resetTime: string;
+}
+export interface RateAvailableEvent extends BaseEvent {
+    type: 'rate:available';
+    limit: number;
+    remaining: number;
+}
+export interface CacheHitEvent extends BaseEvent {
+    type: 'cache:hit';
+    key: string;
+}
+export interface CacheMissEvent extends BaseEvent {
+    type: 'cache:miss';
+    key: string;
+}
+export interface CacheSetEvent extends BaseEvent {
+    type: 'cache:set';
+    key: string;
+    ttl?: number;
+}
+export interface CacheInvalidateEvent extends BaseEvent {
+    type: 'cache:invalidate';
+    key: string;
+}
+export interface ErrorEvent extends BaseEvent {
+    type: 'error';
+    error: Error;
+    operation: string;
+    context?: Record<string, any>;
+}
+export type PcoEvent = RequestStartEvent | RequestCompleteEvent | RequestErrorEvent | AuthSuccessEvent | AuthFailureEvent | AuthRefreshEvent | RateLimitEvent | RateAvailableEvent | CacheHitEvent | CacheMissEvent | CacheSetEvent | CacheInvalidateEvent | ErrorEvent;
+export type EventHandler<T extends PcoEvent = PcoEvent> = (event: T) => void | Promise<void>;
+export interface EventEmitter {
+    on<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
+    off<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
+    emit<T extends PcoEvent>(event: T): void;
+}

package/dist/types/events.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * v2.0.0 Event System Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });