@bubblelab/bubble-core 0.1.156 → 0.1.158

package/dist/bubbles/service-bubble/postgresql.d.ts

@@ -12,9 +12,9 @@ declare const PostgreSQLParamsSchema: z.ZodObject<{
     maxRows: z.ZodDefault<z.ZodNumber>;
     credentials: z.ZodOptional<z.ZodRecord<z.ZodNativeEnum<typeof CredentialType>, z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
+    query: string;
     timeout: number;
     ignoreSSL: boolean;
-    query: string;
     allowedOperations: ("SELECT" | "INSERT" | "UPDATE" | "DELETE" | "WITH" | "EXPLAIN" | "ANALYZE" | "SHOW" | "DESCRIBE" | "DESC" | "CREATE")[];
     parameters: unknown[];
     maxRows: number;
@@ -49,8 +49,8 @@ declare const PostgreSQLResultSchema: z.ZodObject<{
     error: z.ZodString;
     cleanedJSONString: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    error: string;
     success: boolean;
+    error: string;
     rows: Record<string, unknown>[];
     rowCount: number | null;
     command: string;
@@ -61,8 +61,8 @@ declare const PostgreSQLResultSchema: z.ZodObject<{
         dataTypeID: number;
     }[] | undefined;
 }, {
-    error: string;
     success: boolean;
+    error: string;
     rows: Record<string, unknown>[];
     rowCount: number | null;
     command: string;
@@ -89,9 +89,9 @@ export declare class PostgreSQLBubble extends ServiceBubble<PostgreSQLParams, Po
         maxRows: z.ZodDefault<z.ZodNumber>;
         credentials: z.ZodOptional<z.ZodRecord<z.ZodNativeEnum<typeof CredentialType>, z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
+        query: string;
         timeout: number;
         ignoreSSL: boolean;
-        query: string;
         allowedOperations: ("SELECT" | "INSERT" | "UPDATE" | "DELETE" | "WITH" | "EXPLAIN" | "ANALYZE" | "SHOW" | "DESCRIBE" | "DESC" | "CREATE")[];
         parameters: unknown[];
         maxRows: number;
@@ -124,8 +124,8 @@ export declare class PostgreSQLBubble extends ServiceBubble<PostgreSQLParams, Po
         error: z.ZodString;
         cleanedJSONString: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        error: string;
         success: boolean;
+        error: string;
         rows: Record<string, unknown>[];
         rowCount: number | null;
         command: string;
@@ -136,8 +136,8 @@ export declare class PostgreSQLBubble extends ServiceBubble<PostgreSQLParams, Po
             dataTypeID: number;
         }[] | undefined;
     }, {
-        error: string;
         success: boolean;
+        error: string;
         rows: Record<string, unknown>[];
         rowCount: number | null;
         command: string;

package/dist/bubbles/service-bubble/posthog/index.d.ts

@@ -0,0 +1,3 @@
+export { PosthogBubble } from './posthog.js';
+export { PosthogParamsSchema, PosthogResultSchema, PosthogEventSchema, PosthogPersonSchema, PosthogInsightSchema, PosthogQueryResultSchema, PosthogProjectSchema, type PosthogParams, type PosthogParamsInput, type PosthogResult, type PosthogEvent, type PosthogPerson, type PosthogInsight, type PosthogQueryResult, type PosthogProject, type PosthogListProjectsParams, type PosthogListEventsParams, type PosthogQueryParams, type PosthogGetPersonParams, type PosthogGetInsightParams, } from './posthog.schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/bubbles/service-bubble/posthog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/posthog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,GAC7B,MAAM,qBAAqB,CAAC"}

package/dist/bubbles/service-bubble/posthog/index.js

@@ -0,0 +1,3 @@
+export { PosthogBubble } from './posthog.js';
+export { PosthogParamsSchema, PosthogResultSchema, PosthogEventSchema, PosthogPersonSchema, PosthogInsightSchema, PosthogQueryResultSchema, PosthogProjectSchema, } from './posthog.schema.js';
+//# sourceMappingURL=index.js.map

package/dist/bubbles/service-bubble/posthog/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/posthog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,GAcrB,MAAM,qBAAqB,CAAC"}

package/dist/bubbles/service-bubble/posthog/posthog.d.ts

@@ -0,0 +1,469 @@
+import { CredentialType } from '@bubblelab/shared-schemas';
+import { ServiceBubble } from '../../../types/service-bubble-class.js';
+import type { BubbleContext } from '../../../types/bubble.js';
+import { type PosthogParamsInput, type PosthogResult } from './posthog.schema.js';
+/**
+ * PosthogBubble - Integration with PostHog product analytics
+ *
+ * Provides read operations for retrieving analytics data from PostHog:
+ * - List events with filtering by event type, person, and date range
+ * - Execute HogQL queries for custom analytics
+ * - Look up person profiles and properties
+ * - Retrieve saved insight results
+ *
+ * @example
+ * ```typescript
+ * // List recent pageview events
+ * const result = await new PosthogBubble({
+ *   operation: 'list_events',
+ *   project_id: '12345',
+ *   event: '$pageview',
+ *   limit: 50,
+ * }).action();
+ *
+ * // Execute a HogQL query
+ * const queryResult = await new PosthogBubble({
+ *   operation: 'query',
+ *   project_id: '12345',
+ *   query: 'SELECT event, count() FROM events GROUP BY event ORDER BY count() DESC LIMIT 10',
+ * }).action();
+ *
+ * // Look up a person by distinct ID
+ * const person = await new PosthogBubble({
+ *   operation: 'get_person',
+ *   project_id: '12345',
+ *   distinct_id: 'user_123',
+ * }).action();
+ * ```
+ */
+export declare class PosthogBubble<T extends PosthogParamsInput = PosthogParamsInput> extends ServiceBubble<T, Extract<PosthogResult, {
+    operation: T['operation'];
+}>> {
+    static readonly service = "posthog";
+    static readonly authType: "apikey";
+    static readonly bubbleName: "posthog";
+    static readonly type: "service";
+    static readonly schema: import("zod").ZodDiscriminatedUnion<"operation", [import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_projects">;
+        host: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        limit: number;
+        operation: "list_projects";
+        host: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "list_projects";
+        limit?: number | undefined;
+        host?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_events">;
+        project_id: import("zod").ZodString;
+        host: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        event: import("zod").ZodOptional<import("zod").ZodString>;
+        person_id: import("zod").ZodOptional<import("zod").ZodString>;
+        distinct_id: import("zod").ZodOptional<import("zod").ZodString>;
+        after: import("zod").ZodOptional<import("zod").ZodString>;
+        before: import("zod").ZodOptional<import("zod").ZodString>;
+        properties: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        limit: number;
+        operation: "list_events";
+        host: string;
+        project_id: string;
+        event?: string | undefined;
+        distinct_id?: string | undefined;
+        properties?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        person_id?: string | undefined;
+        after?: string | undefined;
+        before?: string | undefined;
+    }, {
+        operation: "list_events";
+        project_id: string;
+        event?: string | undefined;
+        distinct_id?: string | undefined;
+        properties?: string | undefined;
+        limit?: number | undefined;
+        host?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        person_id?: string | undefined;
+        after?: string | undefined;
+        before?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"query">;
+        project_id: import("zod").ZodString;
+        host: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        query: import("zod").ZodString;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "query";
+        host: string;
+        project_id: string;
+        query: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "query";
+        project_id: string;
+        query: string;
+        host?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_person">;
+        project_id: import("zod").ZodString;
+        host: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        distinct_id: import("zod").ZodOptional<import("zod").ZodString>;
+        search: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        limit: number;
+        operation: "get_person";
+        host: string;
+        project_id: string;
+        distinct_id?: string | undefined;
+        search?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "get_person";
+        project_id: string;
+        distinct_id?: string | undefined;
+        limit?: number | undefined;
+        search?: string | undefined;
+        host?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_insight">;
+        project_id: import("zod").ZodString;
+        host: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        insight_id: import("zod").ZodNumber;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "get_insight";
+        host: string;
+        project_id: string;
+        insight_id: number;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "get_insight";
+        project_id: string;
+        insight_id: number;
+        host?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>]>;
+    static readonly resultSchema: import("zod").ZodDiscriminatedUnion<"operation", [import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_projects">;
+        success: import("zod").ZodBoolean;
+        projects: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodNumber;
+            uuid: import("zod").ZodOptional<import("zod").ZodString>;
+            name: import("zod").ZodString;
+            organization: import("zod").ZodOptional<import("zod").ZodString>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+            timezone: import("zod").ZodOptional<import("zod").ZodString>;
+            is_demo: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: number;
+            name: string;
+            uuid?: string | undefined;
+            created_at?: string | undefined;
+            organization?: string | undefined;
+            timezone?: string | undefined;
+            is_demo?: boolean | undefined;
+        }, {
+            id: number;
+            name: string;
+            uuid?: string | undefined;
+            created_at?: string | undefined;
+            organization?: string | undefined;
+            timezone?: string | undefined;
+            is_demo?: boolean | undefined;
+        }>, "many">>;
+        next: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "list_projects";
+        success: boolean;
+        error: string;
+        projects?: {
+            id: number;
+            name: string;
+            uuid?: string | undefined;
+            created_at?: string | undefined;
+            organization?: string | undefined;
+            timezone?: string | undefined;
+            is_demo?: boolean | undefined;
+        }[] | undefined;
+        next?: string | null | undefined;
+    }, {
+        operation: "list_projects";
+        success: boolean;
+        error: string;
+        projects?: {
+            id: number;
+            name: string;
+            uuid?: string | undefined;
+            created_at?: string | undefined;
+            organization?: string | undefined;
+            timezone?: string | undefined;
+            is_demo?: boolean | undefined;
+        }[] | undefined;
+        next?: string | null | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_events">;
+        success: import("zod").ZodBoolean;
+        events: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            uuid: import("zod").ZodOptional<import("zod").ZodString>;
+            event: import("zod").ZodString;
+            distinct_id: import("zod").ZodString;
+            properties: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            timestamp: import("zod").ZodOptional<import("zod").ZodString>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+            elements: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown, "many">>;
+            elements_chain: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            event: string;
+            distinct_id: string;
+            id?: string | undefined;
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            timestamp?: string | undefined;
+            created_at?: string | undefined;
+            elements?: unknown[] | undefined;
+            elements_chain?: string | undefined;
+        }, {
+            event: string;
+            distinct_id: string;
+            id?: string | undefined;
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            timestamp?: string | undefined;
+            created_at?: string | undefined;
+            elements?: unknown[] | undefined;
+            elements_chain?: string | undefined;
+        }>, "many">>;
+        next: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "list_events";
+        success: boolean;
+        error: string;
+        next?: string | null | undefined;
+        events?: {
+            event: string;
+            distinct_id: string;
+            id?: string | undefined;
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            timestamp?: string | undefined;
+            created_at?: string | undefined;
+            elements?: unknown[] | undefined;
+            elements_chain?: string | undefined;
+        }[] | undefined;
+    }, {
+        operation: "list_events";
+        success: boolean;
+        error: string;
+        next?: string | null | undefined;
+        events?: {
+            event: string;
+            distinct_id: string;
+            id?: string | undefined;
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            timestamp?: string | undefined;
+            created_at?: string | undefined;
+            elements?: unknown[] | undefined;
+            elements_chain?: string | undefined;
+        }[] | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"query">;
+        success: import("zod").ZodBoolean;
+        columns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        results: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodUnknown, "many">, "many">>;
+        types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>, "many">>;
+        hasMore: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "query";
+        success: boolean;
+        error: string;
+        columns?: string[] | undefined;
+        results?: unknown[][] | undefined;
+        types?: (string | string[])[] | undefined;
+        hasMore?: boolean | null | undefined;
+    }, {
+        operation: "query";
+        success: boolean;
+        error: string;
+        columns?: string[] | undefined;
+        results?: unknown[][] | undefined;
+        types?: (string | string[])[] | undefined;
+        hasMore?: boolean | null | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_person">;
+        success: import("zod").ZodBoolean;
+        persons: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            uuid: import("zod").ZodOptional<import("zod").ZodString>;
+            distinct_ids: import("zod").ZodArray<import("zod").ZodString, "many">;
+            properties: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            distinct_ids: string[];
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            created_at?: string | undefined;
+        }, {
+            id: string;
+            distinct_ids: string[];
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            created_at?: string | undefined;
+        }>, "many">>;
+        next: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "get_person";
+        success: boolean;
+        error: string;
+        next?: string | null | undefined;
+        persons?: {
+            id: string;
+            distinct_ids: string[];
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            created_at?: string | undefined;
+        }[] | undefined;
+    }, {
+        operation: "get_person";
+        success: boolean;
+        error: string;
+        next?: string | null | undefined;
+        persons?: {
+            id: string;
+            distinct_ids: string[];
+            uuid?: string | undefined;
+            properties?: Record<string, unknown> | undefined;
+            created_at?: string | undefined;
+        }[] | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_insight">;
+        success: import("zod").ZodBoolean;
+        insight: import("zod").ZodOptional<import("zod").ZodObject<{
+            id: import("zod").ZodNumber;
+            short_id: import("zod").ZodOptional<import("zod").ZodString>;
+            name: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+            description: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+            result: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            filters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+            last_refresh: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+            last_modified_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: number;
+            description?: string | null | undefined;
+            created_at?: string | undefined;
+            short_id?: string | undefined;
+            name?: string | null | undefined;
+            result?: unknown;
+            filters?: Record<string, unknown> | undefined;
+            last_refresh?: string | null | undefined;
+            last_modified_at?: string | undefined;
+        }, {
+            id: number;
+            description?: string | null | undefined;
+            created_at?: string | undefined;
+            short_id?: string | undefined;
+            name?: string | null | undefined;
+            result?: unknown;
+            filters?: Record<string, unknown> | undefined;
+            last_refresh?: string | null | undefined;
+            last_modified_at?: string | undefined;
+        }>>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "get_insight";
+        success: boolean;
+        error: string;
+        insight?: {
+            id: number;
+            description?: string | null | undefined;
+            created_at?: string | undefined;
+            short_id?: string | undefined;
+            name?: string | null | undefined;
+            result?: unknown;
+            filters?: Record<string, unknown> | undefined;
+            last_refresh?: string | null | undefined;
+            last_modified_at?: string | undefined;
+        } | undefined;
+    }, {
+        operation: "get_insight";
+        success: boolean;
+        error: string;
+        insight?: {
+            id: number;
+            description?: string | null | undefined;
+            created_at?: string | undefined;
+            short_id?: string | undefined;
+            name?: string | null | undefined;
+            result?: unknown;
+            filters?: Record<string, unknown> | undefined;
+            last_refresh?: string | null | undefined;
+            last_modified_at?: string | undefined;
+        } | undefined;
+    }>]>;
+    static readonly shortDescription = "PostHog product analytics for events, persons, and insights";
+    static readonly longDescription = "\n    PostHog is an open-source product analytics platform.\n    This bubble provides read operations for retrieving analytics data:\n    - List and filter captured events (pageviews, custom events, etc.)\n    - Execute HogQL queries for advanced custom analytics\n    - Look up person profiles and their properties\n    - Retrieve saved insight results\n\n    Authentication:\n    - Uses a Personal API Key via Bearer token\n    - Supports US Cloud, EU Cloud, and self-hosted instances via configurable host URL\n\n    Use Cases:\n    - Pull analytics data into automated workflows\n    - Query event data with HogQL for custom reports\n    - Look up user profiles and their properties\n    - Retrieve computed insight results for dashboards\n  ";
+    static readonly alias = "posthog-analytics";
+    constructor(params?: T, context?: BubbleContext);
+    /**
+     * Choose the appropriate credential for PostHog API
+     */
+    protected chooseCredential(): string | undefined;
+    /**
+     * Test if the credential is valid by listing projects
+     */
+    testCredential(): Promise<boolean>;
+    /**
+     * Perform the PostHog operation
+     */
+    protected performAction(context?: BubbleContext): Promise<Extract<PosthogResult, {
+        operation: T['operation'];
+    }>>;
+    /**
+     * Make an authenticated GET request to the PostHog API
+     */
+    private makePosthogGetRequest;
+    /**
+     * Make an authenticated POST request to the PostHog API
+     */
+    private makePosthogPostRequest;
+    /**
+     * List all projects accessible with the API key
+     */
+    private listProjects;
+    /**
+     * List events with optional filtering
+     */
+    private listEvents;
+    /**
+     * Execute a HogQL query
+     */
+    private executeQuery;
+    /**
+     * Get person profiles
+     */
+    private getPerson;
+    /**
+     * Get a saved insight's results
+     */
+    private getInsight;
+}
+//# sourceMappingURL=posthog.d.ts.map

package/dist/bubbles/service-bubble/posthog/posthog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posthog.d.ts","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/posthog/posthog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAMnB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,aAAa,CACxB,CAAC,SAAS,kBAAkB,GAAG,kBAAkB,CACjD,SAAQ,aAAa,CACrB,CAAC,EACD,OAAO,CAAC,aAAa,EAAE;IAAE,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,CAAA;CAAE,CAAC,CACtD;IAEC,MAAM,CAAC,QAAQ,CAAC,OAAO,aAAa;IACpC,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAG,QAAQ,CAAU;IAC7C,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAG,SAAS,CAAU;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAU;IAC1C,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAuB;IAC7C,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAuB;IACnD,MAAM,CAAC,QAAQ,CAAC,gBAAgB,iEACgC;IAChE,MAAM,CAAC,QAAQ,CAAC,eAAe,gvBAiB7B;IACF,MAAM,CAAC,QAAQ,CAAC,KAAK,uBAAuB;gBAG1C,MAAM,GAAE,CAIF,EACN,OAAO,CAAC,EAAE,aAAa;IAKzB;;OAEG;IACH,SAAS,CAAC,gBAAgB,IAAI,MAAM,GAAG,SAAS;IAShD;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IAyBxC;;OAEG;cACa,aAAa,CAC3B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE;QAAE,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,CAAA;KAAE,CAAC,CAAC;IA+CjE;;OAEG;YACW,qBAAqB;IA2CnC;;OAEG;YACW,sBAAsB;IAmCpC;;OAEG;YACW,YAAY;IAyB1B;;OAEG;YACW,UAAU;IA+BxB;;OAEG;YACW,YAAY;IA8B1B;;OAEG;YACW,SAAS;IA2BvB;;OAEG;YACW,UAAU;CAkBzB"}