incyclist-services 1.7.21 → 1.7.23

package/lib/esm/ride/page/service.js

@@ -0,0 +1,221 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { EventLogger } from "gd-eventlog";
+import { Singleton } from "../../base/decorators";
+import { IncyclistPageService } from "../../base/pages";
+import { useRideDisplay } from "../display";
+import { sleep } from "../../utils/sleep";
+const BACKGROUND_PAUSE_TIMEOUT_MS = 60000;
+let RidePageService = (() => {
+    let _classDecorators = [Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = IncyclistPageService;
+    var RidePageService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RidePageService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        eventHandler = {};
+        backgroundTimer;
+        backgroundPausedByService = false;
+        menuProps = null;
+        isInitialized = false;
+        constructor() {
+            super('RidePage');
+            this.eventHandler['state-update'] = this.onDisplayStateUpdate.bind(this);
+            this.eventHandler['route-update'] = this.onRouteUpdate.bind(this);
+        }
+        async initPage() {
+            const service = this.getRideDisplay();
+            await service.init();
+            this.isInitialized = true;
+            return service.getRideType();
+        }
+        openPage(simulate) {
+            this.logEvent({ message: 'page shown', page: 'Rides' });
+            EventLogger.setGlobalConfig('page', 'Rides');
+            super.openPage();
+            try {
+                const service = this.getRideDisplay();
+                if (!this.isInitialized) {
+                    service.init();
+                }
+                this.registerEventHandlers();
+                service.start(simulate);
+                sleep(5).then(() => {
+                    this.updatePageDisplay();
+                });
+            }
+            catch (err) {
+                this.logError(err, 'openPage');
+            }
+            return this.getPageObserver();
+        }
+        closePage() {
+            EventLogger.setGlobalConfig('page', null);
+            this.logEvent({ message: 'page closed', page: 'Rides' });
+            this.getRideDisplay().stop();
+            this.menuProps = null;
+            this.isInitialized = false;
+            super.closePage();
+        }
+        pausePage() {
+            this.backgroundTimer = setTimeout(() => {
+                this.getRideDisplay().pause('user');
+                this.backgroundPausedByService = true;
+            }, BACKGROUND_PAUSE_TIMEOUT_MS);
+            this.isInitialized = false;
+            return super.pausePage();
+        }
+        resumePage() {
+            if (this.backgroundTimer) {
+                clearTimeout(this.backgroundTimer);
+            }
+            return super.resumePage();
+        }
+        getRideObserver() {
+            return this.rideObserver;
+        }
+        getPageDisplayProps() {
+            const rideType = this.getRideDisplay().getRideType();
+            switch (rideType) {
+                case 'Video': return this.getVideoRideDisplayProps();
+                default:
+                    return null;
+            }
+        }
+        onMenuOpen() {
+            const state = this.getRideDisplay().getState();
+            this.menuProps = { showResume: state === 'Paused' };
+            this.updatePageDisplay();
+        }
+        onMenuClose() {
+            this.menuProps = null;
+            this.updatePageDisplay();
+        }
+        onPause() {
+            this.getRideDisplay().pause('user');
+            this.menuProps = { showResume: false };
+            this.updatePageDisplay();
+        }
+        onResume() {
+            this.getRideDisplay().resume();
+            this.menuProps = null;
+            this.updatePageDisplay();
+        }
+        onEndRide() {
+            this.getRideDisplay().stop();
+            this.moveToPreviousPage();
+            this.closePage();
+        }
+        onRetryStart() {
+            this.getRideDisplay().retryStart();
+        }
+        onIgnoreStart() {
+            this.getRideDisplay().startWithMissingSensors();
+        }
+        async onCancelStart() {
+            this.rideObserver?.stop();
+            await this.getRideDisplay().cancelStart();
+            this.moveToPreviousPage();
+            this.closePage();
+        }
+        getVideoRideDisplayProps() {
+            const props = this.rideDisplayProps;
+            const state = this.getRideDisplay().getState();
+            const rideType = this.getRideDisplay().getRideType();
+            const isStarting = state === 'Idle' || state === 'Starting' || state === 'Error';
+            const displayProps = {
+                rideState: state,
+                rideType,
+                startOverlayProps: isStarting ? this.getRideDisplay().getStartOverlayProps() : null,
+                menuProps: this.menuProps,
+                video: props.video,
+                videos: props.videos,
+                route: props.route
+            };
+            return displayProps;
+        }
+        getRideType() {
+            return this.getRideDisplay().getRideType();
+        }
+        updatePageDisplay() {
+            this.getPageObserver().emit('page-update');
+        }
+        registerEventHandlers() {
+            const events = Object.keys(this.eventHandler);
+            events.forEach(event => { this.rideObserver.on(event, this.eventHandler[event]); });
+        }
+        unregisterEventHandlers() {
+            const events = Object.keys(this.eventHandler);
+            events.forEach(event => { this.rideObserver.off(event, this.eventHandler[event]); });
+        }
+        onDisplayStateUpdate(state, props) {
+            switch (state) {
+                case 'Paused':
+                    this.menuProps = { showResume: true };
+                    break;
+                case 'Active':
+                    this.menuProps = null;
+                    break;
+            }
+            this.updatePageDisplay();
+        }
+        onRouteUpdate() {
+            this.updatePageDisplay();
+        }
+        moveToPreviousPage() {
+            this.moveTo('$contentPage');
+        }
+        get rideObserver() {
+            return this.getRideDisplay().getObserver();
+        }
+        get rideDisplayProps() {
+            return this.getRideDisplay().getDisplayProperties();
+        }
+        getRideDisplay() {
+            return useRideDisplay();
+        }
+    };
+    return RidePageService = _classThis;
+})();
+export { RidePageService };
+export const getRidePageService = () => new RidePageService();

package/lib/esm/ride/page/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/ride/route/RLVDisplayService.js

@@ -132,12 +132,12 @@ let RLVDisplayService = (() => {
         }
         pause() {
             super.pause();
-            this.currentVideo.syncHelper.pause();
+            this.currentVideo?.syncHelper.pause();
             this.isVideoPaused = true;
         }
         resume() {
             super.resume();
-            this.currentVideo.syncHelper.resume();
+            this.currentVideo?.syncHelper.resume();
             this.isVideoPaused = false;
         }
         getDisplayProperties(props) {
@@ -154,14 +154,14 @@ let RLVDisplayService = (() => {
             if (this.videos.length === 1) {
                 const autoConvert = this.currentVideo?.playback === 'converted';
                 const video = {
-                    src: this.currentVideo.source,
+                    src: this.currentVideo?.source,
                     startTime,
                     autoConvert,
                     info: this.getInfotextDisplayProps(),
                     muted: true,
                     loop: this.isLoopEnabled() ? true : undefined,
-                    playback: this.currentVideo.playback,
-                    observer: this.currentVideo.observer,
+                    playback: this.currentVideo?.playback,
+                    observer: this.currentVideo?.observer,
                     onLoaded: this.onVideoLoaded.bind(this),
                     onLoadError: this.onVideoLoadError.bind(this),
                     onPlaybackError: this.onVideoPlaybackError.bind(this),
@@ -236,8 +236,8 @@ let RLVDisplayService = (() => {
         }
         onNextVideo() {
             const old = this.currentVideo;
-            const next = this.currentVideo.next;
-            if (!next)
+            const next = this.currentVideo?.next;
+            if (!next || !old)
                 return;
             old.isCurrent = false;
             old.isInitial = false;
@@ -258,13 +258,13 @@ let RLVDisplayService = (() => {
             this.emit('route-updated', this.getCurrentRoute());
             this.getCoaches().updateRoute(this.getCurrentRoute());
             this.logEvent({ message: 'switching to next video', route: this.getCurrentRoute().details.title,
-                segment: this.currentVideo.route.description.title, offset: this.offset, segmentDistance: this.currentVideo.route.description.distance,
+                segment: this.currentVideo?.route.description.title, offset: this.offset, segmentDistance: this.currentVideo?.route.description.distance,
                 totalDistance: this.getCurrentRoute().details.distance });
         }
         checkInfotextDisplayProps(time) {
             if (!this.currentVideo?.info)
                 return;
-            const info = this.currentVideo.info.find(i => i.start <= time && i.stop > time);
+            const info = this.currentVideo?.info.find(i => i.start <= time && i.stop > time);
             if (info) {
                 this.infotext = info.props;
             }
@@ -320,7 +320,7 @@ let RLVDisplayService = (() => {
         }
         async stop() {
             try {
-                this.currentVideo.syncHelper.stop();
+                this.currentVideo?.syncHelper.stop();
                 delete this.startTime;
                 await super.stop();
             }
@@ -336,7 +336,7 @@ let RLVDisplayService = (() => {
             if (this.currentRoute?.description?.hasGpx && !this.currentRoute?.points?.length) {
                 state = 'Start:Failed';
                 const errMessage = 'Invalid route (GPX missing)';
-                if (!this.currentVideo.error) {
+                if (!this.currentVideo?.error) {
                     this.logError(new Error(errMessage), 'getVideoState', { route: this.currentVideo.route });
                 }
                 this.currentVideo.error = errMessage;
@@ -354,7 +354,7 @@ let RLVDisplayService = (() => {
             return state;
         }
         getVideoLoadProgress() {
-            return { loaded: this.currentVideo?.loaded, bufferTime: this.currentVideo.bufferTime };
+            return { loaded: this.currentVideo?.loaded, bufferTime: this.currentVideo?.bufferTime };
         }
         onConvertUpdate(progress, frames, time) {
             if (!this.currentVideo || this.currentVideo.loaded)
@@ -430,7 +430,7 @@ let RLVDisplayService = (() => {
         }
         onVideoEnded(video = this.currentVideo) {
             video.syncHelper.onVideoEnded();
-            if (this.currentVideo.next) {
+            if (this.currentVideo?.next) {
                 this.onNextVideo();
             }
         }
@@ -439,7 +439,7 @@ let RLVDisplayService = (() => {
             const offset = this.offset ?? 0;
             const { routeDistance, speed } = activityPos;
             if (!this.isVideoPaused) {
-                this.currentVideo.syncHelper.onActivityUpdate(routeDistance - offset, speed);
+                this.currentVideo?.syncHelper.onActivityUpdate(routeDistance - offset, speed);
             }
         }
         initVideoSource(video) {
@@ -465,18 +465,21 @@ let RLVDisplayService = (() => {
         buildVideoError(error, video = this.currentVideo) {
             const src = this.getVideoUrl(video);
             const remote = src?.startsWith('http');
-            switch (error.code) {
-                case MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED:
-                    if (error.message.includes('Format error'))
+            try {
+                switch (error.code) {
+                    case MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED:
+                        if (error.message.includes('Format error'))
+                            return remote ? 'Could not load video' : 'Could not open video file';
+                        return 'Could not decode video';
+                    case MediaError.MEDIA_ERR_NETWORK:
                         return remote ? 'Could not load video' : 'Could not open video file';
-                    return 'Could not decode video';
-                case MediaError.MEDIA_ERR_NETWORK:
-                    return remote ? 'Could not load video' : 'Could not open video file';
-                case MediaError.MEDIA_ERR_ABORTED:
-                    return 'The playback was canceled';
-                case MediaError.MEDIA_ERR_DECODE:
-                    return 'Could not decode video';
+                    case MediaError.MEDIA_ERR_ABORTED:
+                        return 'The playback was canceled';
+                    case MediaError.MEDIA_ERR_DECODE:
+                        return 'Could not decode video';
+                }
             }
+            catch { }
             return error.message;
         }
         getVideoUrl(video) {
@@ -525,11 +528,11 @@ let RLVDisplayService = (() => {
                 let distance = startPos;
                 if (startPos === undefined) {
                     distance = this.isLoopEnabled() ? lapDistance : routeDistance - (this.offset ?? 0);
-                    if (distance > this.currentVideo.route.details.distance) {
+                    if (distance > this.currentVideo?.route.details.distance) {
                         distance = 0;
                     }
                 }
-                const routeId = this.currentVideo.route.description.id;
+                const routeId = this.currentVideo?.route.description.id;
                 this.getUserSettings().set(`routeSelection.video.prevSetting.${routeId}.startPos`, distance);
             }
             catch (err) {

package/lib/esm/ride/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/routes/page/service.js

@@ -40,6 +40,7 @@ import { useUserSettings } from "../../settings";
 import { Observer } from "../../base/types";
 import { v4 } from "uuid";
 import { sleep } from "../../utils/sleep";
+import { useDevicePairing } from "../../devices";
 let RoutesPageService = (() => {
     let _classDecorators = [Singleton];
     let _classDescriptor;
@@ -48,14 +49,17 @@ let RoutesPageService = (() => {
     let _classSuper = IncyclistPageService;
     let _instanceExtraInitializers = [];
     let _getRouteList_decorators;
+    let _getDevicePairing_decorators;
     let _getUserSettings_decorators;
     var RoutesPageService = class extends _classSuper {
         static { _classThis = this; }
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getRouteList_decorators = [Injectable];
+            _getDevicePairing_decorators = [Injectable];
             _getUserSettings_decorators = [Injectable];
             __esDecorate(this, null, _getRouteList_decorators, { kind: "method", name: "getRouteList", static: false, private: false, access: { has: obj => "getRouteList" in obj, get: obj => obj.getRouteList }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getDevicePairing_decorators, { kind: "method", name: "getDevicePairing", static: false, private: false, access: { has: obj => "getDevicePairing" in obj, get: obj => obj.getDevicePairing }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getUserSettings_decorators, { kind: "method", name: "getUserSettings", static: false, private: false, access: { has: obj => "getUserSettings" in obj, get: obj => obj.getUserSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             RoutesPageService = _classThis = _classDescriptor.value;
@@ -141,6 +145,15 @@ let RoutesPageService = (() => {
             if (card)
                 card.delete();
         }
+        start() {
+            const service = this.getRouteList();
+            const pairing = this.getDevicePairing();
+            const { id, title, videoUrl } = service.getStartSettings() ?? {};
+            this.logEvent({ message: 'Attempting to start a ride', id, title, videoUrl, readyToStart: pairing.isReadyToStart(), });
+            service.close();
+            const next = pairing.isReadyToStart() ? '/rideDeviceOK' : '/pairingStart';
+            this.moveTo(next);
+        }
         startImport(info) {
             if (this.importObserver)
                 return this.importObserver;
@@ -248,6 +261,9 @@ let RoutesPageService = (() => {
         getRouteList() {
             return useRouteList();
         }
+        getDevicePairing() {
+            return useDevicePairing();
+        }
         getUserSettings() {
             return useUserSettings();
         }

package/lib/types/activities/ride/service.d.ts

@@ -187,7 +187,7 @@ export declare class ActivityRideService extends IncyclistService {
     protected update(): void;
     protected isLoop(): boolean;
     protected createFreeRide(settings: FreeRideStartSettings): Route;
-    protected getMode(routeType: ActivityRouteType): "video" | "workout" | "free ride" | "follow route";
+    protected getMode(routeType: ActivityRouteType): "video" | "workout" | "follow route" | "free ride";
     protected updateActivityTime(): void;
     getRideProps(): any;
     protected logActivityUpdateMessage(): void;

package/lib/types/activities/ride/types.d.ts

@@ -1,3 +1,4 @@
+import { HealthStatus } from "../../devices";
 import { Dimension, Unit } from "../../i18n";
 import { ActivityDetailsUI } from "../base";
 export type ActivityState = 'ininitalized' | 'active' | 'paused' | 'completed' | 'idle';
@@ -15,3 +16,16 @@ export type ActivityUpdate = {
     routeDistance: number;
     distance: number;
 };
+export interface ActivityDashboardDataItem {
+    value: string | number | undefined;
+    unit?: string;
+    label?: string;
+    info?: string;
+}
+export interface ActivityDashboardItem {
+    title: string;
+    data: ActivityDashboardDataItem[];
+    size?: number;
+    dataState?: HealthStatus;
+}
+export type ActivityDashboardDisplayProperties = ActivityDashboardItem[];

package/lib/types/activities/types.d.ts

@@ -0,0 +1 @@
+export * from './ride/types';

package/lib/types/apps/base/app/index.d.ts

@@ -6,6 +6,7 @@ export declare class ConnectedAppService<C extends AppCredentials> extends Incyc
     protected appKey: string;
     protected isInitialized: boolean;
     protected id: any;
+    protected credentials: C;
     constructor(service: any, appKey: string);
     init(): boolean;
     connect(credentials: C): Promise<boolean>;
@@ -13,6 +14,7 @@ export declare class ConnectedAppService<C extends AppCredentials> extends Incyc
     isConnected(): boolean;
     getCredentials(): C;
     protected initAuth(): boolean;
+    protected checkAuth(): boolean;
     protected ensureInitialized(): boolean;
     protected getUserSettings(): import("../../../settings").UserSettingsService;
 }

package/lib/types/apps/komoot/KomootAppConnection.d.ts

@@ -4,7 +4,6 @@ import { KomootAuth, KomootCredentials } from "./types";
 export declare class KomootAppConnection extends ConnectedAppService<KomootCredentials> {
     protected _isConnecting: any;
     protected api: KomootApi;
-    protected credentials: KomootCredentials;
     constructor();
     connect(credentials: KomootCredentials): Promise<boolean>;
     isConnecting(): boolean;
@@ -12,7 +11,8 @@ export declare class KomootAppConnection extends ConnectedAppService<KomootCrede
     isConnected(): boolean;
     getCredentials(): KomootCredentials;
     getApi(): KomootApi;
-    protected initAuth(): boolean;
+    protected iniAuth(): boolean;
+    protected checkAuth(): boolean;
     protected getAuthConfig(): KomootAuth | KomootCredentials;
     protected getUuid(): any;
     protected saveCredentials(): void;

package/lib/types/apps/velohero/VeloHeroAppConnection.d.ts

@@ -4,7 +4,6 @@ import { VeloHeroAuth, VeloHeroCredentials } from "./types";
 export declare class VeloHeroAppConnection extends ConnectedAppService<VeloHeroCredentials> {
     protected _isConnecting: any;
     protected api: VeloHeroApi;
-    protected credentials: VeloHeroCredentials;
     constructor();
     connect(credentials: VeloHeroCredentials): Promise<boolean>;
     isConnecting(): boolean;

package/lib/types/base/pages/service.d.ts

@@ -15,5 +15,9 @@ export declare class IncyclistPageService extends IncyclistService implements IP
     resumePage(): Promise<void>;
     getPageObserver(): IObserver;
     protected stopObserver(): void;
+    protected getPrevContentPage(): string;
+    protected moveTo(route: string, close?: boolean): void;
+    protected getUIBinding(): import("../../api").INativeUI;
+    protected getBindings(): import("../../api").IncyclistBindings;
     protected getAppState(): import("../../appstate").AppStateService;
 }

package/lib/types/devices/page/service.d.ts

@@ -13,8 +13,9 @@ export declare class DevicesPageService extends IncyclistPageService {
     protected openedCapability: IncyclistCapability | undefined;
     protected openedInterfaceSettings: TInterface;
     protected interfaceSettingsObserver: Observer | undefined;
+    protected isPairingForRide: boolean;
     constructor();
-    openPage(): IObserver;
+    openPage(forRide?: boolean): IObserver;
     closePage(): void;
     pausePage(): Promise<void>;
     resumePage(): Promise<void>;
@@ -43,14 +44,11 @@ export declare class DevicesPageService extends IncyclistPageService {
     protected onOK(): void;
     protected onSimulate(): void;
     protected onCancel(): void;
-    protected moveTo(route: string, close?: boolean): void;
     protected start(): Promise<void>;
     stop(adapters?: Array<string>, forExit?: boolean): Promise<void>;
     protected get state(): InternalPairingState;
-    protected getUIBinding(): import("../../types").INativeUI;
     protected getDevicePairing(): import("../pairing").DevicePairingService;
     protected getDeviceConfiguration(): import("../configuration").DeviceConfigurationService;
-    protected getBindings(): import("../../api").IncyclistBindings;
     protected getIncyclist(): import("../../ui").UserInterfaceServcie;
 }
 export declare const getDevicesPageService: () => DevicesPageService;

package/lib/types/devices/ride/index.d.ts

@@ -1,2 +1,2 @@
 export * from './service';
-export * from './model';
+export type * from './types';

package/lib/types/devices/ride/service.d.ts

@@ -1,5 +1,5 @@
 import { AdapterInfo, IncyclistDeviceSettings } from "../configuration";
-import { AdapterRideInfo, AdapterStateInfo, LegacyRoute, PreparedRoute, RideServiceCheckFilter, RideServiceDeviceProperties } from "./model";
+import { AdapterRideInfo, AdapterStateInfo, LegacyRoute, PreparedRoute, RideServiceCheckFilter, RideServiceDeviceProperties } from "./types";
 import { CyclingMode, DeviceData, DeviceSettings, ICyclingMode, IncyclistCapability, IncyclistDeviceAdapter, UpdateRequest } from "incyclist-devices";
 import { IncyclistService } from "../../base/service";
 import { Route } from "../../routes/base/model/route";

package/lib/types/devices/ride/types.d.ts

@@ -0,0 +1,54 @@
+import { DeviceProperties } from "incyclist-devices";
+import { AdapterInfo, ExtendedIncyclistCapability } from "../configuration";
+import { Route } from "../../routes/base/model/route";
+import { RouteApiDetail } from "../../routes/base/api/types";
+export type HealthStatus = 'green' | 'amber' | 'red';
+export interface AdapterRideInfo extends AdapterInfo {
+    isStarted: boolean;
+    tsLastData?: number;
+    isHealthy?: boolean;
+    isRestarting?: boolean;
+    dataStatus?: HealthStatus;
+    ivToCheck?: NodeJS.Timeout;
+    isControl?: boolean;
+}
+export interface AdapterStateInfo {
+    udid: string;
+    name: string;
+    isControl: boolean;
+    capabilities: Array<ExtendedIncyclistCapability>;
+    isStarted: boolean;
+}
+export interface LegacyRoute {
+    get(): RouteApiDetail;
+    isLap(): boolean;
+    getTitle(): string;
+}
+export interface RideServiceDeviceProperties extends DeviceProperties {
+    forceErgMode?: boolean;
+    startPos?: number;
+    realityFactor?: number;
+    rideMode?: string;
+    route?: Route | LegacyRoute;
+}
+export interface RideServiceCheckFilter {
+    interface?: string;
+    interfaces?: string[];
+    udid?: string;
+}
+export interface Point {
+    elevation: number;
+    distance: number;
+}
+export interface PreparedRoute {
+    name: string;
+    description: string;
+    programId: number;
+    type: string;
+    totalDistance: number;
+    lapMode: boolean;
+    minElevation: number;
+    maxElevation: number;
+    sampleRate: number;
+    points: Point[];
+}

package/lib/types/devices/types.d.ts

@@ -1 +1,2 @@
 export type * from './page/types';
+export type * from './ride/types';

package/lib/types/ride/display/service.d.ts

@@ -115,7 +115,7 @@ export declare class RideDisplayService extends IncyclistService implements ICur
     protected isStartDeviceCompleted(): boolean;
     protected isStartDeviceReadyToStart(): boolean;
     protected isSensorsReadyToStart(): boolean;
-    protected getStartOverlayProps: () => StartOverlayProps;
+    getStartOverlayProps: () => StartOverlayProps;
     protected getDeviceStartSettings(): any;
     protected isSimulator(): boolean;
     protected getBike(): string;

package/lib/types/ride/index.d.ts

@@ -1,2 +1,3 @@
 export * from './base';
 export * from './display';
+export * from './page';

package/lib/types/ride/page/index.d.ts

@@ -0,0 +1 @@
+export * from './service';