@telemetryos/root-sdk 1.2.0 → 1.4.0

package/dist/media.d.ts

@@ -30,42 +30,31 @@ export declare class Media {
     _client: Client;
     constructor(client: Client);
     /**
-     * Queries for media folders based on folder properties.
+     * Retrieves all media folders in the account.
      *
-     * This method allows you to search for media folders that match specific criteria,
-     * such as name, ID, or other folder properties.
-     *
-     * @param query An object with partial MediaFolder properties to match against
-     * @returns A promise that resolves to an array of matching media folders
-     */
-    queryFolders(query: Partial<MediaFolder>): Promise<MediaFolder[]>;
-    /**
-     * Retrieves media folders that have been tagged with a specific tag.
-     *
-     * @param tagName The name of the tag to search for
-     * @returns A promise that resolves to an array of media folders with the specified tag
+     * @returns A promise that resolves to an array of all media folders
      */
-    getFoldersByTag(tagName: string): Promise<MediaFolder[]>;
+    getAllFolders(): Promise<MediaFolder[]>;
     /**
-     * Retrieves a specific media folder by its ID.
+     * Retrieves all media content within a specific folder.
      *
-     * @param id The unique identifier of the folder to retrieve
-     * @returns A promise that resolves to the media folder with the specified ID
+     * @param folderId The unique identifier of the folder
+     * @returns A promise that resolves to an array of media content in the folder
      */
-    getFolderById(id: string): Promise<MediaFolder>;
+    getAllByFolderId(folderId: string): Promise<MediaContent[]>;
     /**
-     * Retrieves all media content items within a specific folder.
+     * Retrieves media content that has been tagged with a specific tag.
      *
-     * @param folderId The unique identifier of the folder to get content from
-     * @returns A promise that resolves to an array of media content items in the folder
+     * @param tagName The name of the tag to search for
+     * @returns A promise that resolves to an array of media content with the specified tag
      */
-    getMediaContentByFolderId(folderId: string): Promise<MediaContent[]>;
+    getAllByTag(tagName: string): Promise<MediaContent[]>;
     /**
      * Retrieves a specific media content item by its ID.
      *
      * @param id The unique identifier of the media content to retrieve
-     * @returns A promise that resolves to the media content item with the specified ID
+     * @returns A promise that resolves to the media content with the specified ID
      */
-    getMediaContentById(id: string): Promise<MediaContent>;
+    getById(id: string): Promise<MediaContent>;
 }
 export {};

package/dist/proxy.d.ts

@@ -0,0 +1,48 @@
+import { Client } from './client.js';
+/**
+ * Provides a proxy API for fetching third-party content through the TelemetryOS proxy service.
+ *
+ * This API allows applications to fetch content from external URLs through the platform's
+ * proxy service, which handles authentication, caching, bandwidth quotas, and CORS issues.
+ * The proxy is useful for accessing external APIs or content that may have CORS restrictions.
+ */
+export declare class Proxy {
+    _client: Client;
+    constructor(client: Client);
+    /**
+     * Fetches content from an external URL through the TelemetryOS proxy service.
+     *
+     * This method has the same interface as the native `fetch()` API but routes the request through
+     * the platform's proxy service. This is useful for:
+     * - Accessing external APIs that have CORS restrictions
+     * - Fetching content with platform authentication
+     * - Benefiting from platform caching and bandwidth management
+     * - Proxying content from external sources
+     *
+     * @param input The URL to fetch from (as a string or URL object)
+     * @param init Optional fetch options (method, headers, body, signal, etc.)
+     * @returns A promise that resolves to a standard Response object
+     *
+     * @example
+     * // Fetch JSON from an external API
+     * const response = await proxy().fetch('https://api.example.com/data');
+     * const data = await response.json();
+     *
+     * @example
+     * // POST data to an external API
+     * const response = await proxy().fetch('https://api.example.com/submit', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: JSON.stringify({ key: 'value' })
+     * });
+     *
+     * @example
+     * // Fetch an image through the proxy
+     * const response = await proxy().fetch('https://example.com/image.jpg');
+     * const blob = await response.blob();
+     * const imageUrl = URL.createObjectURL(blob);
+     */
+    fetch(input: string, init?: RequestInit): Promise<Response>;
+    fetch(input: URL, init?: RequestInit): Promise<Response>;
+    fetch(input: Request, init?: RequestInit): Promise<Response>;
+}

package/dist/root-settings-navigation.d.ts

@@ -12,7 +12,7 @@ type RootSettingsNavigationOpts = {
     entries: RootSettingsNavigationEntry[];
 };
 export type RootSettingsApplicationNavigationState = {
-    applicationId: string;
+    applicationSpecifier: string;
     entries: RootSettingsNavigationEntry[];
 };
 type RootSettingsNavigationState = Record<string, RootSettingsApplicationNavigationState>;

package/dist/users.d.ts

@@ -2,9 +2,6 @@ import { Client } from './index.js';
 type CurrentUser = {
     id: string;
 };
-type GetCurrentUserResult = {
-    user: CurrentUser;
-};
 export declare class Users {
     _client: Client;
     constructor(client: Client);
@@ -20,6 +17,6 @@ export declare class Users {
      * const userResult = await users.getCurrent();
      * console.log(`Current user ID: ${userResult.user.id}`);
      */
-    getCurrent(): Promise<GetCurrentUserResult>;
+    getCurrent(): Promise<CurrentUser>;
 }
 export {};

package/dist/weather.d.ts

@@ -0,0 +1,214 @@
+import type { Client } from './client.js';
+/**
+ * Weather condition data with current conditions
+ */
+export type WeatherConditions = {
+    /** City name (localized) */
+    CityLocalized: string;
+    /** City name (English) */
+    CityEnglish: string;
+    /** Wind abbreviation */
+    WindAbbr: string;
+    /** ISO country code */
+    CountryCode: string;
+    /** Timezone */
+    Timezone: string;
+    /** Weather description text */
+    WeatherText: string;
+    /** State/Province */
+    State: string;
+    /** Part of day (day/night indicator) */
+    Pod: string;
+    /** Weather code (internal mapping) */
+    WeatherCode: string;
+    /** Wind direction in degrees */
+    WindDirectionDegrees: string;
+    /** Wind direction (cardinal direction in English) */
+    WindDirectionEnglish: string;
+    /** Wind direction (localized) */
+    WindDirectionLocalized: string;
+    /** Relative humidity percentage */
+    RelativeHumidity: number;
+    /** Unix timestamp */
+    Timestamp: number;
+    /** Longitude */
+    Longitude: number;
+    /** Latitude */
+    Latitude: number;
+    /** Temperature */
+    Temp: number;
+    /** Atmospheric pressure */
+    Pressure: number;
+    /** Wind speed */
+    WindSpeed: number;
+    /** Visibility distance */
+    Visibility: number;
+    /** Precipitation amount */
+    Precip: number;
+};
+/**
+ * Weather forecast data point
+ */
+export type WeatherForecast = {
+    /** ISO datetime string */
+    Datetime: string;
+    /** Part of day (day/night indicator) */
+    Pod: string;
+    /** Weather description label */
+    Label: string;
+    /** Weather code */
+    WeatherCode: string;
+    /** Unix timestamp */
+    Timestamp: number;
+    /** Temperature */
+    Temp: number;
+    /** Minimum temperature */
+    MinTemp: number;
+    /** Maximum temperature */
+    MaxTemp: number;
+};
+/**
+ * Parameters for weather requests
+ */
+export type WeatherRequestParams = {
+    /** City name (can include state/country: "city, state, country") */
+    city?: string;
+    /** Postal/ZIP code (alternative to city) */
+    postalCode?: string;
+    /** Latitude (if city not provided) */
+    lat?: string;
+    /** Longitude (if city not provided) */
+    lon?: string;
+    /** Units system: "imperial" or "metric" */
+    units?: 'imperial' | 'metric';
+    /** Language code for localized responses */
+    language?: string;
+};
+/**
+ * Parameters for daily forecast requests
+ */
+export type DailyForecastParams = WeatherRequestParams & {
+    /** Number of days to forecast */
+    days?: number;
+};
+/**
+ * Parameters for hourly forecast requests
+ */
+export type HourlyForecastParams = WeatherRequestParams & {
+    /** Number of hours to forecast */
+    hours?: number;
+};
+/**
+ * Weather API for retrieving weather data from various providers
+ *
+ * Provides access to current conditions and forecasts from WeatherBit
+ * and AccuWeather through the General Integrations Service.
+ */
+export declare class Weather {
+    _client: Client;
+    constructor(client: Client);
+    /**
+     * Retrieves current weather conditions for a specified location using WeatherBit.
+     *
+     * @param params - Weather request parameters including location and units
+     * @returns A promise that resolves to the current weather conditions
+     * @throws {Error} If the request fails or location is invalid
+     *
+     * @example
+     * ```typescript
+     * // Get weather by city
+     * const weather = await weather.getConditions({ city: 'New York', units: 'imperial' })
+     *
+     * // Get weather by postal code
+     * const weather = await weather.getConditions({ postalCode: '10001', units: 'metric' })
+     *
+     * // Get weather by coordinates
+     * const weather = await weather.getConditions({ lat: '40.7128', lon: '-74.0060' })
+     * ```
+     */
+    getConditions(params: WeatherRequestParams): Promise<WeatherConditions>;
+    /**
+     * Retrieves daily weather forecast for a specified location using WeatherBit.
+     *
+     * @param params - Forecast request parameters including location, units, and number of days
+     * @returns A promise that resolves to an array of daily forecast data
+     * @throws {Error} If the request fails or location is invalid
+     *
+     * @example
+     * ```typescript
+     * // Get 5-day forecast
+     * const forecast = await weather.getDailyForecast({
+     *   city: 'London',
+     *   units: 'metric',
+     *   days: 5
+     * })
+     * ```
+     */
+    getDailyForecast(params: DailyForecastParams): Promise<WeatherForecast[]>;
+    /**
+     * Retrieves hourly weather forecast for a specified location using WeatherBit.
+     *
+     * @param params - Forecast request parameters including location, units, and number of hours
+     * @returns A promise that resolves to an array of hourly forecast data
+     * @throws {Error} If the request fails or location is invalid
+     *
+     * @example
+     * ```typescript
+     * // Get 24-hour forecast
+     * const forecast = await weather.getHourlyForecast({
+     *   city: 'Tokyo',
+     *   units: 'metric',
+     *   hours: 24
+     * })
+     * ```
+     */
+    getHourlyForecast(params: HourlyForecastParams): Promise<WeatherForecast[]>;
+    /**
+     * Retrieves current weather conditions using AccuWeather.
+     *
+     * @param params - Weather request parameters including location and units
+     * @returns A promise that resolves to the AccuWeather conditions data
+     * @throws {Error} If the request fails or location is invalid
+     *
+     * @example
+     * ```typescript
+     * const weather = await weather.getAccuWeatherConditions({
+     *   city: 'Paris',
+     *   units: 'metric'
+     * })
+     * ```
+     */
+    getAccuWeatherConditions(params: WeatherRequestParams): Promise<Record<string, any>>;
+    /**
+     * Retrieves daily forecast using AccuWeather.
+     *
+     * @param params - Forecast request parameters including location and units
+     * @returns A promise that resolves to the AccuWeather daily forecast data
+     * @throws {Error} If the request fails or location is invalid
+     *
+     * @example
+     * ```typescript
+     * const forecast = await weather.getAccuWeatherDailyForecast({
+     *   city: 'Sydney',
+     *   units: 'metric'
+     * })
+     * ```
+     */
+    getAccuWeatherDailyForecast(params: WeatherRequestParams): Promise<Record<string, any>>;
+    /**
+     * Retrieves hourly forecast using AccuWeather.
+     *
+     * @param params - Forecast request parameters including location and units
+     * @returns A promise that resolves to the AccuWeather hourly forecast data
+     * @throws {Error} If the request fails or location is invalid
+     *
+     * @example
+     * ```typescript
+     * const forecast = await weather.getAccuWeatherHourlyForecast({
+     *   city: 'Berlin',
+     *   units: 'metric'
+     * })
+     * ```
+     */
+    getAccuWeatherHourlyForecast(params: WeatherRequestParams): Promise<Record<string, any>>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetryos/root-sdk",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "The official TelemetryOS root application sdk package. Provides types and apis for building root TelemetryOS applications.",
   "type": "module",
   "main": "dist/index.cjs",