@proveanything/smartlinks 1.0.65 → 1.1.1

package/README.md

@@ -128,6 +128,49 @@ const content = await ai.generateContent('collectionId', {
 console.log(content)
 ```
 
+### Analytics (Actions & Broadcasts)
+
+Track user actions and broadcast deliveries per collection. These endpoints live under admin and require valid auth (API key or bearer token).
+
+```ts
+import { actions, broadcasts } from '@proveanything/smartlinks'
+
+// List action events for a user
+const actionEvents = await actions.byUser('collectionId', {
+  userId: 'user_123',
+  from: '2025-01-01T00:00:00Z',
+  to: '2025-12-31T23:59:59Z',
+  limit: 100,
+})
+
+// Outcome counts, optionally deduping latest per actor
+const counts = await actions.countsByOutcome('collectionId', {
+  actionId: 'click',
+  dedupeLatest: true,
+  idField: 'userId',
+})
+
+// Append a single action event
+await actions.append('collectionId', {
+  userId: 'user_123',
+  actionId: 'click',
+  outcome: 'success',
+})
+
+// Broadcast recipients and filters
+const recipients = await broadcasts.recipientIds('collectionId', {
+  broadcastId: 'br_456',
+  idField: 'contactId',
+})
+
+// Append broadcast recipients in bulk (preferred shape)
+await broadcasts.appendBulk('collectionId', {
+  params: { broadcastId: 'br_456', channel: 'email' },
+  ids: ['contact_1','contact_2'],
+  idField: 'contactId',
+})
+```
+
 ## Browser and React
 
 The SDK works in modern browsers. Initialize once and call public endpoints without an API key; authenticate to access protected/admin endpoints.

package/dist/api/actions.d.ts

@@ -0,0 +1,32 @@
+import type { ActionQueryByUser, ActionCountsQuery, ActorIdsByActionQuery, AppendActionBody, OutcomeCount, ActorId, ActorWithOutcome, ActionEventRow, AdminByUserRequest, AdminCountsByOutcomeRequest, AdminActorIdsByActionRequest, PublicCountsByOutcomeRequest, PublicByUserRequest, CreateActionBody, UpdateActionBody, ListActionsQuery, ActionRecord, ActionList } from "../types/actions";
+export declare namespace actions {
+    /**
+     * POST /admin/collection/:collectionId/actions/by-user
+     * Returns BigQuery action rows, newest first.
+     */
+    function byUser(collectionId: string, query?: AdminByUserRequest | ActionQueryByUser): Promise<ActionEventRow[]>;
+    /**
+     * POST /admin/collection/:collectionId/actions/counts-by-outcome
+     * Returns array of { outcome, count }.
+     */
+    function countsByOutcome(collectionId: string, query?: AdminCountsByOutcomeRequest | ActionCountsQuery): Promise<OutcomeCount[]>;
+    /**
+     * POST /admin/collection/:collectionId/actions/actor-ids/by-action
+     * Returns list of IDs, optionally with outcome when includeOutcome=true.
+     */
+    function actorIdsByAction(collectionId: string, query: AdminActorIdsByActionRequest | ActorIdsByActionQuery): Promise<ActorId[] | ActorWithOutcome[]>;
+    /**
+     * POST /admin/collection/:collectionId/actions/append
+     * Appends one action event.
+     */
+    function append(collectionId: string, body: AppendActionBody): Promise<{
+        success: true;
+    }>;
+    function create(collectionId: string, body: CreateActionBody): Promise<ActionRecord>;
+    function list(collectionId: string, query?: ListActionsQuery): Promise<ActionList>;
+    function get(collectionId: string, id: string): Promise<ActionRecord>;
+    function update(collectionId: string, id: string, patchBody: UpdateActionBody): Promise<ActionRecord>;
+    function remove(collectionId: string, id: string): Promise<void>;
+    function publicCountsByOutcome(collectionId: string, body: PublicCountsByOutcomeRequest, authToken?: string): Promise<OutcomeCount[]>;
+    function publicMyActions(collectionId: string, body: PublicByUserRequest, authToken?: string): Promise<ActionEventRow[]>;
+}

package/dist/api/actions.js

@@ -0,0 +1,99 @@
+// src/api/actions.ts
+import { request, post, patch, del } from "../http";
+function encodeQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        if (typeof value === "boolean") {
+            search.set(key, value ? "true" : "false");
+        }
+        else {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}
+export var actions;
+(function (actions) {
+    /**
+     * POST /admin/collection/:collectionId/actions/by-user
+     * Returns BigQuery action rows, newest first.
+     */
+    async function byUser(collectionId, query = {}) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/by-user`;
+        return post(path, query);
+    }
+    actions.byUser = byUser;
+    /**
+     * POST /admin/collection/:collectionId/actions/counts-by-outcome
+     * Returns array of { outcome, count }.
+     */
+    async function countsByOutcome(collectionId, query = {}) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/counts-by-outcome`;
+        return post(path, query);
+    }
+    actions.countsByOutcome = countsByOutcome;
+    /**
+     * POST /admin/collection/:collectionId/actions/actor-ids/by-action
+     * Returns list of IDs, optionally with outcome when includeOutcome=true.
+     */
+    async function actorIdsByAction(collectionId, query) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/actor-ids/by-action`;
+        return post(path, query);
+    }
+    actions.actorIdsByAction = actorIdsByAction;
+    /**
+     * POST /admin/collection/:collectionId/actions/append
+     * Appends one action event.
+     */
+    async function append(collectionId, body) {
+        if (!body.userId && !body.contactId) {
+            throw new Error("AppendActionBody must include one of userId or contactId");
+        }
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/append`;
+        return post(path, body);
+    }
+    actions.append = append;
+    // CRUD: Actions (Postgres)
+    async function create(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/`;
+        return post(path, body);
+    }
+    actions.create = create;
+    async function list(collectionId, query = {}) {
+        const qs = encodeQuery(query);
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/${qs}`;
+        return request(path);
+    }
+    actions.list = list;
+    async function get(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/${encodeURIComponent(id)}`;
+        return request(path);
+    }
+    actions.get = get;
+    async function update(collectionId, id, patchBody) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/${encodeURIComponent(id)}`;
+        return patch(path, patchBody);
+    }
+    actions.update = update;
+    async function remove(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/actions/${encodeURIComponent(id)}`;
+        return del(path);
+    }
+    actions.remove = remove;
+    // Public endpoints (permission-aware)
+    async function publicCountsByOutcome(collectionId, body, authToken) {
+        const path = `/public/collection/${encodeURIComponent(collectionId)}/actions/counts-by-outcome`;
+        const headers = authToken ? { AUTHORIZATION: `Bearer ${authToken}` } : undefined;
+        return post(path, body, headers);
+    }
+    actions.publicCountsByOutcome = publicCountsByOutcome;
+    async function publicMyActions(collectionId, body, authToken) {
+        const path = `/public/collection/${encodeURIComponent(collectionId)}/actions/by-user`;
+        const headers = authToken ? { AUTHORIZATION: `Bearer ${authToken}` } : undefined;
+        return post(path, body, headers);
+    }
+    actions.publicMyActions = publicMyActions;
+})(actions || (actions = {}));

package/dist/api/broadcasts.d.ts

@@ -0,0 +1,8 @@
+import type { ListBroadcastsQuery, BroadcastRecord, BroadcastList } from "../types/broadcasts";
+export declare namespace broadcasts {
+    function create(collectionId: string, body: Omit<BroadcastRecord, 'id' | 'collectionId' | 'createdAt'>): Promise<BroadcastRecord>;
+    function list(collectionId: string, query?: ListBroadcastsQuery): Promise<BroadcastList>;
+    function get(collectionId: string, id: string): Promise<BroadcastRecord>;
+    function update(collectionId: string, id: string, body: Partial<Omit<BroadcastRecord, 'id' | 'collectionId' | 'createdAt'>>): Promise<BroadcastRecord>;
+    function remove(collectionId: string, id: string): Promise<void>;
+}

package/dist/api/broadcasts.js

@@ -0,0 +1,50 @@
+// src/api/broadcasts.ts
+import { request, post, patch, del } from "../http";
+function encodeQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        if (typeof value === "boolean") {
+            search.set(key, value ? "true" : "false");
+        }
+        else {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}
+export var broadcasts;
+(function (broadcasts) {
+    // CRUD: Create broadcast
+    async function create(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/broadcasts/`;
+        return post(path, body);
+    }
+    broadcasts.create = create;
+    // CRUD: List broadcasts (GET with query)
+    async function list(collectionId, query = {}) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/broadcasts/${encodeQuery(query)}`;
+        return request(path);
+    }
+    broadcasts.list = list;
+    // CRUD: Get a single broadcast
+    async function get(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/broadcasts/${encodeURIComponent(id)}`;
+        return request(path);
+    }
+    broadcasts.get = get;
+    // CRUD: Update a broadcast
+    async function update(collectionId, id, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/broadcasts/${encodeURIComponent(id)}`;
+        return patch(path, body);
+    }
+    broadcasts.update = update;
+    // CRUD: Delete a broadcast
+    async function remove(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/broadcasts/${encodeURIComponent(id)}`;
+        return del(path);
+    }
+    broadcasts.remove = remove;
+})(broadcasts || (broadcasts = {}));

package/dist/api/comms.d.ts

@@ -1,4 +1,4 @@
-import type { SendNotificationRequest, SendNotificationResponse } from "../types/comms";
+import type { SendNotificationRequest, SendNotificationResponse, CommunicationEvent, CommsQueryByUser, CommsRecipientIdsQuery, CommsRecipientsWithoutActionQuery, CommsRecipientsWithActionQuery, RecipientId, RecipientWithOutcome, LogCommunicationEventBody, LogBulkCommunicationEventsBody, AppendResult, AppendBulkResult } from "../types/comms";
 /**
  * Communications namespace for sending notifications and managing user communications
  */
@@ -44,4 +44,39 @@ export declare namespace comms {
      * ```
      */
     function sendNotification(collectionId: string, request: SendNotificationRequest): Promise<SendNotificationResponse>;
+    /**
+     * Analytics: Query communication events by user or contact.
+     * POST /admin/collection/:collectionId/comm/query/by-user
+     */
+    function queryByUser(collectionId: string, body?: CommsQueryByUser): Promise<CommunicationEvent[]>;
+    /**
+     * Analytics: Recipient IDs for a communication source.
+     * POST /admin/collection/:collectionId/comm/query/recipient-ids
+     */
+    function queryRecipientIds(collectionId: string, body: CommsRecipientIdsQuery): Promise<RecipientId[]>;
+    /**
+     * Analytics: Recipients who did not perform an action.
+     * POST /admin/collection/:collectionId/comm/query/recipients/without-action
+     */
+    function queryRecipientsWithoutAction(collectionId: string, body: CommsRecipientsWithoutActionQuery): Promise<RecipientId[]>;
+    /**
+     * Analytics: Recipients who performed an action, optionally with outcome.
+     * POST /admin/collection/:collectionId/comm/query/recipients/with-action
+     */
+    function queryRecipientsWithAction(collectionId: string, body: CommsRecipientsWithActionQuery): Promise<RecipientId[] | RecipientWithOutcome[]>;
+    /**
+     * Logging: Append a single communication event.
+     * POST /admin/collection/:collectionId/comm/log
+     */
+    function logCommunicationEvent(collectionId: string, body: LogCommunicationEventBody): Promise<AppendResult>;
+    /**
+     * Logging: Append many communication events for a list of IDs.
+     * POST /admin/collection/:collectionId/comm/log/bulk
+     */
+    function logBulkCommunicationEvents(collectionId: string, body: LogBulkCommunicationEventsBody | ({
+        sourceId: string;
+        ids: string[];
+        idField?: 'userId' | 'contactId';
+        [k: string]: any;
+    })): Promise<AppendBulkResult>;
 }

package/dist/api/comms.js

@@ -51,4 +51,58 @@ export var comms;
         return post(path, request);
     }
     comms.sendNotification = sendNotification;
+    /**
+     * Analytics: Query communication events by user or contact.
+     * POST /admin/collection/:collectionId/comm/query/by-user
+     */
+    async function queryByUser(collectionId, body = {}) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/comm/query/by-user`;
+        return post(path, body);
+    }
+    comms.queryByUser = queryByUser;
+    /**
+     * Analytics: Recipient IDs for a communication source.
+     * POST /admin/collection/:collectionId/comm/query/recipient-ids
+     */
+    async function queryRecipientIds(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/comm/query/recipient-ids`;
+        return post(path, body);
+    }
+    comms.queryRecipientIds = queryRecipientIds;
+    /**
+     * Analytics: Recipients who did not perform an action.
+     * POST /admin/collection/:collectionId/comm/query/recipients/without-action
+     */
+    async function queryRecipientsWithoutAction(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/comm/query/recipients/without-action`;
+        return post(path, body);
+    }
+    comms.queryRecipientsWithoutAction = queryRecipientsWithoutAction;
+    /**
+     * Analytics: Recipients who performed an action, optionally with outcome.
+     * POST /admin/collection/:collectionId/comm/query/recipients/with-action
+     */
+    async function queryRecipientsWithAction(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/comm/query/recipients/with-action`;
+        return post(path, body);
+    }
+    comms.queryRecipientsWithAction = queryRecipientsWithAction;
+    /**
+     * Logging: Append a single communication event.
+     * POST /admin/collection/:collectionId/comm/log
+     */
+    async function logCommunicationEvent(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/comm/log`;
+        return post(path, body);
+    }
+    comms.logCommunicationEvent = logCommunicationEvent;
+    /**
+     * Logging: Append many communication events for a list of IDs.
+     * POST /admin/collection/:collectionId/comm/log/bulk
+     */
+    async function logBulkCommunicationEvents(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/comm/log/bulk`;
+        return post(path, body);
+    }
+    comms.logBulkCommunicationEvents = logBulkCommunicationEvents;
 })(comms || (comms = {}));

package/dist/api/index.d.ts

@@ -16,4 +16,8 @@ export { ai } from "./ai";
 export { comms } from "./comms";
 export { nfc } from "./nfc";
 export { contact } from "./contact";
+export { actions } from "./actions";
+export { broadcasts } from "./broadcasts";
+export { segments } from "./segments";
+export { journeys } from "./journeys";
 export type { AIGenerateContentRequest, AIGenerateImageRequest, AISearchPhotosRequest, AISearchPhotosPhoto } from "./ai";

package/dist/api/index.js

@@ -18,3 +18,7 @@ export { ai } from "./ai";
 export { comms } from "./comms";
 export { nfc } from "./nfc";
 export { contact } from "./contact";
+export { actions } from "./actions";
+export { broadcasts } from "./broadcasts";
+export { segments } from "./segments";
+export { journeys } from "./journeys";

package/dist/api/journeys.d.ts

@@ -0,0 +1,8 @@
+import type { JourneyRecord, JourneyList, ListJourneysQuery, CreateJourneyBody, UpdateJourneyBody } from "../types/journeys";
+export declare namespace journeys {
+    function create(collectionId: string, body: CreateJourneyBody): Promise<JourneyRecord>;
+    function list(collectionId: string, query?: ListJourneysQuery): Promise<JourneyList>;
+    function get(collectionId: string, id: string): Promise<JourneyRecord>;
+    function update(collectionId: string, id: string, body: UpdateJourneyBody): Promise<JourneyRecord>;
+    function remove(collectionId: string, id: string): Promise<void>;
+}

package/dist/api/journeys.js

@@ -0,0 +1,48 @@
+// src/api/journeys.ts
+import { request, post, patch, del } from "../http";
+function encodeQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        if (typeof value === "boolean")
+            search.set(key, value ? "true" : "false");
+        else
+            search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}
+export var journeys;
+(function (journeys) {
+    // Create
+    async function create(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/journeys/`;
+        return post(path, body);
+    }
+    journeys.create = create;
+    // List
+    async function list(collectionId, query = {}) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/journeys/${encodeQuery(query)}`;
+        return request(path);
+    }
+    journeys.list = list;
+    // Get
+    async function get(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/journeys/${encodeURIComponent(id)}`;
+        return request(path);
+    }
+    journeys.get = get;
+    // Update
+    async function update(collectionId, id, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/journeys/${encodeURIComponent(id)}`;
+        return patch(path, body);
+    }
+    journeys.update = update;
+    // Delete
+    async function remove(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/journeys/${encodeURIComponent(id)}`;
+        return del(path);
+    }
+    journeys.remove = remove;
+})(journeys || (journeys = {}));

package/dist/api/segments.d.ts

@@ -0,0 +1,13 @@
+import type { SegmentRecord, ListSegmentsQuery, SegmentList, SegmentCalculateResult, SegmentRecipientsResponse } from "../types/segments";
+export declare namespace segments {
+    function create(collectionId: string, body: Omit<SegmentRecord, 'id' | 'collectionId' | 'createdAt'>): Promise<SegmentRecord>;
+    function list(collectionId: string, query?: ListSegmentsQuery): Promise<SegmentList>;
+    function get(collectionId: string, id: string): Promise<SegmentRecord>;
+    function update(collectionId: string, id: string, body: Partial<Omit<SegmentRecord, 'id' | 'collectionId' | 'createdAt'>>): Promise<SegmentRecord>;
+    function remove(collectionId: string, id: string): Promise<void>;
+    function calculate(collectionId: string, id: string): Promise<SegmentCalculateResult>;
+    function recipients(collectionId: string, id: string, query?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<SegmentRecipientsResponse>;
+}

package/dist/api/segments.js

@@ -0,0 +1,60 @@
+// src/api/segments.ts
+import { request, post, patch, del } from "../http";
+function encodeQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        if (typeof value === "boolean")
+            search.set(key, value ? "true" : "false");
+        else
+            search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}
+export var segments;
+(function (segments) {
+    // Create
+    async function create(collectionId, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/segments/`;
+        return post(path, body);
+    }
+    segments.create = create;
+    // List
+    async function list(collectionId, query = {}) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/segments/${encodeQuery(query)}`;
+        return request(path);
+    }
+    segments.list = list;
+    // Get
+    async function get(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/segments/${encodeURIComponent(id)}`;
+        return request(path);
+    }
+    segments.get = get;
+    // Update
+    async function update(collectionId, id, body) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/segments/${encodeURIComponent(id)}`;
+        return patch(path, body);
+    }
+    segments.update = update;
+    // Delete
+    async function remove(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/segments/${encodeURIComponent(id)}`;
+        return del(path);
+    }
+    segments.remove = remove;
+    // Stub: calculate
+    async function calculate(collectionId, id) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/segments/${encodeURIComponent(id)}/calculate`;
+        return post(path, {});
+    }
+    segments.calculate = calculate;
+    // Stub: recipients
+    async function recipients(collectionId, id, query = {}) {
+        const path = `/admin/collection/${encodeURIComponent(collectionId)}/segments/${encodeURIComponent(id)}/recipients${encodeQuery(query)}`;
+        return request(path);
+    }
+    segments.recipients = recipients;
+})(segments || (segments = {}));

package/dist/types/actions.d.ts

@@ -0,0 +1,120 @@
+import type { IdField } from './common';
+export interface AdminByUserRequest {
+    userId?: string;
+    contactId?: string;
+    appId?: string;
+    actionId?: string;
+    broadcastId?: string;
+    outcome?: string | null;
+    from?: string;
+    to?: string;
+    limit?: number;
+}
+export interface AdminCountsByOutcomeRequest {
+    appId?: string;
+    actionId?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    dedupeLatest?: boolean;
+    idField?: IdField;
+}
+export interface AdminActorIdsByActionRequest {
+    actionId: string;
+    idField?: IdField;
+    outcome?: string | null;
+    includeOutcome?: boolean;
+    from?: string;
+    to?: string;
+    limit?: number;
+}
+export interface PublicCountsByOutcomeRequest {
+    appId: string;
+    actionId: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+}
+export interface PublicByUserRequest {
+    appId: string;
+    actionId: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+}
+export interface ActionEventRow {
+    orgId: string;
+    timestamp: string;
+    appId?: string;
+    actionId?: string;
+    broadcastId?: string;
+    userId?: string;
+    contactId?: string;
+    outcome?: string | null;
+    [k: string]: unknown;
+}
+export interface OutcomeCount {
+    outcome: string | null;
+    count: number;
+}
+export type ActorId = string;
+export interface ActorWithOutcome {
+    id: string;
+    outcome: string | null;
+}
+export interface AppendActionBody {
+    userId?: string;
+    contactId?: string;
+    actionId: string;
+    appId?: string;
+    broadcastId?: string;
+    outcome?: string;
+    timestamp?: string;
+    [k: string]: any;
+}
+export interface ActionPermissions {
+    allowOwnRead?: boolean;
+    allowPublicSummary?: boolean;
+    allowAuthenticatedSummary?: boolean;
+}
+export interface ActionRecord {
+    id: string;
+    collectionId: string;
+    appId: string;
+    permissions?: ActionPermissions;
+    data?: {
+        display?: {
+            title?: string;
+            description?: string;
+            icon?: string;
+            color?: string;
+        };
+        actionType?: string;
+        [key: string]: unknown;
+    };
+    createdAt: string;
+}
+export interface ActionList {
+    items: ActionRecord[];
+    limit: number;
+    offset: number;
+}
+export interface CreateActionBody {
+    id: string;
+    appId: string;
+    permissions?: ActionPermissions;
+    data?: Record<string, unknown>;
+}
+export interface UpdateActionBody {
+    appId?: string;
+    permissions?: ActionPermissions;
+    data?: Record<string, unknown>;
+}
+export interface ListActionsQuery {
+    appId?: string;
+    limit?: number;
+    offset?: number;
+}
+export type ActionQueryByUser = AdminByUserRequest;
+export type ActionCountsQuery = AdminCountsByOutcomeRequest;
+export type ActorIdsByActionQuery = AdminActorIdsByActionRequest;

package/dist/types/actions.js

@@ -0,0 +1,2 @@
+// src/types/actions.ts
+export {};

package/dist/types/analytics.js

@@ -0,0 +1,3 @@
+"use strict";
+// Deprecated: types moved to ./actions.ts and ./broadcasts.ts
+// This file is intentionally left empty to avoid duplicate exports.

package/dist/types/broadcasts.d.ts

@@ -0,0 +1,31 @@
+export interface ListBroadcastsQuery {
+    limit?: number;
+    offset?: number;
+    appId?: string;
+}
+export interface BroadcastRecord {
+    id: string;
+    collectionId: string;
+    appId: string;
+    templateId?: string | null;
+    segmentId?: string | null;
+    status?: string | null;
+    scheduledAt?: string | null;
+    sentAt?: string | null;
+    data?: {
+        display?: {
+            title?: string;
+            description?: string;
+            icon?: string;
+            color?: string;
+        };
+        broadcastType?: string;
+        [key: string]: unknown;
+    };
+    createdAt: string;
+}
+export interface BroadcastList {
+    items: BroadcastRecord[];
+    limit: number;
+    offset: number;
+}

package/dist/types/broadcasts.js

@@ -0,0 +1,2 @@
+// src/types/broadcasts.ts
+export {};

package/dist/types/common.d.ts

@@ -0,0 +1 @@
+export type IdField = 'userId' | 'contactId';