@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/service.d.ts

@@ -0,0 +1,597 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { SessionQueryEngine } from '@deepseek-ai/dsh-session-query';
+import { type AgentFrameState, type AssetKind, type AssetStatus, type FitnessSignal, type FrameMode, type HomeAddress, type HumanAction, type HumanNotificationPreference, type InboxSenderAddress, type UserAddress, type InboxDelivery, type InboxMessage, type LearningCheckpoint, type MemoryProposal, type SessionBinding } from './domain.js';
+import type { ResolvedConfig } from './config.js';
+import { HomeStore, type CreateOrganizationInput } from './home-store.js';
+import { HomeSpace } from './home-space.js';
+import { LearningLedger } from './ledger.js';
+import { WorkLedger, type FormalWork } from './work-ledger.js';
+import { ProjectLedger, type FormalProject } from './project-ledger.js';
+import type { UiProjectOutcomeReviewInbox } from './ui-contract.js';
+import { type ProjectSeatContext } from './project-seat-context.js';
+import { type SharedKnowledgeTarget, type SharedKnowledgeProposal } from './shared-knowledge.js';
+import { WorklogLedger, type WorklogRevision } from './worklog-ledger.js';
+import { type LearningTrigger } from './learning-trigger.js';
+import { type ActiveOrganizationLocation } from './organization-location.js';
+type MutableKind = Exclude<AssetKind, 'identity'>;
+export interface FrameStatusSnapshot {
+    state: AgentFrameState;
+    refreshRequired: boolean;
+    staleFrames: HomeAddress[];
+}
+export interface MemoryUseOutcomePage {
+    homeAddress: HomeAddress;
+    assetId: string;
+    assetRevision: number;
+    currentBodySha256: string;
+    interpretation: string;
+    outcomes: Array<{
+        workId: string;
+        projectId?: string;
+        sessionId: string;
+        completedAt?: string;
+        resultSubject?: string;
+        resultBody?: string;
+        resultArtifacts: NonNullable<FormalWork['resultArtifacts']>;
+        workSourceStatus: 'verified' | 'changed' | 'unavailable';
+        omittedReceipts: number;
+        uses: Array<{
+            receiptId: string;
+            signal: 'retrieved' | 'applied';
+            sessionId: string;
+            eventSeq?: number;
+            assetRevision?: number;
+            assetBodySha256?: string;
+            observedAt: string;
+            sourceStatus: 'verified' | 'changed' | 'unavailable';
+        }>;
+    }>;
+    nextBeforeWorkId?: string;
+}
+type InboxSendInput = {
+    to: string[];
+    cc?: string[];
+    subject: string;
+    body: string;
+    priority?: 'normal' | 'urgent';
+    due?: string;
+    contextRefs?: string[];
+    humanAction?: HumanAction;
+    replyTo?: string;
+    projectId?: string;
+    idempotencyKey?: string;
+    kind?: InboxMessage['kind'];
+    internalReturnToSessionId?: string;
+};
+export declare class BizAgentService {
+    readonly ledger: LearningLedger;
+    readonly config: ResolvedConfig;
+    private readonly sessionQuery?;
+    private readonly learningTriggers;
+    private activeOrganization?;
+    readonly workLedger?: WorkLedger | undefined;
+    readonly projectLedger?: ProjectLedger | undefined;
+    readonly worklogLedger?: WorklogLedger | undefined;
+    projectMainProvisioner?: (projectId: string) => Promise<{
+        sessionId: string;
+    }>;
+    private readonly liveBindings;
+    /** Bounded, de-duplicated runtime issues; oldest are dropped first. */
+    private readonly runtimeIssues;
+    private sharedKnowledgeIndex;
+    private worklogRecoveryOffset;
+    private sessionWorklogRecoveryOffset;
+    constructor(store: HomeSpace | HomeStore, ledger: LearningLedger, config: ResolvedConfig, sessionQuery?: (Pick<SessionQueryEngine, "readSession"> & Partial<Pick<SessionQueryEngine, "listSessions">>) | undefined, learningTriggers?: readonly LearningTrigger[], activeOrganization?: ActiveOrganizationLocation | undefined, workLedger?: WorkLedger | undefined, projectLedger?: ProjectLedger | undefined, worklogLedger?: WorklogLedger | undefined);
+    store: HomeSpace;
+    initialize(): Promise<void>;
+    /**
+     * Before organizations had their own folder, every Session outside a Home folder fell back to the
+     * Business Home. Forget those bindings so the Sessions bind afresh, to the personal Home, on their
+     * next turn. Bindings the current rules still make are kept.
+     */
+    private releaseStrayBusinessBindings;
+    getActiveOrganizationLocation(): ActiveOrganizationLocation | undefined;
+    /**
+     * Where this Home's own Sessions run when BizAgent starts one (formal Work, Inbox wake): the host's
+     * explicit workspaceHomes mapping, else the active Home's own directory. Undefined when neither
+     * exists. The Home directory is the same Workspace its Principal and Project Main use.
+     */
+    homeWorkspaceRoot(home: HomeAddress): string | undefined;
+    /** A known Workspace whose new Sessions resolve to this active Business Home: the organization folder. */
+    chatWorkspacePath(home: HomeAddress): string | undefined;
+    /** Create an organization in its own folder, `<data root>/orgs/<id>`, and make it the active one. */
+    createOrganization(input: CreateOrganizationInput): Promise<void>;
+    /** Create the one-click sample team and place its sample data files. */
+    createSampleOrganization(): Promise<void>;
+    bindSession(sessionId: string, cwd?: string): SessionBinding | undefined;
+    contextForSession(sessionId: string, cwd?: string): string;
+    contextSnapshotForSession(sessionId: string, cwd?: string): {
+        homeAddress: HomeAddress;
+        revision: number;
+        digest: string;
+        text: string;
+    } | undefined;
+    homeStatus(agent: Agent): Promise<Record<string, unknown>>;
+    listEpisodes(agent: Agent, input?: {
+        beforeSessionId?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    readEpisode(agent: Agent, input: {
+        sessionId: string;
+        afterSeq?: number;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    recordWorklog(agent: Agent, input: {
+        description: string;
+        body: string;
+        status: WorklogRevision['status'];
+        idempotencyKey: string;
+        files?: string[];
+        projectId?: string;
+        workId?: string;
+    }): Promise<Record<string, unknown>>;
+    /** Materialize completed formal Work after its completion turn is durable. */
+    reconcileCompletedWorklogs(limit?: number, sessionId?: string): Promise<{
+        created: string[];
+        deferred: string[];
+        failed: Array<{
+            workId: string;
+            error: unknown;
+        }>;
+    }>;
+    private materializeCompletedWorklog;
+    /** Record substantive ordinary turns from the persisted Session, including after a restart. */
+    reconcileSessionWorklogs(limit?: number, sessionId?: string): Promise<{
+        created: string[];
+        deferred: string[];
+        failed: Array<{
+            sessionId: string;
+            error: unknown;
+        }>;
+    }>;
+    searchWorklogs(agent: Agent, input?: {
+        query?: string;
+        status?: WorklogRevision['status'];
+        beforeSessionId?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    readWorklog(agent: Agent, input: {
+        sessionId: string;
+        revision?: number;
+    }): Promise<Record<string, unknown>>;
+    readWorklogFile(agent: Agent, input: {
+        sessionId: string;
+        revision?: number;
+        path: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    scanLearningMaterials(agent: Agent, input?: {
+        beforeSessionId?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /** Host scheduler preflight uses the same bounded source scan as the worker, without spending model tokens. */
+    hasPendingLearningMaterials(homeAddress: HomeAddress): Promise<boolean>;
+    private scanHomeLearningMaterials;
+    /**
+     * Snapshot the Home's identity and learning files. Retired assets are left out, except ones that
+     * were in the batch's starting snapshot, so a retirement during the batch shows as an update.
+     */
+    private captureLearningLibrary;
+    reviewLearningMaterial(agent: Agent, input: {
+        materialId: string;
+        summary: string;
+    }): Promise<Record<string, unknown>>;
+    startLearningBatch(agent: Agent, callId: string): Promise<Record<string, unknown>>;
+    learningBatchStatus(agent: Agent, runId: string): Promise<Record<string, unknown>>;
+    readLearningBatchChange(agent: Agent, input: {
+        runId: string;
+        path: string;
+        side: 'before' | 'after';
+        offset?: number;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    settleLearningBatchMaterial(agent: Agent, input: {
+        runId: string;
+        materialId: string;
+        summary: string;
+        candidates?: Array<{
+            kind: MutableKind;
+            description: string;
+            body: string;
+            fromSeq?: number;
+            toSeq?: number;
+            tags?: string[];
+        }>;
+    }): Promise<Record<string, unknown>>;
+    finishLearningBatch(agent: Agent, input: {
+        runId: string;
+        action: 'complete' | 'abandon';
+        summary: string;
+    }): Promise<Record<string, unknown>>;
+    private learningBatchView;
+    sendInboxMessage(agent: Agent, callId: string, input: InboxSendInput): Promise<Record<string, unknown>>;
+    /** Resolve a Project Seat delivery to its long-lived execution Home. */
+    inboxAddressHome(address: string, allowReleased?: boolean): HomeAddress | undefined;
+    projectSeatContextForAddress(address: string): ProjectSeatContext | undefined;
+    joinProjectTurn(agent: Agent, projectId: string): Promise<Record<string, unknown>>;
+    private recordProjectTurn;
+    private inboxDeliveryForHome;
+    private sendInboxFromBinding;
+    listInbox(agent: Agent, input?: {
+        direction?: 'incoming' | 'outgoing' | 'both';
+        pendingOnly?: boolean;
+        beforeMessageId?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    pendingInboxDigestForSession(sessionId: string, cwd?: string): {
+        homeAddress: HomeAddress;
+        total: number;
+        digest: string;
+        messages: Array<{
+            id: string;
+            fromAddress: InboxSenderAddress;
+            subject: string;
+            kind: InboxMessage['kind'];
+            priority: 'normal' | 'urgent';
+            convergence?: {
+                topicId: string;
+                hop: number;
+                topicCount: number;
+            };
+        }>;
+    } | undefined;
+    readInboxMessage(agent: Agent, messageId: string): Promise<Record<string, unknown>>;
+    handleInboxMessage(agent: Agent, messageId: string): Promise<Record<string, unknown>>;
+    private inboxDeliveries;
+    /** Trusted host entrypoint; the owner and authority reference must come from verified identity state. */
+    createAutomaticTopicEscalation(input: {
+        topicId: string;
+        userId: string;
+        authorityRef: string;
+        now?: number;
+    }): Promise<{
+        message: InboxMessage;
+        delivery: InboxDelivery;
+    } | undefined>;
+    /** Call these human Inbox methods only after the host has authenticated the user. */
+    readHumanNotificationPreference(userId: string): {
+        recipient: UserAddress;
+        enabled: boolean;
+        revision: number;
+        updatedAt?: string;
+    };
+    setHumanNotificationPreference(userId: string, enabled: boolean, expectedRevision: number): Promise<{
+        preference: HumanNotificationPreference;
+    }>;
+    listHumanInbox(userId: string, input?: {
+        direction?: 'incoming' | 'outgoing' | 'both';
+        pendingOnly?: boolean;
+        beforeMessageId?: string;
+        limit?: number;
+    }): Record<string, unknown>;
+    readHumanInbox(userId: string, messageId: string): Record<string, unknown>;
+    handleHumanInbox(userId: string, messageId: string): Promise<Record<string, unknown>>;
+    replyHumanInbox(userId: string, input: {
+        replyTo: string;
+        subject: string;
+        body: string;
+        idempotencyKey: string;
+    }): Promise<Record<string, unknown>>;
+    createProject(agent: Agent, input: {
+        title: string;
+        goal: string;
+        doneWhen: string;
+        idempotencyKey: string;
+    }): Promise<Record<string, unknown>>;
+    listProjects(agent: Agent, input?: {
+        status?: FormalProject['status'];
+        beforeProjectId?: string;
+        limit?: number;
+    }): Promise<{
+        homeAddress: HomeAddress;
+        projects: FormalProject[];
+        nextBeforeProjectId?: string;
+    }>;
+    listProjectsForSession(sessionId: string, cwd: string | undefined, input?: {
+        status?: FormalProject['status'];
+        beforeProjectId?: string;
+        limit?: number;
+    }): Promise<{
+        homeAddress: HomeAddress;
+        projects: FormalProject[];
+        nextBeforeProjectId?: string;
+    }>;
+    readProject(agent: Agent, projectId: string): Promise<{
+        project: FormalProject;
+        work: FormalWork[];
+    }>;
+    readProjectForSession(sessionId: string, cwd: string | undefined, projectId: string): Promise<{
+        project: FormalProject;
+        work: FormalWork[];
+    }>;
+    inviteProjectSeat(agent: Agent, input: {
+        projectId: string;
+        homeAddress: string;
+        responsibility: string;
+    }): Promise<Record<string, unknown>>;
+    releaseProjectSeat(agent: Agent, input: {
+        projectId: string;
+        seatAddress: string;
+    }): Promise<Record<string, unknown>>;
+    readProjectArtifact(agent: Agent, input: {
+        projectId: string;
+        claimId: string;
+        path: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    submitProject(agent: Agent, input: {
+        projectId: string;
+        summary: string;
+        body: string;
+        doneWhenAssessment: string;
+        artifactRefs?: string[];
+    }): Promise<Record<string, unknown>>;
+    reviewProject(agent: Agent, input: {
+        projectId: string;
+        claimId: string;
+        decision: 'accept' | 'rework';
+        reason: string;
+    }): Promise<Record<string, unknown>>;
+    /** Human review keeps the same settlement checks and records the verified Host principal. */
+    reviewProjectAsHuman(principal: string, input: {
+        projectId: string;
+        claimId: string;
+        expectedRevision: number;
+        decision: 'accept' | 'rework';
+        reason: string;
+    }, authorize: (principal: string, project: FormalProject) => boolean | Promise<boolean>): Promise<Record<string, unknown>>;
+    listPendingProjectOutcomeReviewsAsHuman(principal: string, authorize: (principal: string, project: FormalProject) => boolean | Promise<boolean>, offset?: number, limit?: number): Promise<UiProjectOutcomeReviewInbox>;
+    private decideProjectReview;
+    reconcileProjectOutcomeReworkNotifications(limit?: number): Promise<{
+        delivered: string[];
+        failed: Array<{
+            projectId: string;
+            claimId: string;
+            error: unknown;
+        }>;
+    }>;
+    private deliverProjectOutcomeReworkNotice;
+    dispatchWork(agent: Agent, input: {
+        toAddress: string;
+        goal: string;
+        acceptanceCriteria: string;
+        idempotencyKey: string;
+        projectId?: string;
+    }): Promise<Record<string, unknown>>;
+    private dispatchWorkRecord;
+    /**
+     * Why a worker Session must not be started automatically for this Work, or undefined when it may.
+     * Like Inbox wake, DSH has no per-start execution principal, so only Homes with the same explicit
+     * owner may start work in each other's mapped Workspace. Other Work stays open for the
+     * assignee's own Sessions.
+     */
+    workAutoStartBlock(requester: HomeAddress, assignee: HomeAddress): 'no-workspace-mapping' | 'different-owner' | undefined;
+    /** True only when both Homes exist and carry the same non-empty owner. */
+    sameHomeOwner(left: HomeAddress, right: HomeAddress): boolean;
+    listWork(agent: Agent, input?: {
+        direction?: 'assigned' | 'requested' | 'both';
+        status?: FormalWork['status'];
+        beforeWorkId?: string;
+        limit?: number;
+    }): Promise<{
+        homeAddress: HomeAddress;
+        works: FormalWork[];
+        nextBeforeWorkId: string | undefined;
+    }>;
+    acceptWork(agent: Agent, workId: string): Promise<Record<string, unknown>>;
+    readWork(agent: Agent, workId: string): Promise<Record<string, unknown>>;
+    readWorkArtifact(agent: Agent, input: {
+        workId: string;
+        path: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    evaluateWorkOutput(agent: Agent, workId: string): Promise<Record<string, unknown>>;
+    private requireWorkOutputAccess;
+    cancelWork(agent: Agent, input: {
+        workId: string;
+        reason: string;
+    }): Promise<Record<string, unknown>>;
+    completeWork(agent: Agent, input: {
+        workId: string;
+        subject: string;
+        body: string;
+        artifactRefs?: string[];
+    }): Promise<Record<string, unknown>>;
+    /** Rebuild Work notices from durable reservations before restarting reserved workers. */
+    reconcileWorkNotifications(): Promise<{
+        repaired: {
+            workId: string;
+            phase: 'request' | 'result' | 'cancel';
+        }[];
+        failed: {
+            workId: string;
+            phase: 'request' | 'result' | 'cancel';
+            error: unknown;
+        }[];
+    }>;
+    private workNoticeMissing;
+    private requireWorkSenderBinding;
+    private finishWorkCompletion;
+    private requireWorkNotification;
+    private requireWorkLedger;
+    private requireProjectLedger;
+    private requireWorklogLedger;
+    private requireInboxDelivered;
+    frameStatus(agent: Agent): Promise<FrameStatusSnapshot>;
+    frameStatusForSession(sessionId: string, cwd: string | undefined, events: readonly SessionEvent[]): Promise<FrameStatusSnapshot>;
+    private frameStatusSnapshot;
+    searchHomes(agent: Agent, input?: {
+        query?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    searchHomesForSession(sessionId: string, cwd: string | undefined, input?: {
+        query?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    resolveHomeForSession(sessionId: string, cwd: string | undefined, target: string): Promise<Record<string, unknown>>;
+    openFrame(agent: Agent, input: {
+        address: string;
+        mode?: FrameMode;
+        refresh?: boolean;
+        /** Host admission retries need a full snapshot without invalidating other fresh Frames. */
+        forceSnapshot?: boolean;
+    }): Promise<Record<string, unknown>>;
+    searchFrame(agent: Agent, input: {
+        address?: string;
+        query?: string;
+        kind?: AssetKind;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    readFrame(agent: Agent, callId: string, input: {
+        address?: string;
+        assetId: string;
+    }): Promise<Record<string, unknown>>;
+    closeFrame(agent: Agent, address?: string): Promise<Record<string, unknown>>;
+    searchMemory(agent: Agent, input: {
+        query?: string;
+        kind?: AssetKind;
+        status?: AssetStatus;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    readMemory(agent: Agent, callId: string, assetId: string): Promise<Record<string, unknown>>;
+    private sharedKnowledgeTargets;
+    private searchSharedKnowledgeLayers;
+    private refreshSharedKnowledgeIndex;
+    private renderSharedKnowledgeIndex;
+    private verifiedSharedKnowledgeDocument;
+    searchSharedKnowledge(agent: Agent, query?: string): Promise<Record<string, unknown>>;
+    readSharedKnowledge(agent: Agent, documentId: string, target: SharedKnowledgeTarget): Promise<Record<string, unknown>>;
+    proposeSharedKnowledge(agent: Agent, callId: string, input: SharedKnowledgeTarget & {
+        description: string;
+        body: string;
+    }): Promise<Record<string, unknown>>;
+    sharedKnowledgeProposals(agent: Agent, status?: SharedKnowledgeProposal['status']): Promise<Record<string, unknown>>;
+    decideSharedKnowledgeAsHuman(input: {
+        proposalId: string;
+        action: 'accept' | 'reject';
+        decision: string;
+        reviewerId: string;
+        authorityRef: string;
+    }): Promise<Record<string, unknown>>;
+    /** Inspect later formal Work in the same worker Session without assigning a benefit score. */
+    memoryUseOutcomes(agent: Agent, input: {
+        assetId: string;
+        beforeWorkId?: string;
+        limit?: number;
+    }): Promise<MemoryUseOutcomePage>;
+    memoryUseOutcomesForSession(sessionId: string, cwd: string | undefined, input: {
+        assetId: string;
+        beforeWorkId?: string;
+        limit?: number;
+    }): Promise<MemoryUseOutcomePage>;
+    private memoryUseOutcomesForHome;
+    remember(agent: Agent, callId: string, input: {
+        kind?: MutableKind;
+        status?: 'candidate' | 'active';
+        description: string;
+        body: string;
+        tags?: string[];
+    }): Promise<Record<string, unknown>>;
+    updateMemory(agent: Agent, input: {
+        assetId: string;
+        action: 'revise' | 'retire' | 'publish';
+        expectedRevision?: number;
+        description?: string;
+        body?: string;
+        tags?: string[];
+    }): Promise<Record<string, unknown>>;
+    proposeMemory(agent: Agent, callId: string, input: {
+        toAddress: string;
+        proposedKind?: MutableKind;
+        targetAssetId?: string;
+        description: string;
+        body: string;
+        tags?: string[];
+    }): Promise<Record<string, unknown>>;
+    proposals(agent: Agent, input: {
+        id?: string;
+        direction?: 'incoming' | 'outgoing' | 'both';
+        status?: MemoryProposal['status'];
+    }): Promise<Record<string, unknown>>;
+    acceptProposal(agent: Agent, input: {
+        proposalId: string;
+        kind?: MutableKind;
+        description?: string;
+        body?: string;
+        tags?: string[];
+        decision?: string;
+    }): Promise<Record<string, unknown>>;
+    /** Call only after the host authenticates the human and authorizes this exact target Home. */
+    decideProposalAsHuman(input: {
+        ownerAddress: string;
+        proposalId: string;
+        action: 'accept' | 'reject';
+        decision: string;
+        reviewerId: string;
+        authorityRef: string;
+    }): Promise<Record<string, unknown>>;
+    private acceptProposalForHome;
+    prepareLearningCheckpoint(agent: Agent, turn: number): Promise<LearningCheckpoint | undefined>;
+    settleLearningCheckpoint(agent: Agent, input: {
+        checkpointId: string;
+        action: 'remember' | 'skip';
+        description?: string;
+        body?: string;
+        tags?: string[];
+        decision?: string;
+    }): Promise<Record<string, unknown>>;
+    failPendingCheckpoint(sessionId: string, turn: number, decision: string): Promise<void>;
+    readEvidence(agent: Agent, input: {
+        assetId: string;
+        sourceIndex?: number;
+    }): Promise<Record<string, unknown>>;
+    feedback(agent: Agent, callId: string, input: {
+        assetId: string;
+        signal: FitnessSignal;
+        outcome?: string;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Fitness is derived from the asset's receipts, so concurrent feedback cannot lose an update and
+     * a retried call applies its receipt exactly once. A concurrent asset write is retried.
+     */
+    private settleFitness;
+    close(): Promise<void>;
+    recordRuntimeError(scope: string, error: unknown, home?: HomeAddress): void;
+    /** Every recorded runtime issue, oldest first, for operators (overview health). */
+    listRuntimeIssues(): RuntimeIssue[];
+    private addRuntimeIssue;
+    private requireDurableBinding;
+    private requireDurableSessionBinding;
+    private resolveHome;
+    private frameState;
+    private checkedFrameState;
+    private requireReadableFrameHome;
+    private requireOpenFrameAddress;
+    private requireTargetProposal;
+    private receipt;
+    private reconcileProposals;
+    private reconcileSharedKnowledgeProposals;
+    private reconcileCheckpoints;
+}
+export interface RuntimeIssue {
+    message: string;
+    /** The Home the issue belongs to, when known; unattributed issues are shown to operators only. */
+    home?: HomeAddress;
+    count: number;
+    firstAt: string;
+    lastAt: string;
+}
+export declare function renderRuntimeIssue(issue: RuntimeIssue): string;
+export declare function isAssetKind(value: string): value is AssetKind;
+export declare function isFitnessSignal(value: string): value is FitnessSignal;
+export {};
+//# sourceMappingURL=service.d.ts.map