@bridgething/lib 0.1.2

package/dist/bindings/shared.d.ts

@@ -0,0 +1,1485 @@
+/**
+ * Direction the accessory wants iOS to take when answering an incoming
+ * call while another call is active.
+ */
+export type AcceptCallAction = 'accept' | 'endAndAccept';
+/**
+ * An album reference.
+ */
+export type Album = {
+    id: string;
+    name: string;
+    /**
+     * Opaque artwork asset id (`asset.get`), when known.
+     */
+    artwork_id: string | null;
+};
+/**
+ * Daemon-observed state of the ANCS GATT-client session against the
+ * connected iPhone. iOS-only; emitted on transitions so the companion
+ * app can confirm the LE-pair + ANCS authorization handshake completed.
+ *
+ * State machine:
+ * - `Unknown`: pre-boot only (no iAP2 has ever attached this session).
+ * - `Probing`: a session task is running but no determination yet,
+ *   OR iAP2 just detached and we expect to re-probe on reconnect.
+ * - `Authorized`: ANCS attribute fetches are succeeding.
+ * - `Unauthorized`: ANCS service hidden, or auth-gate detected.
+ */
+export type AncsAuthState = 'unknown' | 'probing' | 'authorized' | 'unauthorized';
+/**
+ * Art render sizes a webapp declares so the companion warms exactly the
+ * pixels it renders: hero (now-playing / detail views) and thumb (queue /
+ * grid). Omitted in a manifest falls back to the canonical `{248, 96}`,
+ * which is also the stock webapp's profile.
+ */
+export type ArtProfile = {
+    heroPx: number;
+    thumbPx: number;
+};
+/**
+ * An artist reference.
+ */
+export type Artist = {
+    id: string;
+    name: string;
+    /**
+     * Opaque artwork asset id (`asset.get`), when known.
+     */
+    artwork_id: string | null;
+};
+export type AssetRetention = {
+    type: 'lru';
+} | {
+    type: 'pinned';
+} | {
+    type: 'ttl';
+    data: TtlRetention;
+} | {
+    type: 'persistent';
+};
+/**
+ * What the gateway-side audio backend supports. `earcons` are short
+ * named sounds the companion can play; `voices` are TTS voices.
+ */
+export type AudioCapabilities = {
+    earcons: Array<string>;
+    voices: Array<VoiceDescriptor>;
+};
+export type BoolField = {
+    key: string;
+    label: string;
+    default: boolean | null;
+};
+/**
+ * Bridge-side identity announce. Daemon sends one of these to every
+ * gateway on connect so the companion knows what daemon it's talking to
+ * and can opt out of unsupported surfaces.
+ */
+export type BridgeThingMeta = {
+    bridgethingVersion: string;
+    libbridgethingVersion: string;
+    appName: string;
+    /**
+     * User-set display name for this device. None when the user hasn't
+     * set one yet; consumers fall back to `model_name` / `serial_number`.
+     * Set via the gateway-side `system.device.setNickname` surface.
+     */
+    nickname: string | null;
+    /**
+     * Daemon semver (no leading `v`), e.g. `0.8.4`. Compared directly to
+     * the manifest's daemon-component version for OTA hot-swap decisions.
+     */
+    appVersion: string;
+    osName: string;
+    osVersion: string;
+    osDescription: string;
+    btMac: string;
+    serialNumber: string;
+    fccId: string;
+    icId: string;
+    modelName: string;
+    /**
+     * OTA channel the running image was cut on, e.g. `stable` or `dev`.
+     * The companion's poll loop only auto-pushes when its configured
+     * channel matches; a mismatch surfaces a "channel switch needs full
+     * flash" event rather than swapping channels in-band.
+     */
+    channel: string;
+    /**
+     * Image variant the running image was cut as, e.g. `prod` or `dev`.
+     * Maps to the yocto image recipe name `bridgething-<variant>-image`,
+     * which is what the companion uses to construct the OTA artifact URL
+     * `images/<channel>/<image_version>/bridgething-<variant>-image.{swu,zck}`.
+     */
+    imageVariant: string;
+    /**
+     * Canonical image version (CalVer, e.g. `2026.05.0`). What the
+     * companion compares to the manifest's image-component version.
+     */
+    imageVersion: string;
+    imageBuildId: string;
+    imageBuildDate: string;
+    imageDistro: string;
+    imageMachine: string;
+    discord: string;
+    credits: string;
+};
+export type BrightnessMode = 'auto' | 'manual';
+/**
+ * Backlight state. `level` is the user-set value (only respected in
+ * `Manual`); `effective_level` is what's actually on the panel - equal
+ * to `level` in `Manual`, ALS-derived in `Auto`.
+ */
+export type BrightnessState = {
+    mode: BrightnessMode;
+    level: number;
+    effectiveLevel: number;
+};
+/**
+ * One row in a `BrowseResult`: either a folder (drilldown) or a leaf
+ * item the user can play / queue / favorite.
+ */
+export type BrowseEntry = {
+    type: 'folder';
+    data: BrowseFolder;
+} | {
+    type: 'item';
+    data: LibraryItem;
+};
+/**
+ * A drilldown node. `node_id` is opaque and gateway-defined; webapps
+ * pass it back as the next `browse({ node_id })` to descend. `total` is
+ * the count of children behind this folder when the gateway can cheaply
+ * expose it. `preview_children` is an inline first-N slice of those
+ * children so home-shelf shapes don't need a separate drill round-trip;
+ * gateways populate it when cheap (Spotify Web API home shelves include
+ * previews; Apple Music curated rails do too) and leave it `None`
+ * otherwise.
+ */
+export type BrowseFolder = {
+    nodeId: string;
+    title: string;
+    subtitle: string | null;
+    artworkId: string | null;
+    total: number | null;
+    previewChildren: Array<BrowseEntry> | null;
+};
+/**
+ * Page of browse results. `total` is the count of items in the
+ * underlying collection when the gateway can cheaply expose it (None
+ * means indeterminate). `has_more` is the authoritative end-of-data
+ * signal - webapps paginate by raising `offset` until `has_more` is
+ * false rather than relying on `total`.
+ */
+export type BrowseResult = {
+    entries: Array<BrowseEntry>;
+    total: number | null;
+    hasMore: boolean;
+};
+/**
+ * Why a call ended, surfaced on `onPhoneCallEnded`. `Failed` carries a
+ * platform-defined reason (network, busy, etc.).
+ */
+export type CallEndReason = {
+    type: 'local';
+} | {
+    type: 'remote';
+} | {
+    type: 'missed';
+} | {
+    type: 'declined';
+} | {
+    type: 'failed';
+    data: {
+        reason: string;
+    };
+};
+/**
+ * What the daemon advertises to webapps. `gateway: None` means no
+ * companion is connected; webapps that depend on companion-routed
+ * surfaces (Library, Net, Notifications, etc.) should branch on this.
+ * `authority` is the live set of scopes the companion currently claims.
+ */
+export type Capabilities = {
+    gateway: GatewayInfo | null;
+    available: SurfaceAvailability;
+    authority: Array<CompanionAuthorityScope>;
+    uriSchemes: Array<string>;
+    network: NetworkInfo;
+    audio: AudioCapabilities;
+    musicProvider: MusicProvider;
+};
+/**
+ * What call-control verbs are currently legal. Webapps must gate UI on
+ * these flags; sending an unavailable verb is a protocol violation, not
+ * a no-op. All `None` = no signal received yet, treat as conservatively
+ * unavailable.
+ */
+export type CommunicationsState = {
+    signalStrength: number | null;
+    registrationStatus: RegistrationStatus | null;
+    airplaneMode: boolean | null;
+    carrierName: string | null;
+    cellularSupported: boolean | null;
+    telephonyEnabled: boolean | null;
+    faceTimeAudioEnabled: boolean | null;
+    faceTimeVideoEnabled: boolean | null;
+    muteStatus: boolean | null;
+    currentCallCount: number | null;
+    newVoicemailCount: number | null;
+    initiateCallAvailable: boolean | null;
+    endAndAcceptAvailable: boolean | null;
+    holdAndAcceptAvailable: boolean | null;
+    swapAvailable: boolean | null;
+    mergeAvailable: boolean | null;
+    holdAvailable: boolean | null;
+};
+/**
+ * One axis the companion can declare authority over. Each scope has a
+ * fallback source the daemon merges with when no claim is active or
+ * the claim has gone stale. Unknown scopes arriving at an older daemon
+ * are stored opaquely and ignored.
+ */
+export type CompanionAuthorityScope = 'nowPlayingMetadata' | 'nowPlayingPlayback' | 'volume';
+/**
+ * One key/value pair as exposed by config read APIs. `value` is always a
+ * string; consumers parse per the field's declared kind (number -> parseFloat,
+ * boolean -> "true"/"false", string/enum/secret -> as-is).
+ */
+export type ConfigEntry = {
+    key: string;
+    value: string;
+};
+/**
+ * One declared user-tunable setting. Adjacent-tagged on the wire to
+ * stay typeshare-compatible: `{"type":"string","data":{"key":"zip",...}}`.
+ */
+export type ConfigField = {
+    type: 'string';
+    data: StringField;
+} | {
+    type: 'number';
+    data: NumberField;
+} | {
+    type: 'boolean';
+    data: BoolField;
+} | {
+    type: 'enum';
+    data: EnumField;
+} | {
+    type: 'secret';
+    data: StringField;
+};
+/**
+ * The foreground app driving playback, surfaced on iOS over iAP2.
+ */
+export type CurrentlyActiveApplication = {
+    /**
+     * Bundle identifier, e.g. `com.spotify.client`.
+     */
+    id: string;
+    name: string;
+};
+export type Device = {
+    name: string;
+    type: DeviceType;
+    mac: string;
+    default: boolean;
+};
+export type DeviceType = 'android' | 'iOS' | 'windows' | 'macOS' | 'linux' | 'unknown';
+/**
+ * Daemon health snapshot. `load_avg` is the unix 1/5/15-minute load.
+ * `soc_temp_c` may be `None` on builds where the SoC thermal probe is
+ * not exposed by the kernel.
+ */
+export type Diagnostics = {
+    diskUsedBytes: number;
+    diskFreeBytes: number;
+    memUsedBytes: number;
+    memAvailBytes: number;
+    uptimeS: number;
+    socTempC: number | null;
+    loadAvg: [number, number, number];
+    daemonVersion: string;
+    kernelVersion: string;
+    bootId: string;
+};
+/**
+ * Why a notification went away. `Acted` covers both positive and
+ * negative invokes; gateways that distinguish dismiss-vs-acted may
+ * surface both as `Acted`.
+ */
+export type DismissReason = 'userDismissed' | 'acted' | 'remoteDismissed';
+/**
+ * DTMF tones the accessory can play during an active call.
+ */
+export type DtmfTone = 'd0' | 'd1' | 'd2' | 'd3' | 'd4' | 'd5' | 'd6' | 'd7' | 'd8' | 'd9' | 'star' | 'hash';
+/**
+ * Direction the accessory wants iOS to take when ending a call.
+ */
+export type EndCallAction = 'end' | 'endAll';
+export type EnumField = {
+    key: string;
+    label: string;
+    choices: Array<string>;
+    default: string | null;
+};
+/**
+ * Page of the user's favorited / liked / saved library items. Mixed-kind
+ * because most platforms expose one "Saved" surface across kinds.
+ */
+export type FavoritesPage = {
+    items: Array<LibraryItem>;
+    total: number | null;
+    hasMore: boolean;
+};
+export type ForwardMessage = {
+    encoding: 'text';
+    data: string;
+} | {
+    encoding: 'json';
+    data: unknown;
+} | {
+    encoding: 'binary';
+    data: Uint8Array;
+};
+/**
+ * What a connected companion advertises about itself. Sent on every
+ * session-up via `GatewayToBridgeCapabilitiesMsg::Announce`, and re-sent
+ * on any change. The daemon caches the latest snapshot per peer and
+ * derives the webapp-facing `Capabilities` from it.
+ */
+export type GatewayCapabilities = {
+    gateway: GatewayInfo;
+    uriSchemes: Array<string>;
+    network: NetworkInfo;
+    available: SurfaceAvailability;
+    audio: AudioCapabilities;
+    musicProvider: MusicProvider;
+};
+/**
+ * Identity payload describing the companion peer the daemon is talking
+ * to. Address is the BT MAC the companion advertises; on transports without
+ * a stable MAC (the network gateway's `0xfe:fe:...` synthetic addrs) it
+ * is the synthetic address as a string.
+ */
+export type GatewayInfo = {
+    address: string;
+    name: string;
+    osName: string;
+    appName: string;
+    appVersion: string;
+    adapterVersion: string;
+    libVersion: string;
+    libbridgethingVersion: string;
+};
+/**
+ * Subscriber's accuracy preference. `Coarse` opts into the lower-power
+ * city-block-grade fix on platforms that distinguish (iOS reduced
+ * accuracy, Android `PRIORITY_BALANCED_POWER_ACCURACY`). The daemon
+ * aggregates across subscribers and forwards the most-demanding to the
+ * companion.
+ */
+export type GeoAccuracy = 'coarse' | 'fine';
+export type GeoError = 'permissionDenied' | 'unavailable' | 'unknownToken';
+export type HardwareError = 'levelOutOfRange' | 'modeMismatch';
+/**
+ * Snapshot of the device's hardware-controlled surfaces. Sent on
+ * `hardware.state.get` and re-broadcast on any change. `ambient_level`
+ * is the 0-255 ambient light reading.
+ */
+export type HardwareState = {
+    brightness: BrightnessState;
+    ambientLevel: number;
+};
+/**
+ * One header on an HTTP request or response. Key order is preserved
+ * across serialize/deserialize.
+ */
+export type HttpHeader = {
+    name: string;
+    value: string;
+};
+export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+/**
+ * An image delivered either as an opaque asset id (fetch via `asset.get`)
+ * or as inline bytes.
+ */
+export type Image = {
+    type: 'id';
+    data: string;
+} | {
+    type: 'bytes';
+    data: Uint8Array;
+};
+/**
+ * What kind of outbound call the accessory wants placed.
+ */
+export type InitiateCallType = 'destination' | 'voicemail' | 'redial';
+/**
+ * Coarse type tag a webapp uses to filter or branch. Mirrors the variant
+ * names of `LibraryItem`; kept separate so search/recommendations can
+ * constrain by kind without having to construct a sample item.
+ */
+export type ItemKind = 'track' | 'album' | 'playlist' | 'podcastEpisode' | 'show' | 'artist' | 'station';
+/**
+ * Stable URI + kind a webapp passes back to act on a library item
+ * (e.g. `player.play({ uri })`, `library.favorites.toggle({ item })`).
+ * `persistent_id` is the platform-stable id when the gateway has one;
+ * webapps treat it as opaque.
+ */
+export type ItemRef = {
+    uri: string;
+    kind: ItemKind;
+    persistentId: string | null;
+};
+export type LibraryError = {
+    type: 'notFound';
+    data: {
+        uri: string;
+    };
+} | {
+    type: 'notSupported';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'unauthorized';
+} | {
+    type: 'noGateway';
+};
+/**
+ * One playable / browsable item from the library. Lean per-variant
+ * payload - gateways translate platform-specific extras down to these
+ * fields, rare per-platform fields just don't surface. Forward-compat:
+ * adding new variants or fields is an additive change webapps can
+ * branch on.
+ */
+export type LibraryItem = {
+    type: 'track';
+    data: Track;
+} | {
+    type: 'album';
+    data: Album;
+} | {
+    type: 'playlist';
+    data: Playlist;
+} | {
+    type: 'podcastEpisode';
+    data: PodcastEpisode;
+} | {
+    type: 'show';
+    data: Show;
+} | {
+    type: 'artist';
+    data: Artist;
+} | {
+    type: 'station';
+    data: Station;
+};
+/**
+ * One log record. `ts_unix_s` is unix-epoch seconds. `target` is the
+ * tracing target / unit name; `message` is the rendered single-line
+ * body. Pre-filtered at subscription time so wire-bloating trace
+ * events don't reach webapps.
+ */
+export type LogEntry = {
+    tsUnixS: number;
+    level: LogLevel;
+    target: string;
+    message: string;
+};
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+/**
+ * What stream of log records a subscription pulls from. `Daemon` is the
+ * bridgething tracing subscriber; `System` is the `journald` view; `All`
+ * merges both in arrival order.
+ */
+export type LogSource = 'daemon' | 'system' | 'all';
+/**
+ * Currently-playing track, populated to the extent the gateway/iAP2
+ * stream has surfaced. All fields are optional because each one arrives
+ * as a separate attribute fetch on iAP2; the daemon accumulates and the
+ * snapshot reflects whatever's known so far.
+ */
+export type MediaItem = {
+    uri: string | null;
+    persistentId: string | null;
+    title: string | null;
+    album: string | null;
+    albumUri: string | null;
+    albumArtist: string | null;
+    artist: string | null;
+    artistUri: string | null;
+    liked: boolean | null;
+    artworkId: string | null;
+    durationMs: number | null;
+    mediaTypes: Array<MediaType> | null;
+    trackNumber: number | null;
+    trackCount: number | null;
+    isLikeSupported: boolean | null;
+    isBanSupported: boolean | null;
+    isBanned: boolean | null;
+    chapterCount: number | null;
+};
+/**
+ * Per-track attributes that vary per song. `persistent_id` is a stable
+ * per-platform identifier (iAP2 sends u64; we hex-encode it on the
+ * wire). `artwork_id` is an opaque asset id - webapps pass this value
+ * to `ClientToBridgeAssetMsg::Get` to retrieve the bytes. The id namespace
+ * is producer-defined: iAP2 emits `iap2/art/<persistent_hex>/<n>`, the
+ * companion picks whatever shape it wants (e.g. `spotify/track/<id>/image`).
+ * Webapps treat the value as opaque.
+ */
+export type MediaItemUpdate = {
+    persistentId: string | null;
+    title: string | null;
+    album: string | null;
+    albumUri: string | null;
+    albumArtist: string | null;
+    artist: string | null;
+    artistUri: string | null;
+    liked: boolean | null;
+    artworkId: string | null;
+    durationMs: number | null;
+    mediaTypes: Array<MediaType> | null;
+    trackNumber: number | null;
+    trackCount: number | null;
+    isLikeSupported: boolean | null;
+    isBanSupported: boolean | null;
+    isBanned: boolean | null;
+    isResidentOnDevice: boolean | null;
+    chapterCount: number | null;
+};
+/**
+ * The kind of media currently playing. Multi-typed: an item can be
+ * e.g. both `Podcast` and `AudioBook` (rare). Drives webapp UI choices
+ * like skip-15s-vs-skip-track and chapter UI.
+ */
+export type MediaType = 'music' | 'podcast' | 'audioBook';
+/**
+ * Which music service the companion is currently logged into and
+ * driving on behalf of the user. `None` when no glue is attached.
+ */
+export type MusicProvider = 'none' | 'spotify' | 'appleMusic' | 'tidal';
+export type NetError = {
+    type: 'requestFailed';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'timeout';
+} | {
+    type: 'unavailable';
+} | {
+    type: 'noGateway';
+};
+export type NetFetchRequest = {
+    url: string;
+    method: HttpMethod;
+    headers: Array<HttpHeader>;
+    body?: Uint8Array | null;
+    timeoutMs: number | null;
+    redirect: RedirectPolicy;
+};
+export type NetFetchResponse = {
+    status: number;
+    headers: Array<HttpHeader>;
+    body: Uint8Array;
+};
+/**
+ * What kind of network the companion's host is currently using. `metered`
+ * is the OS-reported metered flag; webapps should treat it as a hint
+ * (e.g. defer non-essential fetches) rather than a hard ban.
+ */
+export type NetworkInfo = {
+    kind: NetworkKind;
+    metered: boolean;
+};
+export type NetworkKind = 'unknown' | 'wifi' | 'cellular' | 'ethernet';
+/**
+ * One alternate interpretation the LLM surfaced alongside the primary.
+ * Populated when the LLM returns `ambiguous_alternates` in its
+ * json_schema output; consumed by the companion's CLARIFY UI so the
+ * user can pick.
+ */
+export type NluAlternate = {
+    intent: string;
+    slots: NluSlots | null;
+};
+/**
+ * Confidence the companion-side NLU pipeline attaches to a resolved
+ * intent: a coarse "low" | "medium" | "high" level per channel, one for
+ * the intent match and one for the extracted slots.
+ */
+export type NluConfidence = {
+    /**
+     * "low" | "medium" | "high". The LLM emits one of these per channel.
+     */
+    intent: string;
+    slots: string | null;
+};
+/**
+ * What the companion-side NLU resolved an utterance to, sent across
+ * the gateway link for the daemon to dispatch. This is the bridgething-
+ * native shape; the daemon's stock-compat layer wraps it into the
+ * SLIMO `NluMessage` envelope when the active webapp is stock.
+ *
+ * `transcript` is the ASR output the NLU ran on; carried so the daemon
+ * can echo it for telemetry and so SHOW+UNKNOWN+query="DJ"-style
+ * stock-compat fallbacks have the raw query available.
+ */
+export type NluResolvedIntent = {
+    intent: string;
+    slots: NluSlots;
+    transcript: string;
+    confidence: NluConfidence | null;
+    alternates: Array<NluAlternate> | null;
+};
+/**
+ * Slot catalog. Every intent projects through this flat shape;
+ * per-intent slot allowlists are enforced by the json_schema grammar at
+ * decode time, not by this struct. The wire payload omits absent slots,
+ * so a PLAY-with-artist row is just `{ "artist": "..." }` on the wire.
+ *
+ * String values are passed through verbatim from the user's transcript
+ * (no normalization at this layer); the SpotifyResolver may decorate
+ * the slots with a `uri` after catalog lookup.
+ */
+export type NluSlots = {
+    artist: string | null;
+    track: string | null;
+    album: string | null;
+    playlist: string | null;
+    podcast: string | null;
+    episode: string | null;
+    mood: string | null;
+    genre: string | null;
+    era: string | null;
+    popularityFilter: string | null;
+    entityType: string | null;
+    query: string | null;
+    /**
+     * WEBAPP_INTENT only: the filler-stripped natural-language command
+     * the active webapp's voice grammar handler will parse.
+     */
+    rawQuery: string | null;
+    /**
+     * WEBAPP_INTENT / OPEN_WEBAPP only.
+     */
+    webappId: string | null;
+    webappName: string | null;
+    /**
+     * PLAY_PRESET / SAVE_TO_PRESET only. String because users say "two"
+     * but stock SLIMO expects an Array<string> envelope - the stock
+     * translation wraps as needed.
+     */
+    preset: string | null;
+    /**
+     * VOLUME_UP / VOLUME_DOWN. "small" | "large" | numeric step.
+     */
+    amount: string | null;
+    /**
+     * VOLUME_ABSOLUTE. 0-100.
+     */
+    level: number | null;
+    /**
+     * Post-resolution Spotify URI. Populated by the companion's
+     * SpotifyResolver after the NLU stage; daemon dispatches directly
+     * to playback when set.
+     */
+    uri: string | null;
+};
+/**
+ * One notification surfaced from the connected companion's notification
+ * center. `id` is companion-stable for the lifetime of the notification
+ * - webapps pass it to `invokePositive`/`invokeNegative` and listen for
+ * `onNotificationRemoved`. Bodies (`title`/`subtitle`/`message`) are all
+ * optional because ANCS treats them as separate attribute fetches.
+ */
+export type Notification = {
+    id: string;
+    app: NotificationApp;
+    category: NotificationCategory;
+    title: string | null;
+    subtitle: string | null;
+    message: string | null;
+    timestampUnixS: number | null;
+    flags: NotificationFlags;
+    positiveAction: NotificationAction | null;
+    negativeAction: NotificationAction | null;
+};
+/**
+ * One ANCS-style action slot. `label` is the gateway-localized prompt
+ * the webapp renders on the action button.
+ */
+export type NotificationAction = {
+    label: string;
+};
+/**
+ * Originating app metadata. `bundle_id` is platform-stable
+ * (`com.apple.MobileSMS`, `com.spotify.client`, etc.); `display_name`
+ * and `icon_asset_id` are best-effort and may be missing on Android
+ * gateways that don't surface them cheaply.
+ */
+export type NotificationApp = {
+    bundleId: string;
+    displayName: string | null;
+    iconAssetId: string | null;
+};
+export type NotificationCategory = 'other' | 'incomingCall' | 'missedCall' | 'voicemail' | 'social' | 'schedule' | 'email' | 'news' | 'healthAndFitness' | 'businessAndFinance' | 'location' | 'entertainment';
+/**
+ * ANCS-shaped flags. `silent` mirrors the iOS "do not surface
+ * audibly" hint, `important` is the high-importance flag, and
+ * `pre_existing` is true for notifications that arrived before the
+ * daemon connected (replayed by the companion on first sync).
+ */
+export type NotificationFlags = {
+    silent: boolean;
+    important: boolean;
+    preExisting: boolean;
+};
+/**
+ * Delta event the companion or iAP2 stream emits whenever a player
+ * attribute changes. Every field is optional: producers send partial
+ * updates populating only what changed, and fields left unset keep
+ * their prior value.
+ */
+export type NowPlayingUpdate = {
+    mediaItem: MediaItemUpdate | null;
+    playback: PlaybackUpdate | null;
+};
+export type NumberField = {
+    key: string;
+    label: string;
+    min: number | null;
+    max: number | null;
+    step: number | null;
+    default: number | null;
+};
+export type OtaError = {
+    code: OtaErrorCode;
+    msg: string;
+};
+/**
+ * Terminal error from the OTA orchestrator. After an `OtaError` the
+ * orchestrator is back to idle and a fresh `OtaBegin` may be sent.
+ */
+export type OtaErrorCode = 'unknownUpdate' | 'offsetMismatch' | 'hashMismatch' | 'sizeMismatch' | 'cancelled' | 'writeFailed' | 'confirmFailed' | 'internal';
+/**
+ * What the streamed bytes are going to be applied as.
+ *
+ * `Image` streams a `.swu` through libswupdate + slot flip + reboot.
+ * `Daemon` streams a fresh aarch64 daemon binary, atomic-rotates on
+ * the bandaid bind-mount, restarts the service. `BuiltinWebapp`
+ * streams a zip bundle of hub or stock, validates the manifest id is
+ * one of the reserved built-ins, atomic-rotates the bundle dir on the
+ * bandaid bind-mount, restarts the service. `InstalledWebapp` streams
+ * a zip bundle of a third-party (non-reserved) webapp and installs it
+ * into the writable registry; it neither stages on the bandaid nor
+ * restarts, and is never part of an `OtaActivate` batch.
+ *
+ * Companions key reboot expectations off this: image means the device
+ * power-cycles; daemon and builtin-webapp mean the daemon process
+ * restarts and the gateway link drops and reconnects; installed-webapp
+ * applies in place with no restart, and the terminal signal is the
+ * `WebappInstalled` event (or an `OtaError`).
+ */
+export type OtaKind = 'image' | 'daemon' | 'builtinWebapp' | 'installedWebapp';
+/**
+ * Stage of the OTA orchestrator. The phase set is shared between
+ * kinds, with non-image kinds emitting a subset.
+ *
+ * Image: `Streaming` -> `Verifying` -> `Writing` (libswupdate to slot)
+ * -> `Confirming` (try-counter reset) -> `Reboot`.
+ *
+ * Daemon and BuiltinWebapp: `Streaming` -> `Verifying` -> `Writing`,
+ * where `Writing`/100 means the piece is validated and staged on the
+ * bandaid (not yet live). The atomic rotate and the single `systemctl
+ * restart` happen later, on `OtaActivate`, which emits the terminal
+ * `Reboot` for the whole batch. `Confirming` is image-only.
+ *
+ * InstalledWebapp: `Streaming` -> `Verifying` -> `Writing`/0 while the
+ * bundle installs into the writable registry. There is no `Writing`/100,
+ * no `Confirming`, and no `Reboot`; the terminal signal is the
+ * `WebappInstalled` event (or an `OtaError`).
+ */
+export type OtaPhase = 'streaming' | 'verifying' | 'writing' | 'confirming' | 'reboot';
+/**
+ * Per-phase progress tick. `percent` is 0-100 within the current
+ * phase, not the overall flow. `eta_ms` is best-effort remaining time
+ * for the phase when the orchestrator can compute it.
+ */
+export type OtaProgress = {
+    phase: OtaPhase;
+    percent: number;
+    etaMs: number | null;
+};
+export type Peer = {
+    device: Device;
+    paired: boolean;
+    iap2: PeerIap2Status;
+    companion: PeerCompanionStatus;
+    displayName: string | null;
+    language: string | null;
+    uuid: string | null;
+};
+export type PeerCompanionStatus = {
+    type: 'none';
+} | {
+    type: 'pending';
+} | {
+    type: 'connected';
+    data: GatewayInfo;
+};
+export type PeerIap2Status = 'none' | 'linkUp' | 'authenticated' | 'identified';
+/**
+ * One telephony call. `call_id` is companion-stable for the call's
+ * lifetime; webapps pass it back to `answer`/`decline`/`end`/`hold`.
+ * `remote_id` is the raw E.164 (or platform raw); `display_name` is the
+ * gateway's resolved contact name when available.
+ */
+export type PhoneCall = {
+    callId: string;
+    remoteId: string;
+    displayName: string;
+    status: PhoneCallStatus;
+    direction: PhoneCallDirection;
+    startedAtUnixS: number | null;
+    label: string | null;
+    addressBookId: string | null;
+    service: PhoneCallService | null;
+    isConferenced: boolean | null;
+    conferenceGroup: number | null;
+};
+export type PhoneCallDirection = 'incoming' | 'outgoing';
+/**
+ * Call bearer / service kind. iAP2's `CallStateUpdateService` enum
+ * values, projected to our wire surface. Companion gateways that don't
+ * distinguish bearers project all calls to `Telephony`.
+ */
+export type PhoneCallService = 'unknown' | 'telephony' | 'faceTimeAudio' | 'faceTimeVideo';
+export type PhoneCallStatus = 'disconnected' | 'sending' | 'ringing' | 'connecting' | 'active' | 'held' | 'disconnecting';
+export type PhoneError = {
+    type: 'callNotFound';
+    data: {
+        call_id: string;
+    };
+} | {
+    type: 'actionRejected';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'noTarget';
+} | {
+    type: 'unavailable';
+    data: {
+        verb: string;
+    };
+};
+/**
+ * Snapshot of every active call known to the gateway. Multi-call is
+ * possible (call-waiting, conference) - webapps rendering only one
+ * active call typically pick the first non-Held entry.
+ */
+export type PhoneState = {
+    activeCalls: Array<PhoneCall>;
+};
+/**
+ * Optional context for `play({ uri })`. `context_uri` is the album /
+ * playlist / show URI the track is being played from; gateways with
+ * playlist support honor it for skip-next semantics. `position` is the
+ * 0-based index inside the context.
+ */
+export type PlayContext = {
+    contextUri: string;
+    position: number | null;
+};
+/**
+ * Per-session playback snapshot: where in the song we are, what mode is
+ * engaged. `position_ms` is the live playhead at snapshot time; webapps
+ * extrapolate forward locally while `state == Playing`.
+ *
+ * `set_elapsed_time_available` gates scrub UI: when false, the foreground
+ * app refuses absolute-position seeks and webapps must disable the scrub
+ * thumb. `None` means unknown (no signal received yet); webapps treat
+ * unknown as "available" for backward compatibility with older gateways.
+ */
+export type Playback = {
+    state: PlaybackState;
+    positionMs: number;
+    positionAgeMs: number | null;
+    shuffle: boolean;
+    shuffleMode: ShuffleMode | null;
+    repeat: RepeatMode;
+    queueIndex: number | null;
+    queueCount: number | null;
+    queueChapterIndex: number | null;
+    setElapsedTimeAvailable: boolean | null;
+    queueListAvail: boolean | null;
+    appleMusicRadioAd: boolean | null;
+};
+/**
+ * What the current track is playing from: the playlist / album / show /
+ * artist context. Webapps render "playing from <name>"; `uri` lets them
+ * drill into it. `name` is `None` until the companion resolves it.
+ */
+export type PlaybackContext = {
+    uri: string;
+    name: string | null;
+};
+/**
+ * Repeat and shuffle toggle state.
+ */
+export type PlaybackOptions = {
+    repeat: RepeatMode;
+    shuffle: boolean;
+};
+/**
+ * A resolved queue: the current track flanked by upcoming and previous tracks.
+ */
+export type PlaybackQueue = {
+    next: Array<Track>;
+    current: Track;
+    previous: Array<Track>;
+};
+/**
+ * Which player controls the current source supports; webapps disable the
+ * UI for any capability that is `false`.
+ */
+export type PlaybackRestrictions = {
+    can_repeat_context: boolean;
+    can_repeat_track: boolean;
+    can_seek: boolean;
+    can_skip_next: boolean;
+    can_skip_prev: boolean;
+    can_toggle_shuffle: boolean;
+    can_like: boolean;
+    can_change_volume: boolean;
+    can_set_output: boolean;
+};
+/**
+ * Three-state playback. `Stopped` is the no-track-loaded resting state;
+ * `Paused` is "track is loaded, position is held"; `Playing` is the
+ * progressing state.
+ */
+export type PlaybackState = 'stopped' | 'paused' | 'playing';
+/**
+ * Per-playback-session attributes that vary regardless of track:
+ * playing/paused, position, shuffle/repeat, and the iOS bundle
+ * identifier of the app currently driving playback (e.g.
+ * `"com.spotify.client"`). `app_bundle` is null on the Android path
+ * since it isn't a meaningful surface there.
+ *
+ * `set_elapsed_time_available` is the gate webapps must honor for
+ * scrub UI: when false, scrubbing is unsupported by the foreground
+ * app and the seek button must be disabled.
+ */
+export type PlaybackUpdate = {
+    playing: boolean | null;
+    positionMs: number | null;
+    shuffle: boolean | null;
+    shuffleMode: ShuffleMode | null;
+    repeat: RepeatMode | null;
+    appBundle: string | null;
+    appDisplayName: string | null;
+    queueIndex: number | null;
+    queueCount: number | null;
+    queueChapterIndex: number | null;
+    playbackSpeed: number | null;
+    setElapsedTimeAvailable: boolean | null;
+    queueListAvail: boolean | null;
+    appleMusicRadioAd: boolean | null;
+    appleMusicRadioStationName: string | null;
+};
+export type PlayerError = {
+    type: 'schemeUnclaimed';
+    data: {
+        scheme: string;
+    };
+} | {
+    type: 'playFailed';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'noGateway';
+} | {
+    type: 'notInQueue';
+    data: {
+        index: number;
+    };
+};
+/**
+ * User-tunable knobs that are not "currently playing" state.
+ * `crossfade_ms = None` is "crossfade off"; `Some(0)` is also off but
+ * distinguishes "user explicitly set zero" from "feature unsupported by
+ * gateway".
+ */
+export type PlayerOptions = {
+    speed: number;
+    crossfade_ms: number | null;
+};
+/**
+ * Full player snapshot the daemon broadcasts to webapps. Initial value
+ * arrives on `BridgeToClientPlayerMsg::StateChange` at connect time;
+ * subsequent changes flow as `NowPlayingUpdate` deltas the client SDK
+ * merges into the cached snapshot.
+ */
+export type PlayerState = {
+    track: MediaItem | null;
+    playback: Playback;
+    queue: Array<QueueItem>;
+    options: PlayerOptions;
+    context: PlaybackContext | null;
+};
+/**
+ * Lean cross-platform shape for a playlist. `uri` is what `player.play`
+ * would route on; `track_count` is best-effort (some sources don't expose
+ * it cheaply); `owner_name` is whatever the source surfaces (Spotify
+ * owner, Apple Music curator, etc.).
+ */
+export type Playlist = {
+    uri: string;
+    name: string;
+    ownerName: string | null;
+    trackCount: number | null;
+    artworkId: string | null;
+};
+/**
+ * One episode of a podcast. `show_name` mirrors what the gateway exposes
+ * at episode-level so a webapp can render show + episode without a
+ * separate fetch. `published_at_ms` is best-effort; not every gateway
+ * surfaces it.
+ */
+export type PodcastEpisode = {
+    uri: string;
+    name: string;
+    showName: string | null;
+    durationMs: number | null;
+    publishedAtUnixS: number | null;
+    artworkId: string | null;
+};
+/**
+ * One position fix from the gateway. `accuracy_m` is the 1-sigma
+ * horizontal radius. `speed_mps` and `heading_deg` are populated when
+ * the underlying source provides them (CLLocation on iOS does for moving
+ * fixes; Android's FusedLocationProvider similar). `ts_ms` is the
+ * gateway-provided fix timestamp, not the wire-arrival time.
+ */
+export type Position = {
+    lat: number;
+    lon: number;
+    altM: number | null;
+    accuracyM: number;
+    speedMps: number | null;
+    headingDeg: number | null;
+    tsUnixS: number;
+};
+export type Priority = 'normal' | 'bulk' | 'background';
+/**
+ * One row in the player queue. Lean cross-platform shape - gateways
+ * that have richer per-track data still surface what fields they have.
+ * `uri` is required because every queued item must be addressable for
+ * `skipToIndex`. `persistent_id` is the platform-stable id when
+ * available; webapps treat it as opaque.
+ */
+export type QueueItem = {
+    uri: string;
+    title: string | null;
+    artist: string | null;
+    artistUri: string | null;
+    album: string | null;
+    albumUri: string | null;
+    artworkId: string | null;
+    durationMs: number | null;
+    persistentId: string | null;
+    queued: boolean;
+};
+/**
+ * Where in the queue a `queue({ uri })` should land. `Append` (default)
+ * goes at the end; `Next` is play-next; `Index` is an explicit position.
+ */
+export type QueuePosition = {
+    type: 'append';
+} | {
+    type: 'next';
+} | {
+    type: 'index';
+    data: number;
+};
+/**
+ * Resolved range the companion is about to serve. `start` and `length`
+ * echo the corresponding `RangeSpec`; the bytes follow in the reply's
+ * `TransferBody`.
+ */
+export type RangePart = {
+    start: number;
+    length: number;
+};
+/**
+ * Half-open byte range the daemon's range proxy asks the companion
+ * to serve. Mirrors HTTP `Range: bytes=start-end` semantics: `start`
+ * inclusive, `length` bytes. The proxy caps the multi-range count at
+ * the daemon edge (loopback) - companions see whatever swupdate's
+ * delta downloader emits. Offsets are u32 because OTA artifacts are
+ * bounded at 4 GiB end-to-end (matches `OtaBegin.expected_size`).
+ */
+export type RangeSpec = {
+    start: number;
+    length: number;
+};
+/**
+ * Page of recommendation results. Gateway decides how seed + kind
+ * interact (Spotify uses radio-style seeding, Apple Music uses curated
+ * rails) - the daemon doesn't prescribe.
+ */
+export type RecommendationsResult = {
+    items: Array<LibraryItem>;
+    total: number | null;
+    hasMore: boolean;
+};
+export type RedirectPolicy = 'follow' | 'manual' | 'error';
+/**
+ * Cellular registration state - populated from iAP2 `CommunicationsUpdate`
+ * or the companion's equivalent.
+ */
+export type RegistrationStatus = 'unknown' | 'notRegistered' | 'searching' | 'denied' | 'registeredHome' | 'registeredRoaming' | 'emergencyCallsOnly';
+/**
+ * `repeat` is a typed enum (Off/All/One) shared across the player
+ * surface and the iAP2 NowPlaying CSM / MediaSession backends, which
+ * all expose three repeat states.
+ */
+export type RepeatMode = 'off' | 'all' | 'one';
+/**
+ * Page of search results. `kinds` is the constrained kinds the search
+ * honored (echoed back so webapps can detect ignored constraints); items
+ * are ranked best-first.
+ */
+export type SearchResult = {
+    items: Array<LibraryItem>;
+    kinds: Array<ItemKind>;
+    total: number | null;
+    hasMore: boolean;
+};
+/**
+ * One podcast show (parent of `PodcastEpisode`). `episode_count` is
+ * best-effort.
+ */
+export type Show = {
+    uri: string;
+    name: string;
+    publisher: string | null;
+    episodeCount: number | null;
+    artworkId: string | null;
+};
+/**
+ * Three-state shuffle. iAP2 and Apple Music distinguish track-level
+ * from album-level shuffle; companion gateways without that distinction
+ * project to `Songs` when on. Webapps that just need an on/off signal
+ * read `shuffle_on` (None when the underlying mode is unknown).
+ */
+export type ShuffleMode = 'off' | 'songs' | 'albums';
+/**
+ * Algorithmic / radio station. `seed` is the URI the station was seeded
+ * from when known (artist, track, etc.).
+ */
+export type Station = {
+    uri: string;
+    name: string;
+    seed: string | null;
+    artworkId: string | null;
+};
+/**
+ * First event of an open stream. Carries the response status, headers,
+ * and (when known) total payload size so the consumer can preallocate
+ * or display progress. Subsequent `StreamChunk` and `StreamEnd` events
+ * for the same `stream_id` follow.
+ */
+export type StreamBegin = {
+    streamId: string;
+    status: number;
+    headers: Array<HttpHeader>;
+    totalSize: number | null;
+};
+/**
+ * One body chunk. Chunks arrive in order; `offset` is the byte
+ * position of `bytes[0]` within the full body.
+ */
+export type StreamChunk = {
+    streamId: string;
+    offset: number;
+    bytes: Uint8Array;
+};
+/**
+ * Terminates a stream. After `End` no further chunks for `stream_id`
+ * are valid and the daemon clears its routing entry.
+ */
+export type StreamEnd = {
+    streamId: string;
+};
+/**
+ * Stream failed mid-flight (or before the first byte). Terminal - the
+ * daemon clears its routing entry. The `error` shape is shared with
+ * `fetch` since the failure modes are identical.
+ */
+export type StreamError = {
+    streamId: string;
+    error: NetError;
+};
+export type StringField = {
+    key: string;
+    label: string;
+    pattern: string | null;
+    minLength: number | null;
+    maxLength: number | null;
+    default: string | null;
+};
+/**
+ * Bool feature flags the daemon exposes to webapps. Each is true when the
+ * surface has both a backing implementation and (where applicable) a
+ * connected companion claiming to provide it. False = the surface will
+ * respond `Unsupported` or `Unimplemented` to verbs.
+ */
+export type SurfaceAvailability = {
+    geo: boolean;
+    notifications: boolean;
+    netFetch: boolean;
+    netWs: boolean;
+    audioTts: boolean;
+    lyrics: boolean;
+};
+/**
+ * Wall clock + locale snapshot. `wall_clock_unix_s` is the gateway's
+ * (or iAP2 device's) claimed "now" in unix-epoch seconds - webapps
+ * reading time should use the device clock if any but use this as the
+ * trust anchor on first arrival.
+ *
+ * Two zone-identification paths coexist: companion gateways send
+ * `tz_iana` (an IANA zone identifier like `America/Denver`) while iAP2
+ * `DeviceTimeUpdate` only exposes numeric `utc_offset_minutes` plus a
+ * separate `dst_offset_minutes`. Webapps prefer `tz_iana` when present
+ * and fall back to the offset pair.
+ */
+export type TimeInfo = {
+    tzIana: string | null;
+    locale: string | null;
+    wallClockUnixS: number | null;
+    utcOffsetMinutes: number | null;
+    dstOffsetMinutes: number | null;
+};
+/**
+ * A track with resolved album/artist metadata, used by library search
+ * and browse results. For live now-playing state see `MediaItem`.
+ */
+export type Track = {
+    id: string;
+    name: string;
+    album: Album;
+    /**
+     * Primary credited artist.
+     */
+    artist: Artist;
+    /**
+     * All credited artists, in order.
+     */
+    artists: Array<Artist>;
+    duration_ms: number;
+    /**
+     * Opaque artwork asset id; pass to `asset.get` for the bytes.
+     */
+    image_id: string;
+    /**
+     * Whether the track is saved in the user's library.
+     */
+    saved: boolean;
+};
+export type TtlRetention = {
+    seconds: number;
+};
+export type TunnelClosed = {
+    tunnelId: string;
+    reason: string | null;
+};
+export type TunnelData = {
+    tunnelId: string;
+    bytes: Uint8Array;
+};
+export type TunnelError = {
+    type: 'connectFailed';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'permissionDenied';
+} | {
+    type: 'unavailable';
+};
+/**
+ * One TTS voice the companion's audio backend can speak as. `id` is
+ * platform-opaque (Apple/Android voice id); `locale` is BCP-47.
+ */
+export type VoiceDescriptor = {
+    id: string;
+    name: string;
+    locale: string;
+};
+/**
+ * Why dispatch declined to act on a `VoiceDispatch`. The companion
+ * surfaces these to the user (toast / UI hint); the daemon does not
+ * otherwise retain state about the failure.
+ */
+export type VoiceDispatchErrorCode = 'webappNotInstalled' | 'webappNotActive' | 'webappRefused' | 'notDispatchable' | 'playbackFailed' | 'internal';
+/**
+ * Where the daemon actually routed a successful dispatch. Carried back
+ * to the companion so it can render the right confirmation UI.
+ */
+export type VoiceDispatchTarget = 'stockPlayback' | 'activeWebapp' | 'webappSwitch';
+/**
+ * Domain errors emitted by any webapp surface (gateway- or client-side).
+ * Single catalog: both protocols speak the same variant set.
+ */
+export type WebappError = {
+    type: 'webappNotFound';
+    data: {
+        id: string;
+    };
+} | {
+    type: 'cannotUninstallBuiltin';
+    data: {
+        id: string;
+    };
+} | {
+    type: 'idReserved';
+    data: {
+        id: string;
+    };
+} | {
+    type: 'extractedTooLarge';
+    data: {
+        max_bytes: number;
+    };
+} | {
+    type: 'zipMalformed';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'missingIndexHtml';
+} | {
+    type: 'invalidManifest';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'iconNotAvailable';
+    data: {
+        id: string;
+    };
+} | {
+    type: 'unknownConfigKey';
+    data: {
+        key: string;
+    };
+} | {
+    type: 'invalidConfigValue';
+    data: {
+        key: string;
+        reason: string;
+    };
+} | {
+    type: 'internal';
+    data: {
+        reason: string;
+    };
+};
+export type WebappInfo = {
+    id: string;
+    name: string;
+    source: WebappSource;
+    role: WebappRole;
+    version: string;
+    description: string | null;
+    iconAvailable: boolean;
+    iconMime: string | null;
+    /**
+     * icon bytes, inlined on the gateway list so the companion never round-trips
+     * a separate fetch per app. omitted on the on-device client list.
+     */
+    icon?: Uint8Array | null;
+    config: Array<ConfigField>;
+    permissions: Array<string>;
+    /**
+     * Plain-English description of the voice intents the webapp wants
+     * WEBAPP_INTENT routing for. Companion-side NLU folds this into the
+     * "currently active extensions" section of the system prompt at
+     * inference, which is what makes WEBAPP_INTENT emission context-aware.
+     * `None` opts the webapp out of voice integration.
+     */
+    voiceGrammar: string | null;
+    /**
+     * Declared art render sizes; the companion warms exactly these. `None`
+     * means the canonical `{248, 96}` default applies.
+     */
+    art: ArtProfile | null;
+};
+/**
+ * On-disk `manifest.json` shape. Read from the bundle at install time
+ * and validated; the resulting metadata projects to `WebappInfo` for
+ * the wire.
+ */
+export type WebappManifest = {
+    id: string;
+    name: string;
+    version: string;
+    description: string | null;
+    icon: string | null;
+    role: WebappRole;
+    config: Array<ConfigField>;
+    permissions: Array<string>;
+    /**
+     * Optional plain-English description of the voice commands this
+     * webapp wants WEBAPP_INTENT routing for. The companion's NLU folds
+     * the grammars of all installed-and-active webapps into the system
+     * prompt at inference. Webapps that don't declare a grammar opt out
+     * of voice integration.
+     */
+    voiceGrammar: string | null;
+    /**
+     * Declared art render sizes. Omitted falls back to `{248, 96}`.
+     */
+    art?: ArtProfile | null;
+};
+/**
+ * A webapp's launcher visibility. `Standard` shows up in user-facing
+ * listings (the hub grid, etc); `Launcher` is itself a launcher and is
+ * hidden from those listings. The daemon filters `Launcher` bundles
+ * out of `client.webapp.list`; the gateway list keeps everything.
+ */
+export type WebappRole = 'standard' | 'launcher';
+export type WebappSource = 'builtin' | 'installed';
+export type WsError = {
+    type: 'connectFailed';
+    data: {
+        reason: string;
+    };
+} | {
+    type: 'frameTooLarge';
+} | {
+    type: 'gatewayDisconnected';
+} | {
+    type: 'protocolError';
+    data: {
+        reason: string;
+    };
+};
+export type WsFrame = {
+    type: 'text';
+    data: string;
+} | {
+    type: 'binary';
+    data: Uint8Array;
+};
+//# sourceMappingURL=shared.d.ts.map