@hailer/app-sdk 2.0.0-beta-7 → 2.0.0-beta-9

package/lib/modules/admin.d.ts

@@ -0,0 +1,146 @@
+import { Client } from '@wishcore/wish-rpc';
+import { AdminWorkspaceListRequest, AdminWorkspaceListResponse, AdminWorkspace, AdminCreateStripeSessionRequest, AdminCreateStripeSessionResponse, AdminCreateInvoiceIntegrationRequest, AdminCreateInvoiceIntegrationResponse, AdminUpdateWorkspaceSubscriptionRequest, AdminUpdatePurchasePriceRequest, AdminWorkspaceUsersListRequest, AdminWorkspaceUsersListResponse, AdminUpdateUserRequest, AdminTokenTransactionsListRequest, AdminTokenTransactionsListResponse, AdminUpdateOverridesRequest, AdminUpdateMarketplaceSettingsRequest, AdminInvoiceListRequest, AdminInvoiceListResponse, AdminInvoiceUpdateHandledRequest, AdminInvoiceUpdateHandledResponse, AdminRevenueListRequest, AdminRevenueListResponse } from '../types';
+export declare class Admin {
+    private client;
+    constructor(client: Client);
+    /**
+     * Lists workspaces with search, pagination, and sorting
+     *
+     * @param request AdminWorkspaceListRequest containing filter and options
+     *
+     * @returns List of workspaces with total count
+     *
+     * @throws {HailerError} if request fails or user not authorized
+     */
+    listWorkspaces(request?: AdminWorkspaceListRequest): Promise<AdminWorkspaceListResponse>;
+    /**
+     * Gets detailed information about a specific workspace
+     *
+     * @param workspaceId The ID of the workspace to retrieve
+     *
+     * @returns Workspace details including payment information
+     *
+     * @throws {HailerError} if request fails, workspace not found, or user not authorized
+     */
+    getWorkspace(workspaceId: string): Promise<AdminWorkspace>;
+    /**
+     * Creates a Stripe checkout session for workspace subscription
+     *
+     * @param request AdminCreateStripeSessionRequest containing workspace details and payment info
+     *
+     * @returns AdminCreateStripeSessionResponse with success status and session URL
+     *
+     * @throws {HailerError} if request fails, user not authorized, or workspace already has subscription
+     */
+    createStripeSession(request: AdminCreateStripeSessionRequest): Promise<AdminCreateStripeSessionResponse>;
+    /**
+     * Creates an invoice integration for workspace subscription
+     *
+     * @param request AdminCreateInvoiceIntegrationRequest containing workspace details and payment info
+     *
+     * @returns AdminCreateInvoiceIntegrationResponse with success status
+     *
+     * @throws {HailerError} if request fails, user not authorized, or workspace already has subscription
+     */
+    createInvoiceIntegration(request: AdminCreateInvoiceIntegrationRequest): Promise<AdminCreateInvoiceIntegrationResponse>;
+    /**
+     * Updates workspace subscription billing information
+     *
+     * @param request AdminUpdateWorkspaceSubscriptionRequest containing purchase ID and new billing details
+     *
+     * @returns boolean indicating whether the update was successful
+     *
+     * @throws {HailerError} if request fails, user not authorized, or purchase not found
+     */
+    updateWorkspaceSubscription(request: AdminUpdateWorkspaceSubscriptionRequest): Promise<boolean>;
+    /**
+     * Updates purchase price for active invoice products
+     *
+     * @param request AdminUpdatePurchasePriceRequest containing purchase ID, workspace ID, and new price
+     *
+     * @returns boolean indicating whether the update was successful
+     *
+     * @throws {HailerError} if request fails, user not authorized, purchase not found, or not an invoice product
+     */
+    updatePurchasePrice(request: AdminUpdatePurchasePriceRequest): Promise<boolean>;
+    /**
+     * Lists users in a workspace with search, filtering, pagination, and sorting
+     * If no workspaceId provided, lists all users across all workspaces
+     *
+     * @param request AdminWorkspaceUsersListRequest containing optional workspace ID, filter and options
+     *
+     * @returns List of workspace users with total count and role information
+     *
+     * @throws {HailerError} if request fails, workspace not found, or user not authorized
+     */
+    listWorkspaceUsers(request: AdminWorkspaceUsersListRequest): Promise<AdminWorkspaceUsersListResponse>;
+    /**
+     * Updates a user's information (currently supports email verification only)
+     *
+     * @param request AdminUpdateUserRequest containing user ID and updates
+     *
+     * @returns boolean indicating success
+     *
+     * @throws {HailerError} if request fails, user not found, or user not authorized
+     */
+    updateUser(request: AdminUpdateUserRequest): Promise<boolean>;
+    /**
+     * Updates workspace token balance
+     *
+     * @param request Object containing workspaceId, tokenAmount, and optional payout parameters
+     *
+     * @returns boolean indicating success
+     *
+     * @throws {HailerError} if request fails, workspace not found, or user not authorized
+     */
+    updateTokenBalance(request: {
+        workspaceId: string;
+        tokenAmount: number;
+        payoutMonth?: number;
+        payoutYear?: number;
+        payoutType?: 'admin_bonus' | 'creator_payout';
+        creatorPercent?: number;
+    }): Promise<boolean>;
+    /**
+     * Updates workspace license overrides
+     *
+     * @param request AdminUpdateOverridesRequest containing workspaceId and overrides object
+     *
+     * @returns boolean indicating success
+     *
+     * @throws {HailerError} if request fails, workspace not found, or user not authorized
+     */
+    updateWorkspaceOverrides(request: AdminUpdateOverridesRequest): Promise<boolean>;
+    updateWorkspaceMarketplaceSettings(request: AdminUpdateMarketplaceSettingsRequest): Promise<boolean>;
+    /**
+     * Lists token transactions with filtering, pagination, and statistics
+     *
+     * @param request AdminTokenTransactionsListRequest containing optional filter and pagination options
+     *
+     * @returns AdminTokenTransactionsListResponse with transactions, total count, and statistics
+     *
+     * @throws {HailerError} if request fails or user not authorized
+     */
+    listTokenTransactions(request?: AdminTokenTransactionsListRequest): Promise<AdminTokenTransactionsListResponse>;
+    /**
+     * Lists Hailer invoice purchases with filtering, pagination, and workspace grouping
+     *
+     * @param request AdminInvoiceListRequest containing optional filter and pagination options
+     *
+     * @returns AdminInvoiceListResponse with invoices, total count, and workspace groups
+     *
+     * @throws {HailerError} if request fails or user not authorized
+     */
+    listInvoices(request?: AdminInvoiceListRequest): Promise<AdminInvoiceListResponse>;
+    /**
+     * Updates the handled status for one or more Hailer invoice purchases
+     *
+     * @param request AdminInvoiceUpdateHandledRequest containing purchase ID(s) and handled status
+     *
+     * @returns AdminInvoiceUpdateHandledResponse with count of updated records
+     *
+     * @throws {HailerError} if request fails, purchase not found, or not a Hailer invoice purchase
+     */
+    updateInvoiceHandled(request: AdminInvoiceUpdateHandledRequest): Promise<AdminInvoiceUpdateHandledResponse>;
+    listMonthlyRevenue(request: AdminRevenueListRequest): Promise<AdminRevenueListResponse>;
+}

package/lib/modules/metrics.d.ts

@@ -0,0 +1,61 @@
+import { Client } from '@wishcore/wish-rpc';
+export interface MetricDefinition {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    supportsTimeRange: boolean;
+    supportsBreakdown: boolean;
+}
+export interface MetricData {
+    metricType: string;
+    timestamp: number;
+    current: {
+        value: number;
+        labels?: any;
+    };
+    timeSeries?: Array<{
+        timestamp: number;
+        value: number;
+    }>;
+    breakdown?: {
+        byWorkspace?: Record<string, number>;
+        byUser?: Record<string, number>;
+    };
+    metadata: {
+        scope?: any;
+        permissions?: any;
+        source: string;
+        executionTime?: number;
+    };
+}
+export interface MetricOptions {
+    workspaceId?: string;
+    userId?: string;
+    timeRange?: {
+        start: number;
+        end: number;
+    };
+    interval?: '1m' | '5m' | '15m' | '1h';
+}
+export interface MetricListOptions {
+    category?: string;
+    includeDetails?: boolean;
+}
+export declare class MetricsApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Get list of available metrics for current user based on permissions
+     * @param options Optional filtering options
+     * @returns Array of metric IDs or detailed metric definitions
+     */
+    list(options?: MetricListOptions): Promise<string[] | MetricDefinition[]>;
+    /**
+     * Get current metrics data for single metric
+     * @param metricType The metric type to fetch
+     * @param options Optional filtering and time range options
+     * @returns Single metric data
+     */
+    get(metricTypes: string[], options?: MetricOptions): Promise<MetricData>;
+}

package/lib/modules/network.d.ts

@@ -0,0 +1,14 @@
+import { Client } from '@wishcore/wish-rpc';
+import { Workspace } from '../types';
+export declare class WorkspaceApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Returns the current network
+     *
+     * @returns the Hailer Workspace information the user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    current(): Promise<Workspace>;
+}

package/lib/modules/payment.d.ts

@@ -0,0 +1,66 @@
+import { Client } from '@wishcore/wish-rpc';
+import { PricingData, CreatePricingRequest, UpdatePricingRequest, CreatePurchaseRequest, CreatePurchaseResponse, Purchase, StripeTaxCalculationRequest, StripeTaxCalculationResponse } from '../types';
+export declare class Payment {
+    private client;
+    constructor(client: Client);
+    /**
+     * Creates pricing configuration for a product
+     *
+     * @param request CreatePricingRequest containing productId, types, and providers
+     *
+     * @returns Created pricing configuration
+     *
+     * @throws {HailerError} if request is incorrect or product not found
+     */
+    createPricing(request: CreatePricingRequest): Promise<PricingData>;
+    /**
+     * Updates pricing configuration for a product
+     *
+     * @param request UpdatePricingRequest containing productId, types, and providers
+     *
+     * @returns Updated pricing configuration
+     *
+     * @throws {HailerError} if request is incorrect, product not found, or pricing doesn't exist
+     */
+    updatePricing(request: UpdatePricingRequest): Promise<PricingData>;
+    /**
+     * Gets pricing configuration for a product
+     *
+     * @param productId Product ID to get pricing for
+     *
+     * @returns Pricing configuration or null if not found
+     *
+     * @throws {HailerError} if request is incorrect or product not found
+     */
+    getPricing(productId: string): Promise<PricingData | null>;
+    /**
+     * Creates a product purchase/subscription
+     *
+     * @param request CreatePurchaseRequest containing productId, workspaceId, and planType
+     *
+     * @returns Purchase creation result with status and details
+     *
+     * @throws {HailerError} if request is incorrect, product not found, or payment fails
+     */
+    createPurchase(request: CreatePurchaseRequest): Promise<CreatePurchaseResponse>;
+    /**
+     * Gets purchases for a workspace
+     *
+     * @param workspaceId Workspace ID to get purchases for
+     *
+     * @returns Array of purchases for the workspace
+     *
+     * @throws {HailerError} if request is incorrect or workspace not found
+     */
+    getPurchases(workspaceId: string): Promise<Purchase[]>;
+    /**
+     * Calculates Stripe tax for line items
+     *
+     * @param request StripeTaxCalculationRequest containing workspaceId and lineItems
+     *
+     * @returns Tax calculation result with amounts, rates, and country information
+     *
+     * @throws {HailerError} if request is incorrect, workspace not found, or Stripe customer not found
+     */
+    calculateStripeTax(request: StripeTaxCalculationRequest): Promise<StripeTaxCalculationResponse>;
+}

package/lib/modules/public/version.d.ts

@@ -0,0 +1,16 @@
+import { Options } from '../../hailer-api';
+import { Version } from '../../types';
+export declare class VersionPublicApi {
+    private options;
+    constructor(options: Options);
+    /**
+     * Gets single version from Hailer market
+     *
+     * @param id Version Id
+     *
+     * @returns Single version from Hailer market or undefined if no version found
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(id: string): Promise<Version | undefined>;
+}

package/lib/modules/version.d.ts

@@ -0,0 +1,16 @@
+import { Client } from '@wishcore/wish-rpc';
+import { Version } from '../types';
+export declare class VersionApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Gets single version from Hailer market
+     *
+     * @param id Version Id
+     *
+     * @returns Single version from Hailer market or undefined if no version found
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(id: string): Promise<Version | undefined>;
+}

package/lib/modules/workspace.d.ts

@@ -13,7 +13,7 @@ export declare class WorkspaceApi {
             description: string;
         }) => Promise<ProductVersion>;
         /** Check if product is installed */
-        isProductInstalled(id: string): Promise<boolean>;
+        isProductInstalled(id: string, workspaceId: string): Promise<boolean>;
         /** Get version */
         get(id: string): Promise<ProductVersion | undefined>;
         /** Install template from Hailer market */

package/lib/src/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_API_VERSION = 1;
+export declare const DEFAULT_ALLOWED_URLS: string[];
+export declare const DEFAULT_BACKEND_URL = "https://api.hailer.com";
+/** Map of which backend to use depending on which frontend is hosting the app frame, be sure to fall back to production backend if no match */
+export declare const publicBackendMap: {
+    [host: string]: string;
+};

package/lib/src/hailer-api.d.ts

@@ -0,0 +1,92 @@
+import { UserApi } from './modules/user';
+import { ActivityApi } from './modules/activity';
+import { WorkspaceApi } from './modules/network';
+import { HailerApiInfo, HailerSettings, HailerSignal } from './types';
+import { Ui } from './modules/ui';
+import { Process } from './modules/process';
+import { HailerPublicApi } from './modules/public';
+import { WorkflowApi } from './modules/workflow';
+import { AppApi } from './modules/app';
+import { InsightApi } from './modules/insight';
+import { PermissionApi } from './modules/permission';
+import { ProductApi } from './modules/product';
+import { ProductVersionApi } from './modules/product-version';
+import { ProductInstalledApi } from './modules/product-installed';
+export interface Options {
+    /** When connected is called the host is ready to receive calls */
+    connected?: () => void;
+    /** Callback when app is determined to be outside of Hailer, as a standalone app */
+    outside?: (config?: any) => void;
+    /** Callback on errors, defaults to printing errors in console */
+    error?: (error: Error) => void;
+    /** Callback called on app init and when permissions have changed */
+    permissions?: () => void;
+    /** Callback called on app init and when settings have changed */
+    settings?: (data: HailerSettings) => void;
+    /** Callback called on app init and when config has changed */
+    config?: (config: any) => void;
+    /** Will be called each time a subscribed signal is emitted from Hailer frontend. To subscribe to signals, add them to options.subscribedSignals[] */
+    signals?: (signal: HailerSignal) => void;
+    /** Urls the sdk is allowed to connect to. Defaults to all Hailer instances*/
+    allowedUrls?: string[];
+    /**
+     * Optional signal filter, passes all signals by default
+     *
+     * Example:
+     *
+     *     subscribedSignals: ['activity.create', 'activity.update']
+     */
+    subscribedSignals?: string[];
+    /** Api version to be used in the app by default */
+    apiVersion?: 1;
+    /** Public backend Api url. Defaults to https://api.hailer.com */
+    publicBackendUrl?: string;
+}
+export declare class HailerApi {
+    options: Options;
+    user: UserApi;
+    app: AppApi;
+    activity: ActivityApi;
+    insight: InsightApi;
+    network: WorkspaceApi;
+    process: Process;
+    workflow: WorkflowApi;
+    permission: PermissionApi;
+    product: ProductApi;
+    productVersion: ProductVersionApi;
+    productInstalled: ProductInstalledApi;
+    /** All public endpoints, which can be accessed while not logged in to Hailer. */
+    public: HailerPublicApi;
+    /** User interface commands */
+    ui: Ui;
+    /** Url of the Hailer instance hosting the API */
+    private hostUrl?;
+    private appId?;
+    /** If set it indicates that app is locked to a specific workspaceId */
+    private workspaceId?;
+    private client;
+    private apiVersion;
+    private settings?;
+    private config?;
+    private subscribedSignals?;
+    private timer?;
+    /**
+     * Hailer API state
+     *
+     * ```
+     * true // outside hailer
+     * false // logged into hailer
+     * null // state not yet detected
+     * ```
+     */
+    private outside;
+    /**
+     * Create a Hailer API client for inteacting with Hailer. **NOTE** This only works when inside Hailer.
+     *
+     * This should be run after window is initialized for example in ***onMount*** in Svelte or in ***useEffect*** in React
+     */
+    constructor(options?: Options);
+    private createEventListener;
+    info(): HailerApiInfo;
+    request(op: string, args: any[]): Promise<any>;
+}

package/lib/src/index.d.ts

@@ -0,0 +1,2 @@
+export { HailerApi } from './hailer-api';
+export * from './types';

package/lib/src/modules/activity/kanban.d.ts

@@ -0,0 +1,36 @@
+import { Client } from '@wishcore/wish-rpc';
+import { ActivityKanbanListOptions, KanbanListResponse, KanbanLoadResponse } from '../../types';
+export declare class Kanban {
+    private client;
+    constructor(client: Client);
+    /**
+     * Lists all activities in a kanban grouped by phases
+     *
+     * @param processId the id of the process the kanban relates to
+     * @param options ActivityKanbanListOptions
+     *
+     * @returns activities in kanban list format
+     *
+     * @throws {HailerError} if request fails
+     */
+    list(processId: string, options?: ActivityKanbanListOptions): Promise<KanbanListResponse>;
+    /**
+     * Loads a single activity in kanban format
+     *
+     * @param activityId activityId of the wanted activity
+     *
+     * @returns activity in kanban format
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    load(activityId: string): Promise<KanbanLoadResponse>;
+    /**
+     * Updates priority of activities in kanban
+     *
+     * @param activityId activityId of the wanted activity
+     * @param priority new priority for the activity
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    updatePriority(activityId: string, priority: number): Promise<void>;
+}

package/lib/src/modules/activity.d.ts

@@ -0,0 +1,83 @@
+import { Client } from '@wishcore/wish-rpc';
+import { ActivityCreateOptions, ActivityListOptions, Activity } from '../types';
+import { Kanban } from './activity/kanban';
+export declare class ActivityApi {
+    private client;
+    kanban: Kanban;
+    constructor(client: Client);
+    /**
+     * Lists all activities from the specified process and phase
+     *
+     * @param processId process from current network
+     * @param phaseId phase in the process specified in processId
+     * @param options ActivityListOptions
+     *
+     * @returns List of Hailer activities from process and phase filtered with supplied options
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list(processId: string, phaseId: string, options?: ActivityListOptions): Promise<Activity[]>;
+    /**
+     * Gets single activity
+     *
+     * @param activityId activity Id of the process specified in processId
+     * @param processId Process where the activityId is
+     * @param phaseId Phase where the activityId is in process specified by processId
+     * @param options options containing apiVersion
+     *
+     * @returns Hailer activity information or undefined if no activity is found
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(activityId: string): Promise<Activity | undefined>;
+    /**
+     * Creates activities
+     *
+     * @param processId The process where the activity is created
+     * @param activities new activities as objects
+     * @param activities.name name of the activity
+     * @param activities.fields fields of the activity
+     * @param options ActivityCreateOptions
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    create(processId: string, activities: {
+        name: string;
+        fields?: {
+            [id: string]: string | number;
+        };
+    }[], options?: ActivityCreateOptions): Promise<Activity[]>;
+    /**
+     * Updates activites
+     *
+     * Each activity has the following parameters
+     * @param activities updated activity objects of an activity to edit
+     * @param activities.name New name of the activity
+     * @param activities.fields change values of fields, null removes current value
+     * @param activities.phaseId New phase of the activity
+     * @param options
+     *
+     * @returns The number of updated activities
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    update(activities: {
+        _id: string;
+        name?: string;
+        fields?: {
+            [id: string]: string | number | null;
+        };
+        phaseId?: string;
+    }[], options: any): Promise<number>;
+    /**
+     * Removes activities
+     *
+     * @param activities Ids of activities to be removed
+     * @param options options containing apiVersion
+     *
+     * @returns The number of removed activities
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    remove(activities: string[]): Promise<number>;
+}

package/lib/src/modules/app.d.ts

@@ -0,0 +1,12 @@
+import { Client } from '@wishcore/wish-rpc';
+import { HailerAppConfig } from '../types';
+/**
+ * This class is used to access Hailer public API even when the app is outside of Hailer
+ */
+export declare class AppApi {
+    private client;
+    constructor(client: Client);
+    config: {
+        update: (appId: string | undefined, config: HailerAppConfig) => Promise<void>;
+    };
+}

package/lib/src/modules/insight.d.ts

@@ -0,0 +1,36 @@
+import { Client } from '@wishcore/wish-rpc';
+import { InsightData, InsightDoc } from '../types';
+export declare class InsightApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Get Insight data
+     *
+     * @param insightId the id of the Insight the data is fetched from
+     *
+     * @returns data from the Insight
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    data(insightId: string, options: {
+        update?: true;
+    }): Promise<InsightData>;
+    /**
+     * Get Insight data
+     *
+     *
+     * @returns data from the Insight
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list(): Promise<InsightDoc[]>;
+    /**
+     * Get Insight data
+     *
+     *
+     * @returns data from the Insight
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    update(insightId: string, update: Partial<InsightDoc>): Promise<InsightDoc[]>;
+}

package/lib/src/modules/network.d.ts

@@ -0,0 +1,14 @@
+import { Client } from '@wishcore/wish-rpc';
+import { Workspace } from '../types';
+export declare class WorkspaceApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Returns the current network
+     *
+     * @returns the Hailer Workspace information the user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    current(): Promise<Workspace>;
+}

package/lib/src/modules/permission.d.ts

@@ -0,0 +1,9 @@
+import { Client } from '@wishcore/wish-rpc';
+/**
+ * This class is used to access Hailer public API even when the app is outside of Hailer
+ */
+export declare class PermissionApi {
+    private client;
+    constructor(client: Client);
+    map: () => Promise<void>;
+}

package/lib/src/modules/process.d.ts

@@ -0,0 +1,38 @@
+import { Client } from '@wishcore/wish-rpc';
+import { HailerProcess } from '../types';
+/** @deprecated Use Workflow instead */
+export declare class Process {
+    private client;
+    constructor(client: Client);
+    /**
+     * Lists all processes from a workspace
+     *
+     * @returns all Hailer processes in the workspace the app user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list(): Promise<{
+        [key: string]: HailerProcess;
+    }>;
+    /**
+     * Gets a single process from a workspace
+     *
+     * @param processId the id of the process in question
+     *
+     * @returns the specified Hailer process
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(processId: string): Promise<HailerProcess>;
+    /**
+     * Gets an id of a field in a process by its name
+     *
+     * @param processId the id of the process in question
+     * @param fieldName name of the field
+     *
+     * @returns the field id as string
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    getFieldIdByName(processId: string, fieldName: string): Promise<string>;
+}