@bojanrajkovic/mcp-paprika 1.0.0

package/dist/features/embeddings.d.ts

@@ -0,0 +1,70 @@
+/**
+ * HTTP client for embedding services with OpenAI-compatible `/v1/embeddings` endpoints.
+ *
+ * Includes:
+ * - EmbeddingClient: cockatiel-resilient HTTP client with retry and circuit breaker
+ * - recipeToEmbeddingText: pure function for converting recipes to embedding text
+ */
+import type { Recipe } from "../paprika/types.js";
+import type { EmbeddingConfig } from "../utils/config.js";
+/**
+ * HTTP client for embedding services.
+ *
+ * Uses cockatiel for resilience:
+ * - Retries on transient failures (429, 500, 502, 503) with exponential backoff
+ * - Circuit breaker opens after 5 consecutive transient failures
+ *
+ * Validates responses with Zod schemas at the boundary.
+ *
+ * Per-instance resilience stack (not shared between instances) to avoid
+ * circuit breaker state leaking between tests or concurrent clients.
+ */
+export declare class EmbeddingClient {
+    private readonly _baseUrl;
+    private readonly _apiKey;
+    private readonly _model;
+    private readonly _retryPolicy;
+    private readonly _breakerPolicy;
+    private readonly _resilience;
+    private _dimensions;
+    constructor(config: Readonly<EmbeddingConfig>);
+    /**
+     * Get the dimensionality of the embedding vectors.
+     * Must be called after at least one successful embedding call.
+     *
+     * @throws EmbeddingError if no embedding call has been made yet
+     */
+    get dimensions(): number;
+    /**
+     * Embed multiple texts in a single batch.
+     * Returns an array of embedding vectors, one per input text.
+     *
+     * @param texts - Array of texts to embed
+     * @returns Array of embedding vectors (each is an array of numbers)
+     * @throws EmbeddingAPIError on permanent HTTP errors or circuit breaker open
+     * @throws ZodError on response validation failure
+     * @throws TransientHTTPError (internally caught by resilience) on transient failures
+     */
+    embedBatch(texts: ReadonlyArray<string>): Promise<Array<Array<number>>>;
+    /**
+     * Embed a single text.
+     * Delegates to embedBatch() and returns the first (and only) embedding.
+     *
+     * @param text - Text to embed
+     * @returns Single embedding vector
+     * @throws Same as embedBatch()
+     */
+    embed(text: string): Promise<Array<number>>;
+}
+/**
+ * Convert a recipe to text suitable for embedding.
+ *
+ * Includes recipe name, description, category names, ingredients, and notes.
+ * Excludes directions and nutritional info.
+ * Omits any null or empty fields to avoid unnecessary text.
+ *
+ * @param recipe - Recipe to convert
+ * @param categoryNames - Array of resolved category names
+ * @returns Multi-line text representation of the recipe
+ */
+export declare function recipeToEmbeddingText(recipe: Readonly<Recipe>, categoryNames: ReadonlyArray<string>): string;

package/dist/features/embeddings.js

@@ -0,0 +1,186 @@
+/**
+ * HTTP client for embedding services with OpenAI-compatible `/v1/embeddings` endpoints.
+ *
+ * Includes:
+ * - EmbeddingClient: cockatiel-resilient HTTP client with retry and circuit breaker
+ * - recipeToEmbeddingText: pure function for converting recipes to embedding text
+ */
+import { ExponentialBackoff, ConsecutiveBreaker, retry, circuitBreaker, handleType, wrap, BrokenCircuitError, } from "cockatiel";
+import { z } from "zod";
+import { EmbeddingError, EmbeddingAPIError } from "./embedding-errors.js";
+/**
+ * Internal error class to signal transient HTTP errors for cockatiel.
+ * Not exported — used only within this module for resilience signaling.
+ */
+class TransientHTTPError extends Error {
+    status;
+    constructor(status) {
+        super(`Transient HTTP error (${status.toString()})`);
+        this.status = status;
+        this.name = "TransientHTTPError";
+    }
+}
+/**
+ * HTTP status codes that should trigger retry.
+ */
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503]);
+/**
+ * Zod schema for validating embedding API responses.
+ * Validates the OpenAI-compatible `/v1/embeddings` response format.
+ */
+const EmbeddingResponseSchema = z.object({
+    data: z.array(z.object({
+        index: z.number(),
+        embedding: z.array(z.number()),
+    })),
+    model: z.string(),
+    usage: z.object({
+        prompt_tokens: z.number(),
+        total_tokens: z.number(),
+    }),
+});
+/**
+ * HTTP client for embedding services.
+ *
+ * Uses cockatiel for resilience:
+ * - Retries on transient failures (429, 500, 502, 503) with exponential backoff
+ * - Circuit breaker opens after 5 consecutive transient failures
+ *
+ * Validates responses with Zod schemas at the boundary.
+ *
+ * Per-instance resilience stack (not shared between instances) to avoid
+ * circuit breaker state leaking between tests or concurrent clients.
+ */
+export class EmbeddingClient {
+    _baseUrl;
+    _apiKey;
+    _model;
+    _retryPolicy;
+    _breakerPolicy;
+    _resilience;
+    _dimensions = null;
+    constructor(config) {
+        this._baseUrl = config.baseUrl.replace(/\/+$/, "");
+        this._apiKey = config.apiKey;
+        this._model = config.model;
+        // Per-instance resilience stack
+        this._retryPolicy = retry(handleType(TransientHTTPError), {
+            maxAttempts: 3,
+            backoff: new ExponentialBackoff({
+                initialDelay: 500,
+                maxDelay: 10_000,
+            }),
+        });
+        this._breakerPolicy = circuitBreaker(handleType(TransientHTTPError), {
+            halfOpenAfter: 30_000,
+            breaker: new ConsecutiveBreaker(5),
+        });
+        this._resilience = wrap(this._retryPolicy, this._breakerPolicy);
+    }
+    /**
+     * Get the dimensionality of the embedding vectors.
+     * Must be called after at least one successful embedding call.
+     *
+     * @throws EmbeddingError if no embedding call has been made yet
+     */
+    get dimensions() {
+        if (this._dimensions === null) {
+            throw new EmbeddingError("Dimensions unknown: no embedding call has been made yet");
+        }
+        return this._dimensions;
+    }
+    /**
+     * Embed multiple texts in a single batch.
+     * Returns an array of embedding vectors, one per input text.
+     *
+     * @param texts - Array of texts to embed
+     * @returns Array of embedding vectors (each is an array of numbers)
+     * @throws EmbeddingAPIError on permanent HTTP errors or circuit breaker open
+     * @throws ZodError on response validation failure
+     * @throws TransientHTTPError (internally caught by resilience) on transient failures
+     */
+    async embedBatch(texts) {
+        const endpoint = `${this._baseUrl}/embeddings`;
+        const execute = async () => {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this._apiKey}`,
+                },
+                body: JSON.stringify({
+                    model: this._model,
+                    input: texts,
+                }),
+            });
+            // Check for transient vs permanent errors
+            if (!response.ok) {
+                if (RETRYABLE_STATUSES.has(response.status)) {
+                    throw new TransientHTTPError(response.status);
+                }
+                throw new EmbeddingAPIError("Embedding API error", response.status, endpoint);
+            }
+            // Parse and validate response
+            const json = await response.json();
+            const parsed = EmbeddingResponseSchema.parse(json);
+            // Cache dimensions from first embedding
+            if (parsed.data.length > 0) {
+                this._dimensions = parsed.data[0].embedding.length;
+            }
+            return parsed.data.map((d) => d.embedding);
+        };
+        try {
+            const result = await this._resilience.execute(execute);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof BrokenCircuitError) {
+                throw new EmbeddingAPIError("Service unavailable (circuit open)", 503, endpoint);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Embed a single text.
+     * Delegates to embedBatch() and returns the first (and only) embedding.
+     *
+     * @param text - Text to embed
+     * @returns Single embedding vector
+     * @throws Same as embedBatch()
+     */
+    async embed(text) {
+        const embeddings = await this.embedBatch([text]);
+        const first = embeddings[0];
+        if (first === undefined) {
+            throw new EmbeddingError("Empty embedding response");
+        }
+        return first;
+    }
+}
+/**
+ * Convert a recipe to text suitable for embedding.
+ *
+ * Includes recipe name, description, category names, ingredients, and notes.
+ * Excludes directions and nutritional info.
+ * Omits any null or empty fields to avoid unnecessary text.
+ *
+ * @param recipe - Recipe to convert
+ * @param categoryNames - Array of resolved category names
+ * @returns Multi-line text representation of the recipe
+ */
+export function recipeToEmbeddingText(recipe, categoryNames) {
+    const sections = [recipe.name];
+    if (recipe.description) {
+        sections.push(`Description: ${recipe.description}`);
+    }
+    if (categoryNames.length > 0) {
+        sections.push(`Categories: ${categoryNames.join(", ")}`);
+    }
+    if (recipe.ingredients) {
+        sections.push(`Ingredients: ${recipe.ingredients}`);
+    }
+    if (recipe.notes) {
+        sections.push(`Notes: ${recipe.notes}`);
+    }
+    return sections.join("\n\n");
+}

package/dist/features/vector-store-errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Error class for vector store operations.
+ *
+ * Covers initialization failures, corruption recovery, and indexing errors.
+ * Supports ES2024 ErrorOptions for cause chaining.
+ */
+/**
+ * Base error class for all vector store operations.
+ */
+export declare class VectorStoreError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/features/vector-store-errors.js

@@ -0,0 +1,15 @@
+/**
+ * Error class for vector store operations.
+ *
+ * Covers initialization failures, corruption recovery, and indexing errors.
+ * Supports ES2024 ErrorOptions for cause chaining.
+ */
+/**
+ * Base error class for all vector store operations.
+ */
+export class VectorStoreError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "VectorStoreError";
+    }
+}

package/dist/features/vector-store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Vector store implementation using Vectra for semantic search.
+ *
+ * Provides recipe-aware vector operations with:
+ * - Embedding lifecycle management (when/what to embed)
+ * - Vector storage via Vectra LocalIndex
+ * - Change detection via persisted content hash map
+ * - Corruption recovery for both Vectra index and hash map
+ */
+/**
+ * Semantic search result from the vector store.
+ *
+ * Includes the recipe UID, similarity score (0-1), and recipe name for display.
+ */
+export type SemanticResult = {
+    readonly uid: string;
+    readonly score: number;
+    readonly recipeName: string;
+};
+/**
+ * Result of a batch indexing operation.
+ *
+ * Tracks how many recipes were indexed (content changed), skipped (unchanged),
+ * and the total count for reference.
+ */
+export type IndexingResult = {
+    readonly indexed: number;
+    readonly skipped: number;
+    readonly total: number;
+};
+/**
+ * Produce a stable SHA-256 hex digest of the given text.
+ *
+ * Used to detect whether a recipe's embeddable fields have changed
+ * since the last indexing run. The input text is typically the output
+ * of `recipeToEmbeddingText()`, which includes only fields that should
+ * trigger re-embedding (name, description, categories, ingredients, notes)
+ * and excludes fields like directions and nutritional info that don't
+ * affect semantic search relevance.
+ *
+ * @param text The text to hash (typically embedding text)
+ * @returns A stable SHA-256 hex digest
+ */
+export declare function contentHash(text: string): string;
+import type { EmbeddingClient } from "./embeddings.js";
+import type { Recipe, CategoryUid } from "../paprika/types.js";
+export declare class VectorStore {
+    private readonly _vectorsDir;
+    private readonly _hashIndexPath;
+    private readonly _index;
+    private readonly _embedder;
+    private _hashes;
+    constructor(cacheDir: string, embedder: EmbeddingClient);
+    init(): Promise<void>;
+    private _loadHashIndex;
+    private _backupFile;
+    indexRecipes(recipes: ReadonlyArray<Recipe>, resolveCats: (uids: ReadonlyArray<CategoryUid>) => ReadonlyArray<string>): Promise<IndexingResult>;
+    indexRecipe(recipe: Readonly<Recipe>, categoryNames: ReadonlyArray<string>): Promise<IndexingResult>;
+    get size(): number;
+    private _persistHashes;
+    search(query: string, topK?: number): Promise<ReadonlyArray<SemanticResult>>;
+    removeRecipe(uid: string): Promise<void>;
+}

package/dist/features/vector-store.js

@@ -0,0 +1,202 @@
+/**
+ * Vector store implementation using Vectra for semantic search.
+ *
+ * Provides recipe-aware vector operations with:
+ * - Embedding lifecycle management (when/what to embed)
+ * - Vector storage via Vectra LocalIndex
+ * - Change detection via persisted content hash map
+ * - Corruption recovery for both Vectra index and hash map
+ */
+import { createHash } from "node:crypto";
+/**
+ * Produce a stable SHA-256 hex digest of the given text.
+ *
+ * Used to detect whether a recipe's embeddable fields have changed
+ * since the last indexing run. The input text is typically the output
+ * of `recipeToEmbeddingText()`, which includes only fields that should
+ * trigger re-embedding (name, description, categories, ingredients, notes)
+ * and excludes fields like directions and nutritional info that don't
+ * affect semantic search relevance.
+ *
+ * @param text The text to hash (typically embedding text)
+ * @returns A stable SHA-256 hex digest
+ */
+export function contentHash(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+import { mkdir, readFile, rename, cp, open } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { LocalIndex } from "vectra";
+import { recipeToEmbeddingText } from "./embeddings.js";
+import { VectorStoreError } from "./vector-store-errors.js";
+const HashIndexSchema = z.record(z.string(), z.string());
+/** Maximum number of texts to embed in a single batch call. */
+const BATCH_SIZE = 500;
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function log(msg) {
+    process.stderr.write(`[mcp-paprika:vectors] ${msg}\n`);
+}
+export class VectorStore {
+    _vectorsDir;
+    _hashIndexPath;
+    _index;
+    _embedder;
+    _hashes = {};
+    constructor(cacheDir, embedder) {
+        this._vectorsDir = join(cacheDir, "vectors");
+        this._hashIndexPath = join(this._vectorsDir, "hash-index.json");
+        this._index = new LocalIndex(this._vectorsDir);
+        this._embedder = embedder;
+    }
+    async init() {
+        await mkdir(this._vectorsDir, { recursive: true });
+        // Create or open Vectra index, with corruption recovery (AC1.4)
+        try {
+            const created = await this._index.isIndexCreated();
+            if (!created) {
+                await this._index.createIndex();
+            }
+        }
+        catch {
+            log("corrupt Vectra index, backing up and recreating");
+            const backupDir = `${this._vectorsDir}.bak`;
+            await cp(this._vectorsDir, backupDir, { recursive: true, force: true });
+            await this._index.createIndex({ version: 1, deleteIfExists: true });
+            this._hashes = {};
+            return; // Skip loading hash index — just cleared everything
+        }
+        // Load hash map — follows DiskCache pattern (disk-cache.ts:60-88)
+        await this._loadHashIndex();
+    }
+    async _loadHashIndex() {
+        let raw;
+        try {
+            raw = await readFile(this._hashIndexPath, "utf-8");
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                this._hashes = {};
+                return;
+            }
+            throw error;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            log("corrupt hash-index.json (invalid JSON), backing up and resetting");
+            await this._backupFile(this._hashIndexPath, `${this._hashIndexPath}.bak`);
+            this._hashes = {};
+            return;
+        }
+        const result = HashIndexSchema.safeParse(parsed);
+        if (!result.success) {
+            log("corrupt hash-index.json (schema mismatch), backing up and resetting");
+            await this._backupFile(this._hashIndexPath, `${this._hashIndexPath}.bak`);
+            this._hashes = {};
+            return;
+        }
+        this._hashes = result.data;
+    }
+    async _backupFile(src, dest) {
+        try {
+            await rename(src, dest);
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    async indexRecipes(recipes, resolveCats) {
+        if (recipes.length === 0) {
+            return { indexed: 0, skipped: 0, total: 0 };
+        }
+        // Compute embedding texts and hashes, filter unchanged
+        const toEmbed = [];
+        let skipped = 0;
+        for (const recipe of recipes) {
+            const cats = resolveCats(recipe.categories);
+            const text = recipeToEmbeddingText(recipe, cats);
+            const hash = contentHash(text);
+            if (this._hashes[recipe.uid] === hash) {
+                skipped++;
+                continue;
+            }
+            toEmbed.push({ recipe, text, hash });
+        }
+        if (toEmbed.length === 0) {
+            return { indexed: 0, skipped, total: recipes.length };
+        }
+        // Batch embed in chunks of BATCH_SIZE to avoid API limits on large collections
+        const allVectors = [];
+        for (let offset = 0; offset < toEmbed.length; offset += BATCH_SIZE) {
+            const chunk = toEmbed.slice(offset, offset + BATCH_SIZE);
+            const vectors = await this._embedder.embedBatch(chunk.map((e) => e.text));
+            allVectors.push(...vectors);
+        }
+        // Upsert into Vectra
+        await this._index.beginUpdate();
+        try {
+            for (let i = 0; i < toEmbed.length; i++) {
+                const entry = toEmbed[i];
+                await this._index.upsertItem({
+                    id: entry.recipe.uid,
+                    vector: allVectors[i],
+                    metadata: { recipeName: entry.recipe.name },
+                });
+            }
+            await this._index.endUpdate();
+        }
+        catch (error) {
+            this._index.cancelUpdate();
+            throw new VectorStoreError("Failed to upsert items into vector index", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        // Update hash map
+        for (const entry of toEmbed) {
+            this._hashes[entry.recipe.uid] = entry.hash;
+        }
+        await this._persistHashes();
+        return { indexed: toEmbed.length, skipped, total: recipes.length };
+    }
+    async indexRecipe(recipe, categoryNames) {
+        return this.indexRecipes([recipe], () => [...categoryNames]);
+    }
+    get size() {
+        return Object.keys(this._hashes).length;
+    }
+    async _persistHashes() {
+        const tmpPath = join(this._vectorsDir, `.hash-index-${Date.now().toString()}.tmp`);
+        const fh = await open(tmpPath, "w");
+        try {
+            await fh.writeFile(JSON.stringify(this._hashes, null, 2));
+            await fh.sync();
+        }
+        finally {
+            await fh.close();
+        }
+        await rename(tmpPath, this._hashIndexPath);
+    }
+    async search(query, topK = 10) {
+        const vector = await this._embedder.embed(query);
+        const results = await this._index.queryItems(vector, topK);
+        return results.map((r) => ({
+            uid: r.item.id,
+            score: r.score,
+            recipeName: r.item.metadata?.["recipeName"] ?? "",
+        }));
+    }
+    async removeRecipe(uid) {
+        await this._index.deleteItem(uid);
+        if (uid in this._hashes) {
+            delete this._hashes[uid];
+            await this._persistHashes();
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { PaprikaClient } from "./paprika/client.js";
+import { SyncEngine } from "./paprika/sync.js";
+import { DiskCache } from "./cache/disk-cache.js";
+import { RecipeStore } from "./cache/recipe-store.js";
+import { loadConfig } from "./utils/config.js";
+import { getCacheDir } from "./utils/xdg.js";
+import { registerSearchTool } from "./tools/search.js";
+import { registerFilterTools } from "./tools/filter.js";
+import { registerCategoryTools } from "./tools/categories.js";
+import { registerReadTool } from "./tools/read.js";
+import { registerCreateTool } from "./tools/create.js";
+import { registerUpdateTool } from "./tools/update.js";
+import { registerDeleteTool } from "./tools/delete.js";
+import { registerListTool } from "./tools/list.js";
+import { registerRecipeResources } from "./resources/recipes.js";
+import { setupDiscoverFeature } from "./features/discover-feature.js";
+function log(msg) {
+    process.stderr.write(`[mcp-paprika] ${msg}\n`);
+}
+async function main() {
+    // 1. Load and validate config
+    log("Loading configuration...");
+    const configResult = loadConfig();
+    const config = configResult.match((cfg) => cfg, (err) => {
+        throw err;
+    });
+    // 2. Construct PaprikaClient and authenticate
+    log("Authenticating with Paprika...");
+    const client = new PaprikaClient(config.paprika.email, config.paprika.password);
+    await client.authenticate();
+    log("Authenticated successfully.");
+    // 3. Construct DiskCache and initialize
+    log("Initializing disk cache...");
+    const cache = new DiskCache(getCacheDir());
+    await cache.init();
+    // 4. Construct RecipeStore and hydrate from cache
+    const store = new RecipeStore();
+    const cachedRecipes = await cache.getAllRecipes();
+    for (const recipe of cachedRecipes) {
+        store.set(recipe);
+    }
+    log(`Hydrated store with ${cachedRecipes.length} cached recipes.`);
+    // 5. Construct McpServer
+    const server = new McpServer({
+        name: "mcp-paprika",
+        version: "0.0.0",
+    });
+    // 6. Assemble ServerContext
+    const ctx = {
+        client,
+        cache,
+        store,
+        server,
+    };
+    // 7. Register all 9 tools
+    registerSearchTool(server, ctx);
+    registerFilterTools(server, ctx);
+    registerCategoryTools(server, ctx);
+    registerListTool(server, ctx);
+    registerReadTool(server, ctx);
+    registerCreateTool(server, ctx);
+    registerUpdateTool(server, ctx);
+    registerDeleteTool(server, ctx);
+    log("Registered 9 tools.");
+    // 8. Register recipe resources
+    registerRecipeResources(server, ctx);
+    log("Registered recipe resources.");
+    // 9. Construct SyncEngine, run initial sync, then start background loop
+    const sync = new SyncEngine(ctx, config.sync.interval);
+    log("Running initial sync...");
+    await sync.syncOnce();
+    log("Initial sync complete.");
+    if (config.sync.enabled) {
+        sync.start();
+        log(`Sync engine started (interval: ${config.sync.interval}ms).`);
+    }
+    else {
+        log("Background sync disabled.");
+    }
+    // Phase 3: Semantic search
+    await setupDiscoverFeature(server, ctx, sync, config);
+    // 10. Register SIGINT handler
+    process.on("SIGINT", () => {
+        log("SIGINT received, shutting down...");
+        sync.stop();
+        process.exit(0);
+    });
+    // 11. Connect stdio transport
+    log("Connecting stdio transport...");
+    await server.connect(new StdioServerTransport());
+    log("Server ready.");
+}
+main().catch((err) => {
+    /* oxlint-disable-next-line no-console */
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/paprika/client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Typed HTTP client for the Paprika Cloud Sync API.
+ *
+ * Encapsulates authentication against the v1 login endpoint
+ * and resilient request execution against the v2 data endpoint.
+ *
+ * Provides recipe and category read methods, plus write methods
+ * added in P1-U07 (saveRecipe, deleteRecipe, notifySync).
+ */
+import type { Category, Recipe, RecipeEntry, RecipeUid } from "./types.js";
+export declare class PaprikaClient {
+    private readonly email;
+    private readonly password;
+    private token;
+    private readonly _recipesBulkhead;
+    constructor(email: string, password: string);
+    authenticate(): Promise<void>;
+    listRecipes(): Promise<Array<RecipeEntry>>;
+    getRecipe(uid: string): Promise<Recipe>;
+    getRecipes(uids: ReadonlyArray<string>): Promise<Array<Recipe>>;
+    listCategories(): Promise<Array<Category>>;
+    saveRecipe(recipe: Readonly<Recipe>): Promise<Recipe>;
+    notifySync(): Promise<void>;
+    deleteRecipe(uid: RecipeUid): Promise<void>;
+    private buildRecipeFormData;
+    private request;
+}