Preparing search index...

    Interface TrackProperties

    Per-track metadata.

    The time range, point count and resolution describe what was returned rather than what was asked for, so a client can always tell whether it received a simplified track and ask again for more detail.

    interface TrackProperties {
        pointCount: number;
        appliedProperties?: Path[];
        bbox?: TrackBoundingBox;
        context?: Context;
        contextName?: string;
        coordTimes?: string[][];
        epsilon?: number;
        from?: string;
        id?: string;
        imported?: string;
        isSelf?: boolean;
        name?: string;
        providerId?: string;
        resolution?: string;
        to?: string;
        values?: Record<string, (string | number | null)[][]>;
        [key: string]: unknown;
    }

    Indexable

    • [key: string]: unknown

      Whatever else a stored track carries: the metadata a client posted with it, returned as it was stored.

    Index
    pointCount: number

    Number of points returned across all segments.

    appliedProperties?: Path[]

    Which of the requested TracksRequest.properties the provider actually returned.

    Reported rather than inferred, for the same reason resolution and epsilon are: a client must be able to tell "this provider does not have that path" from "that path had no values in this window".

    Bounding box of the returned geometry, [west, south, east, north].

    context?: Context

    The Signal K context this track belongs to, when it has one.

    Absent for an imported track that names no vessel — a GPX a friend sent, with no MMSI in it. Such a track is still a track: a recorded series of positions, which is what this API serves. What it is not is a claim about a vessel in the data model, so it carries no context rather than an invented one.

    contextName?: string

    Name of the vessel, aircraft or other context, when known.

    Not the name of the track — see name for that. A track recorded from position data has no name of its own; an imported one usually does.

    coordTimes?: string[][]

    Recording time of every point, ISO 8601 UTC, nested to match geometry.coordinates: coordTimes[i][j] is when coordinates[i][j] was recorded.

    Follows the coordTimes convention used by GPX-to-GeoJSON converters, which RFC 7946 permits as a foreign member of properties. The nesting for MultiLineString is specified here because the convention only covers LineString.

    epsilon?: number

    Simplification tolerance actually applied, in metres.

    from?: string

    Time of the first returned point.

    Absent for a track whose points carry no times — an imported GPX without <time> is a shape someone sailed, with no recording times to report. Present for everything a provider recorded itself.

    id?: string

    Identifies this track within the provider that holds it.

    Stable for as long as the track exists. A provider mints it and receives it back unchanged in getTrack and deleteTrack; the server prefixes its registry name to form the providerId:trackId a client addresses, so a provider never has to know what it is registered as.

    A recorded track may derive it from the context; an imported one has nothing to derive it from and gets an opaque id.

    Optional because not every provider identifies tracks as objects. One serving a time-and-context query out of history has no handle to mint and implements neither getTrack nor deleteTrack; requiring an id there would mean inventing one that addresses nothing.

    imported?: string

    When a client added this track with TrackApi.storeTrack (POST /tracks), as an ISO 8601 time. Absent on a track the provider recorded itself.

    Set by the provider; a value in a posted track is ignored.

    isSelf?: boolean

    Whether this is the own vessel's track.

    Absent along with context: a track that names no vessel cannot be the own vessel's, and saying false would imply the question was asked of a vessel that exists.

    name?: string

    The track's own name, when it has one.

    A GPX <trk><name> survives an import here. Recorded tracks have no name until someone gives them one, which is why this is separate from contextName rather than overloading it.

    providerId?: string

    Which registered provider answered for this track.

    Set by the server from the registry, so a provider neither has to name itself nor can name itself wrongly. Every registered provider is queried and their features concatenated, so a vessel recorded by two of them yields two features, and this is what tells them apart.

    resolution?: string

    Spacing actually applied, as an ISO 8601 duration.

    to?: string

    Time of the last returned point, absent whenever from is.

    values?: Record<string, (string | number | null)[][]>

    Values for each requested path, keyed by path and nested to match coordinates: values[path][i][j] belongs with coordinates[i][j].

    A position with no value for a path at that instant carries null rather than being omitted, so the arrays stay aligned.