@rivi-software/radiotools-sdk-generator 0.2.0

package/dist/targets/python.js

@@ -0,0 +1,124 @@
+import { listenerSdkManifest } from "@rivi-software/radiotools-contract";
+import { snakeCase } from "../shared/naming";
+function renderPythonClient() {
+    const manifest = listenerSdkManifest;
+    const readMethods = manifest.clientMethods.filter((m) => m.scope === "listener:read" && m.rest?.method === "GET" && m.name.startsWith("get"));
+    const methodBlocks = readMethods
+        .map((method) => {
+        const pyName = snakeCase(method.name);
+        if (method.name === "getStation") {
+            return `    def ${pyName}(self) -> dict[str, Any]:
+        """${method.description}"""
+        return self._get_json(f"/api/v1/stations/{quote(self.station_slug, safe='')}")`;
+        }
+        if (method.name === "getWeather" || method.name === "getTraffic") {
+            return `    def ${pyName}(self) -> dict[str, Any] | None:
+        """${method.description}"""
+        station = self.get_station()
+        href = station.get("resources", {}).get("${method.name === "getWeather" ? "weather" : "traffic"}")
+        if not href:
+            return None
+        return self._get_json(href)`;
+        }
+        return `    def ${pyName}(self, **params: Any) -> dict[str, Any]:
+        """${method.description}"""
+        raise NotImplementedError("Use the TypeScript SDK or extend this stub with REST href resolution.")`;
+    })
+        .join("\n\n");
+    return `"""Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand."""
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+
+class RadioToolsStationClient:
+    """Minimal REST client for RadioTools listener contract v${manifest.contractVersion}."""
+
+    def __init__(
+        self,
+        base_url: str,
+        station_slug: str,
+        *,
+        api_token: str | None = None,
+        ingest_token: str | None = None,
+        client: httpx.Client | None = None,
+    ) -> None:
+        if not api_token and not ingest_token:
+            raise ValueError("api_token or ingest_token is required")
+        self.base_url = base_url.rstrip("/")
+        self.station_slug = station_slug
+        self.api_token = api_token
+        self.ingest_token = ingest_token
+        self._client = client or httpx.Client(timeout=30.0)
+
+    def _headers(self, *, ingest: bool = False) -> dict[str, str]:
+        token = self.ingest_token if ingest else self.api_token
+        if not token:
+            scope = "ingest:write" if ingest else "listener:read"
+            raise ValueError(f"Missing token for {scope}")
+        return {"Authorization": f"Bearer {token}"}
+
+    def _get_json(self, path: str, *, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        url = path if path.startswith("http") else f"{self.base_url}{path}"
+        response = self._client.get(
+            url,
+            params=params,
+            headers=self._headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _post_json(self, path: str, body: dict[str, Any], *, ingest: bool = True) -> dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        response = self._client.post(url, json=body, headers=self._headers(ingest=ingest))
+        response.raise_for_status()
+        return response.json()
+
+${methodBlocks}
+
+    def report_playback(self, observation: dict[str, Any], *, station_id: str | None = None) -> dict[str, Any]:
+        """Send one encoder playback observation."""
+        params: dict[str, str] = {}
+        if station_id:
+            params["stationId"] = station_id
+        else:
+            params["stationSlug"] = self.station_slug
+        path = "${manifest.integrations.playback.path}"
+        query = "&".join(f"{k}={quote(v, safe='')}" for k, v in params.items())
+        return self._post_json(f"{path}?{query}", observation)
+
+    @classmethod
+    def from_env(cls) -> RadioToolsStationClient:
+        import os
+
+        base_url = os.environ.get("RADIOTOOLS_BASE_URL", "").strip()
+        station_slug = os.environ.get("RADIOTOOLS_STATION_SLUG", "").strip()
+        api_token = os.environ.get("RADIOTOOLS_API_TOKEN", "").strip() or None
+        ingest_token = os.environ.get("RADIOTOOLS_INGEST_TOKEN", "").strip() or None
+        if not base_url or not station_slug:
+            raise ValueError("Set RADIOTOOLS_BASE_URL and RADIOTOOLS_STATION_SLUG")
+        return cls(base_url, station_slug, api_token=api_token, ingest_token=ingest_token)
+`;
+}
+export const pythonTarget = {
+    id: "python",
+    description: "Python httpx client stubs (packages/sdk-python)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-python/src/radiotools_sdk`,
+    generate: () => [
+        {
+            path: "client.py",
+            contents: renderPythonClient(),
+        },
+        {
+            path: "__init__.py",
+            contents: `"""${listenerSdkManifest.packageNames.python} — generated listener SDK."""
+from .client import RadioToolsStationClient
+
+__all__ = ["RadioToolsStationClient"]
+`,
+        },
+    ],
+};

package/dist/targets/react.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const reactTarget: SdkTarget;

package/dist/targets/react.js

@@ -0,0 +1,82 @@
+import { hookNameFromMethod, ZERO_ARG_READ_METHODS } from "../shared/reads";
+function renderReactHooks() {
+    const hooks = ZERO_ARG_READ_METHODS.map((method) => {
+        const hookName = hookNameFromMethod(method);
+        return `export function ${hookName}(client: StationClient) {
+  return useStationQuery(client, "${method}", () => client.${method}());
+}`;
+    }).join("\n\n");
+    return `/** Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand. */
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { StationClient } from "@rivi-software/radiotools-sdk";
+
+type QueryState<T> = {
+  data: T | undefined;
+  error: Error | undefined;
+  loading: boolean;
+  refresh: () => void;
+};
+
+function useStationQuery<T>(
+  client: StationClient,
+  _method: string,
+  read: () => Promise<T>,
+): QueryState<T> {
+  const [data, setData] = useState<T | undefined>(undefined);
+  const [error, setError] = useState<Error | undefined>(undefined);
+  const [loading, setLoading] = useState(true);
+  const mounted = useRef(true);
+
+  const refresh = useCallback(() => {
+    setLoading(true);
+    void read()
+      .then((value) => {
+        if (!mounted.current) return;
+        setData(value);
+        setError(undefined);
+      })
+      .catch((cause: unknown) => {
+        if (!mounted.current) return;
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+      })
+      .finally(() => {
+        if (mounted.current) setLoading(false);
+      });
+  }, [read]);
+
+  useEffect(() => {
+    mounted.current = true;
+    refresh();
+    return () => {
+      mounted.current = false;
+    };
+  }, [refresh]);
+
+  return { data, error, loading, refresh };
+}
+
+export function useRecommendedPollInterval(client: StationClient): QueryState<number> {
+  return useStationQuery(client, "recommendedPollIntervalMs", () =>
+    client.recommendedPollIntervalMs(),
+  );
+}
+
+${hooks}
+`;
+}
+export const reactTarget = {
+    id: "react",
+    description: "React hooks wrapping @rivi-software/radiotools-sdk (packages/sdk-react)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-react/src`,
+    generate: () => [
+        {
+            path: "hooks.generated.ts",
+            contents: renderReactHooks(),
+        },
+        {
+            path: "index.ts",
+            contents: `export * from "./hooks.generated";
+`,
+        },
+    ],
+};

package/dist/targets/ruby.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const rubyTarget: SdkTarget;

package/dist/targets/ruby.js

@@ -0,0 +1,122 @@
+import { listenerSdkManifest } from "@rivi-software/radiotools-contract";
+function renderRubyClient() {
+    const playbackPath = listenerSdkManifest.integrations.playback.path;
+    return `# Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand.
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module RadioTools
+  class StationClient
+    def initialize(base_url:, station_slug:, api_token: nil, ingest_token: nil)
+      raise ArgumentError, "api_token or ingest_token is required" if api_token.to_s.empty? && ingest_token.to_s.empty?
+
+      @base_url = base_url.to_s.chomp("/")
+      @station_slug = station_slug
+      @api_token = api_token
+      @ingest_token = ingest_token
+    end
+
+    def self.from_env
+      new(
+        base_url: ENV.fetch("RADIOTOOLS_BASE_URL", ""),
+        station_slug: ENV.fetch("RADIOTOOLS_STATION_SLUG", ""),
+        api_token: ENV["RADIOTOOLS_API_TOKEN"],
+        ingest_token: ENV["RADIOTOOLS_INGEST_TOKEN"],
+      )
+    end
+
+    def get_station
+      get_json("/api/v1/stations/#{URI.encode_uri_component(@station_slug)}", ingest: false)
+    end
+
+    def get_weather
+      href = station_resource("weather")
+      return nil if href.nil? || href.empty?
+
+      get_json(href, ingest: false)
+    end
+
+    def get_traffic
+      href = station_resource("traffic")
+      return nil if href.nil? || href.empty?
+
+      get_json(href, ingest: false)
+    end
+
+    def report_playback(observation, station_id: nil)
+      params = station_id ? { stationId: station_id } : { stationSlug: @station_slug }
+      query = URI.encode_www_form(params)
+      post_json("${playbackPath}?#{query}", observation, ingest: true)
+    end
+
+    private
+
+    def station_resource(key)
+      station = get_station
+      station.dig("resources", key)
+    end
+
+    def get_json(path, ingest:)
+      uri = path.start_with?("http") ? URI(path) : URI("#{@base_url}#{path}")
+      request = Net::HTTP::Get.new(uri)
+      apply_auth!(request, ingest)
+      execute(request, uri)
+    end
+
+    def post_json(path, body, ingest:)
+      uri = URI("#{@base_url}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request.body = JSON.generate(body)
+      apply_auth!(request, ingest)
+      execute(request, uri)
+    end
+
+    def apply_auth!(request, ingest)
+      token = ingest ? @ingest_token : @api_token
+      raise ArgumentError, "missing bearer token" if token.to_s.empty?
+
+      request["Authorization"] = "Bearer #{token}"
+    end
+
+    def execute(request, uri)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+      raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    end
+  end
+end
+`;
+}
+export const rubyTarget = {
+    id: "ruby",
+    description: "Ruby Net::HTTP client stubs (packages/sdk-ruby)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-ruby/lib/radiotools_sdk`,
+    generate: () => [
+        { path: "client.rb", contents: renderRubyClient() },
+        {
+            path: "../radiotools_sdk.rb",
+            contents: `# frozen_string_literal: true
+
+require_relative "radiotools_sdk/client"
+
+module RadioToolsSdk
+  Client = RadioTools::StationClient
+end
+`,
+        },
+        {
+            path: "../../README.md",
+            contents: `# radiotools_sdk (Ruby)
+
+Generated REST stubs. Regenerate: \`bun run --filter @rivi-software/radiotools-sdk-generator generate --target ruby\`.
+`,
+        },
+    ],
+};

package/dist/targets/svelte.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const svelteTarget: SdkTarget;

package/dist/targets/svelte.js

@@ -0,0 +1,76 @@
+import { pascalCase } from "../shared/naming";
+import { ZERO_ARG_READ_METHODS } from "../shared/reads";
+function renderSvelteStores() {
+    const stores = ZERO_ARG_READ_METHODS.map((method) => {
+        const storeFn = `create${pascalCase(method)}Store`;
+        return `export function ${storeFn}(client: StationClient) {
+  return createStationStore(() => client.${method}());
+}`;
+    }).join("\n\n");
+    return `/** Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand. */
+import { derived, writable, type Readable } from "svelte/store";
+import type { StationClient } from "@rivi-software/radiotools-sdk";
+
+export type StationStoreState<T> = {
+  data: T | undefined;
+  error: Error | undefined;
+  loading: boolean;
+};
+
+export type StationStore<T> = Readable<StationStoreState<T>> & {
+  refresh: () => Promise<void>;
+};
+
+function createStationStore<T>(read: () => Promise<T>): StationStore<T> {
+  const inner = writable<StationStoreState<T>>({
+    data: undefined,
+    error: undefined,
+    loading: true,
+  });
+
+  const refresh = async () => {
+    inner.update((state) => ({ ...state, loading: true }));
+    try {
+      const data = await read();
+      inner.set({ data, error: undefined, loading: false });
+    } catch (cause: unknown) {
+      inner.set({
+        data: undefined,
+        error: cause instanceof Error ? cause : new Error(String(cause)),
+        loading: false,
+      });
+    }
+  };
+
+  void refresh();
+
+  return {
+    subscribe: inner.subscribe,
+    refresh,
+  };
+}
+
+export function createRecommendedPollIntervalStore(client: StationClient) {
+  return createStationStore(() => client.recommendedPollIntervalMs());
+}
+
+${stores}
+
+/** Convenience derived store: true when any nested field is loading. */
+export function stationStoreLoading<T>(store: StationStore<T>): Readable<boolean> {
+  return derived(store, ($state) => $state.loading);
+}
+`;
+}
+export const svelteTarget = {
+    id: "svelte",
+    description: "Svelte stores wrapping @rivi-software/radiotools-sdk (packages/sdk-svelte)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-svelte/src`,
+    generate: () => [
+        { path: "stores.generated.ts", contents: renderSvelteStores() },
+        {
+            path: "index.ts",
+            contents: `export * from "./stores.generated";\n`,
+        },
+    ],
+};

package/dist/targets/swift.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const swiftTarget: SdkTarget;

package/dist/targets/swift.js

@@ -0,0 +1,179 @@
+import { listenerSdkManifest } from "@rivi-software/radiotools-contract";
+function renderSwiftClient() {
+    const playbackPath = listenerSdkManifest.integrations.playback.path.replace(/^\//, "");
+    return `// Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand.
+import Foundation
+
+public enum RadioToolsSDKError: Error, LocalizedError {
+    case missingToken
+    case invalidURL
+    case httpStatus(Int, String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken: return "Missing bearer token"
+        case .invalidURL: return "Invalid URL"
+        case let .httpStatus(code, body): return "HTTP \\(code): \\(body)"
+        }
+    }
+}
+
+public final class StationClient: @unchecked Sendable {
+    private let baseURL: URL
+    private let stationSlug: String
+    private let apiToken: String?
+    private let ingestToken: String?
+    private let session: URLSession
+
+    public init(
+        baseURL: URL,
+        stationSlug: String,
+        apiToken: String? = nil,
+        ingestToken: String? = nil,
+        session: URLSession = .shared
+    ) throws {
+        guard apiToken?.isEmpty == false || ingestToken?.isEmpty == false else {
+            throw RadioToolsSDKError.missingToken
+        }
+        self.baseURL = baseURL
+        self.stationSlug = stationSlug
+        self.apiToken = apiToken
+        self.ingestToken = ingestToken
+        self.session = session
+    }
+
+    public func getStation() async throws -> [String: Any] {
+        let path = "/api/v1/stations/\\(stationSlug.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? stationSlug)"
+        return try await getJSON(path: path, ingest: false)
+    }
+
+    public func getNowPlaying() async throws -> [String: Any] {
+        let station = try await getStation()
+        guard
+            let resources = station["resources"] as? [String: Any],
+            let href = resources["nowPlaying"] as? String,
+            !href.isEmpty
+        else {
+            throw RadioToolsSDKError.httpStatus(404, "nowPlaying unavailable")
+        }
+        return try await getJSON(path: href, ingest: false)
+    }
+
+    public func getWeather() async throws -> [String: Any]? {
+        let station = try await getStation()
+        guard
+            let resources = station["resources"] as? [String: Any],
+            let href = resources["weather"] as? String,
+            !href.isEmpty
+        else { return nil }
+        return try await getJSON(path: href, ingest: false)
+    }
+
+    public func getTraffic() async throws -> [String: Any]? {
+        let station = try await getStation()
+        guard
+            let resources = station["resources"] as? [String: Any],
+            let href = resources["traffic"] as? String,
+            !href.isEmpty
+        else { return nil }
+        return try await getJSON(path: href, ingest: false)
+    }
+
+    public func reportPlayback(
+        observation: [String: Any],
+        stationId: String? = nil
+    ) async throws -> [String: Any] {
+        var items: [URLQueryItem] = []
+        if let stationId, !stationId.isEmpty {
+            items.append(URLQueryItem(name: "stationId", value: stationId))
+        } else {
+            items.append(URLQueryItem(name: "stationSlug", value: stationSlug))
+        }
+        var components = URLComponents(url: baseURL.appendingPathComponent("${playbackPath}"), resolvingAgainstBaseURL: false)
+        components?.queryItems = items
+        guard let url = components?.url else { throw RadioToolsSDKError.invalidURL }
+        return try await postJSON(url: url, body: observation, ingest: true)
+    }
+
+    private func getJSON(path: String, ingest: Bool) async throws -> [String: Any] {
+        let url: URL
+        if path.hasPrefix("http") {
+            guard let parsed = URL(string: path) else { throw RadioToolsSDKError.invalidURL }
+            url = parsed
+        } else {
+            url = URL(string: path, relativeTo: baseURL)?.absoluteURL ?? baseURL
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(try bearer(ingest: ingest), forHTTPHeaderField: "Authorization")
+        let (data, response) = try await session.data(for: request)
+        try validate(response: response, data: data)
+        let object = try JSONSerialization.jsonObject(with: data)
+        guard let dict = object as? [String: Any] else { return [:] }
+        return dict
+    }
+
+    private func postJSON(url: URL, body: [String: Any], ingest: Bool) async throws -> [String: Any] {
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue(try bearer(ingest: ingest), forHTTPHeaderField: "Authorization")
+        request.httpBody = try JSONSerialization.data(withJSONObject: body)
+        let (data, response) = try await session.data(for: request)
+        try validate(response: response, data: data)
+        let object = try JSONSerialization.jsonObject(with: data)
+        return object as? [String: Any] ?? [:]
+    }
+
+    private func bearer(ingest: Bool) throws -> String {
+        let token = ingest ? ingestToken : apiToken
+        guard let token, !token.isEmpty else { throw RadioToolsSDKError.missingToken }
+        return "Bearer \\(token)"
+    }
+
+    private func validate(response: URLResponse, data: Data) throws {
+        guard let http = response as? HTTPURLResponse else { return }
+        guard (200 ... 299).contains(http.statusCode) else {
+            let body = String(data: data, encoding: .utf8) ?? ""
+            throw RadioToolsSDKError.httpStatus(http.statusCode, body)
+        }
+    }
+}
+`;
+}
+export const swiftTarget = {
+    id: "swift",
+    description: "Swift URLSession client stubs (packages/sdk-swift)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-swift/Sources/RadioToolsSDK`,
+    generate: (repoRoot) => [
+        { path: "StationClient.swift", contents: renderSwiftClient() },
+        {
+            path: `${repoRoot}/packages/sdk-swift/Package.swift`,
+            contents: `// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "RadioToolsSDK",
+    platforms: [.iOS(.v16), .macOS(.v13)],
+    products: [
+        .library(name: "RadioToolsSDK", targets: ["RadioToolsSDK"]),
+    ],
+    targets: [
+        .target(name: "RadioToolsSDK"),
+    ]
+)
+`,
+        },
+        {
+            path: `${repoRoot}/packages/sdk-swift/README.md`,
+            contents: `# RadioTools Swift SDK
+
+Generated iOS/macOS REST stubs using \`URLSession\` and async/await.
+
+Regenerate: \`bun run --filter @rivi-software/radiotools-sdk-generator generate --target swift\`
+
+Use \`packages/openapi/openapi.json\` (from Zod) to generate typed models with Swift OpenAPI Generator if needed.
+`,
+        },
+    ],
+};

package/dist/targets/vue.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const vueTarget: SdkTarget;

package/dist/targets/vue.js

@@ -0,0 +1,67 @@
+import { hookNameFromMethod, ZERO_ARG_READ_METHODS } from "../shared/reads";
+function renderVueComposables() {
+    const composables = ZERO_ARG_READ_METHODS.map((method) => {
+        const name = hookNameFromMethod(method);
+        return `export function ${name}(client: StationClient) {
+  return useStationQuery(() => client.${method}());
+}`;
+    }).join("\n\n");
+    return `/** Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand. */
+import { type Ref, onMounted, onUnmounted, ref, shallowRef } from "vue";
+import type { StationClient } from "@rivi-software/radiotools-sdk";
+
+export type StationQuery<T> = {
+  data: Ref<T | undefined>;
+  error: Ref<Error | undefined>;
+  loading: Ref<boolean>;
+  refresh: () => Promise<void>;
+};
+
+function useStationQuery<T>(read: () => Promise<T>): StationQuery<T> {
+  const data = shallowRef<T | undefined>(undefined);
+  const error = ref<Error | undefined>(undefined);
+  const loading = ref(true);
+  let active = true;
+
+  const refresh = async () => {
+    loading.value = true;
+    try {
+      const value = await read();
+      if (!active) return;
+      data.value = value;
+      error.value = undefined;
+    } catch (cause: unknown) {
+      if (!active) return;
+      error.value = cause instanceof Error ? cause : new Error(String(cause));
+    } finally {
+      if (active) loading.value = false;
+    }
+  };
+
+  onMounted(() => {
+    active = true;
+    void refresh();
+  });
+  onUnmounted(() => {
+    active = false;
+  });
+
+  return { data, error, loading, refresh };
+}
+
+export function useRecommendedPollInterval(client: StationClient): StationQuery<number> {
+  return useStationQuery(() => client.recommendedPollIntervalMs());
+}
+
+${composables}
+`;
+}
+export const vueTarget = {
+    id: "vue",
+    description: "Vue composables wrapping @rivi-software/radiotools-sdk (packages/sdk-vue)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-vue/src`,
+    generate: () => [
+        { path: "composables.generated.ts", contents: renderVueComposables() },
+        { path: "index.ts", contents: `export * from "./composables.generated";\n` },
+    ],
+};

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export type GeneratorTargetId = "python" | "react" | "vue" | "svelte" | "go" | "csharp" | "ruby" | "php" | "openapi" | "kotlin" | "swift" | "next";
+export type GeneratorTarget = GeneratorTargetId | "all";
+export type GenerateOptions = {
+    repoRoot: string;
+    target: GeneratorTarget;
+    dryRun?: boolean;
+};
+export type GeneratedFile = {
+    path: string;
+    contents: string;
+};
+export type SdkTarget = {
+    id: GeneratorTargetId;
+    description: string;
+    outputDir: (repoRoot: string) => string;
+    generate: (repoRoot: string) => GeneratedFile[];
+};