@withpica/mcp-server 2.1.0

package/dist/pica-sdk.js

@@ -0,0 +1,1371 @@
+/**
+ * Lightweight PICA SDK client for MCP server
+ * Uses the PICA API directly without external dependencies
+ */
+// --- Request infrastructure ---
+const DEFAULT_TIMEOUT_MS = 30_000;
+const LONG_TIMEOUT_MS = 120_000;
+const MAX_RETRIES = 2;
+const RETRY_BASE_MS = 500;
+/** Paths that get extended timeouts (exports, enrichment, heavy ops) */
+const LONG_TIMEOUT_PATTERNS = [
+    "/exports/",
+    "/enrichment/",
+    "/enrich",
+    "/industry-ready",
+    "/catalog-asset-report",
+    "/analyze",
+    "/identify",
+    "/pica-score",
+    "/briefing",
+    "/pulse",
+    "/duplicates",
+];
+class ApiError extends Error {
+    status;
+    retryable;
+    retryAfterMs;
+    constructor(message, status, retryable, retryAfterMs) {
+        super(message);
+        this.status = status;
+        this.retryable = retryable;
+        this.retryAfterMs = retryAfterMs;
+        this.name = "ApiError";
+    }
+}
+function isRetryableStatus(status) {
+    return status === 429 || status === 502 || status === 503 || status === 504;
+}
+function getTimeoutForPath(path) {
+    return LONG_TIMEOUT_PATTERNS.some((p) => path.includes(p))
+        ? LONG_TIMEOUT_MS
+        : DEFAULT_TIMEOUT_MS;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class BaseResource {
+    baseUrl;
+    apiKey;
+    debug;
+    constructor(baseUrl, apiKey, debug) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.debug = debug;
+    }
+    async fetchWithTimeout(url, init, timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await fetch(url, { ...init, signal: controller.signal });
+        }
+        catch (err) {
+            if (err.name === "AbortError") {
+                throw new ApiError(`Request timed out after ${timeoutMs}ms: ${init.method} ${url}`, 0, true);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async fetchWithRetry(url, init, timeoutMs) {
+        let lastError;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const response = await this.fetchWithTimeout(url, init, timeoutMs);
+                if (response.ok)
+                    return response;
+                const errorText = await response.text();
+                // Auth errors — fail fast, never retry
+                if (response.status === 401 || response.status === 403) {
+                    throw new ApiError(`Authentication failed: ${response.status} ${errorText}`, response.status, false);
+                }
+                // Retryable errors — retry with backoff
+                if (isRetryableStatus(response.status) && attempt < MAX_RETRIES) {
+                    const retryAfter = response.headers.get("retry-after");
+                    const parsed = retryAfter ? parseInt(retryAfter, 10) : NaN;
+                    const delayMs = !isNaN(parsed)
+                        ? parsed * 1000
+                        : RETRY_BASE_MS * Math.pow(2, attempt);
+                    if (this.debug) {
+                        console.error(`[PICA SDK] ${response.status} on attempt ${attempt + 1}, retrying in ${delayMs}ms`);
+                    }
+                    await sleep(delayMs);
+                    continue;
+                }
+                // Non-retryable client/server error
+                throw new ApiError(`API request failed: ${response.status} ${errorText}`, response.status, false);
+            }
+            catch (err) {
+                if (err instanceof ApiError && !err.retryable)
+                    throw err;
+                lastError = err;
+                if (attempt < MAX_RETRIES) {
+                    const delayMs = RETRY_BASE_MS * Math.pow(2, attempt);
+                    if (this.debug) {
+                        console.error(`[PICA SDK] ${err.message} on attempt ${attempt + 1}, retrying in ${delayMs}ms`);
+                    }
+                    await sleep(delayMs);
+                    continue;
+                }
+            }
+        }
+        throw lastError || new Error("Request failed after retries");
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const timeoutMs = getTimeoutForPath(path);
+        if (this.debug) {
+            console.error(`[PICA SDK] ${method} ${url} (timeout: ${timeoutMs}ms)`);
+        }
+        const response = await this.fetchWithRetry(url, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        }, timeoutMs);
+        const data = await response.json();
+        return (data.data || data);
+    }
+    /**
+     * Make a request and return paginated result with metadata
+     */
+    async requestPaginated(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const timeoutMs = getTimeoutForPath(path);
+        if (this.debug) {
+            console.error(`[PICA SDK] ${method} ${url} (timeout: ${timeoutMs}ms)`);
+        }
+        const response = await this.fetchWithRetry(url, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        }, timeoutMs);
+        const json = await response.json();
+        const items = (json.data || []);
+        const total = json.pagination?.total ?? json.count ?? items.length;
+        const hasMore = json.pagination?.hasMore ?? total > items.length;
+        return { data: items, total, hasMore };
+    }
+}
+export { ApiError };
+class WorksResource extends BaseResource {
+    async list(params) {
+        const limit = params?.limit || 50;
+        return this.request("GET", `/admin/works?limit=${limit}`);
+    }
+    async search(params) {
+        const qp = new URLSearchParams();
+        if (params.query)
+            qp.set("query", params.query);
+        if (params.limit !== undefined)
+            qp.set("limit", String(params.limit));
+        if (params.offset !== undefined)
+            qp.set("offset", String(params.offset));
+        if (params.status)
+            qp.set("status", params.status);
+        if (params.type)
+            qp.set("type", params.type);
+        const qs = qp.toString();
+        return this.requestPaginated("GET", `/admin/works${qs ? `?${qs}` : ""}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/works/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/works", data);
+    }
+    async update(id, updates) {
+        return this.request("PATCH", `/admin/works/${id}`, updates);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/works/${id}`);
+    }
+    async verify(id) {
+        return this.request("POST", `/admin/works/${id}/verify`);
+    }
+    async bulkDelete(ids) {
+        await this.request("POST", "/admin/works/bulk-delete", { ids });
+    }
+}
+class PeopleResource extends BaseResource {
+    async list(params) {
+        const limit = params?.limit || 50;
+        return this.request("GET", `/admin/people?limit=${limit}`);
+    }
+    async search(params) {
+        const qp = new URLSearchParams();
+        if (params.query)
+            qp.set("query", params.query);
+        if (params.limit !== undefined)
+            qp.set("limit", String(params.limit));
+        if (params.offset !== undefined)
+            qp.set("offset", String(params.offset));
+        const qs = qp.toString();
+        return this.requestPaginated("GET", `/admin/people${qs ? `?${qs}` : ""}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/people/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/people", data);
+    }
+    async update(id, updates) {
+        return this.request("PATCH", `/admin/people/${id}`, updates);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/people/${id}`);
+    }
+    async enrichFromISNI(id, isni) {
+        return this.request("POST", `/admin/people/${id}/enrich/isni`, {
+            isni,
+        });
+    }
+    async enrichFromMusicBrainz(id, musicbrainz_id) {
+        return this.request("POST", `/admin/people/${id}/enrich/musicbrainz`, { musicbrainz_id });
+    }
+}
+class LicensingResource extends BaseResource {
+    /**
+     * Search for sync-licensable tracks by audio characteristics
+     */
+    async searchForSync(params = {}) {
+        const queryParams = new URLSearchParams();
+        if (params.mood)
+            queryParams.set("mood", params.mood);
+        if (params.genre)
+            queryParams.set("genre", params.genre);
+        if (params.min_bpm !== undefined)
+            queryParams.set("min_bpm", String(params.min_bpm));
+        if (params.max_bpm !== undefined)
+            queryParams.set("max_bpm", String(params.max_bpm));
+        if (params.key)
+            queryParams.set("key", params.key);
+        if (params.min_energy !== undefined)
+            queryParams.set("min_energy", String(params.min_energy));
+        if (params.max_energy !== undefined)
+            queryParams.set("max_energy", String(params.max_energy));
+        if (params.min_valence !== undefined)
+            queryParams.set("min_valence", String(params.min_valence));
+        if (params.max_valence !== undefined)
+            queryParams.set("max_valence", String(params.max_valence));
+        if (params.min_duration !== undefined)
+            queryParams.set("min_duration", String(params.min_duration));
+        if (params.max_duration !== undefined)
+            queryParams.set("max_duration", String(params.max_duration));
+        if (params.instrumental_only)
+            queryParams.set("instrumental_only", "true");
+        if (params.available_for_sync)
+            queryParams.set("available_for_sync", "true");
+        if (params.limit !== undefined)
+            queryParams.set("limit", String(params.limit));
+        const query = queryParams.toString();
+        const path = `/admin/audio-files/search-for-sync${query ? `?${query}` : ""}`;
+        return this.request("GET", path);
+    }
+    /**
+     * Submit a license enquiry for a track
+     */
+    async submitEnquiry(enquiry) {
+        return this.request("POST", "/admin/license-enquiries", enquiry);
+    }
+    /**
+     * List license enquiries with optional filters
+     */
+    async listEnquiries(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.work_id)
+            queryParams.set("work_id", params.work_id);
+        if (params?.status)
+            queryParams.set("status", params.status);
+        if (params?.project_type)
+            queryParams.set("project_type", params.project_type);
+        if (params?.territory)
+            queryParams.set("territory", params.territory);
+        if (params?.limit !== undefined)
+            queryParams.set("limit", String(params.limit));
+        if (params?.offset !== undefined)
+            queryParams.set("offset", String(params.offset));
+        const query = queryParams.toString();
+        const path = `/admin/license-enquiries${query ? `?${query}` : ""}`;
+        return this.request("GET", path);
+    }
+    /**
+     * Get a specific license enquiry by ID
+     */
+    async getEnquiry(id) {
+        return this.request("GET", `/admin/license-enquiries/${id}`);
+    }
+    /**
+     * Update a license enquiry status
+     */
+    async updateEnquiryStatus(id, status, notes) {
+        return this.request("PATCH", `/admin/license-enquiries/${id}`, { status, your_notes: notes });
+    }
+}
+class CreditsResource extends BaseResource {
+    async listForWork(workId) {
+        return this.request("GET", `/admin/works/${workId}/credits`);
+    }
+    async updateForWork(workId, credits) {
+        return this.request("POST", `/admin/works/${workId}/credits`, credits);
+    }
+}
+class CreditsBalanceResource extends BaseResource {
+    async getBalance() {
+        return this.request("GET", "/admin/credits/balance");
+    }
+    async purchase(params) {
+        return this.request("POST", "/admin/credits/purchase", params);
+    }
+}
+class PicaScoreResource extends BaseResource {
+    async get() {
+        return this.request("GET", "/admin/pica-score");
+    }
+}
+class AudioFilesResource extends BaseResource {
+    async list(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.work_id)
+            queryParams.set("work_id", params.work_id);
+        if (params?.file_type)
+            queryParams.set("file_type", params.file_type);
+        if (params?.unprocessed)
+            queryParams.set("unprocessed", "true");
+        if (params?.limit !== undefined)
+            queryParams.set("limit", String(params.limit));
+        const query = queryParams.toString();
+        return this.request("GET", `/admin/audio-files${query ? `?${query}` : ""}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/audio-files/${id}`);
+    }
+    async analyze(id, options) {
+        return this.request("POST", `/admin/audio-files/${id}/analyze`, options);
+    }
+    async getStatus(id) {
+        return this.request("GET", `/admin/audio-files/${id}/status`);
+    }
+    async presignedUpload(params) {
+        return this.request("POST", "/admin/audio-files/presigned-upload", {
+            filename: params.filename,
+            contentType: params.contentType,
+            fileSize: params.fileSize,
+            workId: params.workId,
+            title: params.title,
+            fileType: params.fileType,
+        });
+    }
+    async completeUpload(params) {
+        return this.request("POST", "/admin/audio-files/complete-upload", params);
+    }
+    async identify(id, options) {
+        return this.request("POST", `/admin/audio-files/${id}/identify`, options);
+    }
+}
+class MultimediaResource extends BaseResource {
+    async search(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.query)
+            queryParams.set("query", params.query);
+        if (params?.content_type)
+            queryParams.set("content_type", params.content_type);
+        if (params?.classification)
+            queryParams.set("classification", params.classification);
+        if (params?.is_published !== undefined)
+            queryParams.set("is_published", String(params.is_published));
+        if (params?.work_id)
+            queryParams.set("work_id", params.work_id);
+        if (params?.person_id)
+            queryParams.set("person_id", params.person_id);
+        if (params?.limit !== undefined)
+            queryParams.set("limit", String(params.limit));
+        if (params?.offset !== undefined)
+            queryParams.set("offset", String(params.offset));
+        const query = queryParams.toString();
+        return this.request("GET", `/admin/multimedia${query ? `?${query}` : ""}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/multimedia", data);
+    }
+    async importFromUrl(params) {
+        return this.request("POST", "/admin/multimedia/import-from-url", params);
+    }
+    async linkYoutube(params) {
+        return this.request("POST", "/admin/multimedia/link-youtube", params);
+    }
+    async linkWork(id, workId, relationshipType, notes) {
+        return this.request("POST", `/admin/multimedia/${id}/link-work`, {
+            work_id: workId,
+            relationship_type: relationshipType,
+            notes,
+        });
+    }
+}
+class AgreementsResource extends BaseResource {
+    async list(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.query)
+            queryParams.set("query", params.query);
+        if (params?.agreement_type)
+            queryParams.set("agreement_type", params.agreement_type);
+        if (params?.status)
+            queryParams.set("status", params.status);
+        if (params?.party_name)
+            queryParams.set("party_name", params.party_name);
+        if (params?.includeWorkCounts)
+            queryParams.set("includeWorkCounts", "true");
+        if (params?.limit !== undefined)
+            queryParams.set("limit", String(params.limit));
+        if (params?.offset !== undefined)
+            queryParams.set("offset", String(params.offset));
+        const query = queryParams.toString();
+        return this.request("GET", `/admin/agreements${query ? `?${query}` : ""}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/agreements/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/agreements", data);
+    }
+    async update(id, updates) {
+        return this.request("PATCH", `/admin/agreements/${id}`, updates);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/agreements/${id}`);
+    }
+    async getWorks(id) {
+        return this.request("GET", `/admin/agreements/${id}/works`);
+    }
+    async linkWork(id, data) {
+        return this.request("POST", `/admin/agreements/${id}/works`, data);
+    }
+}
+class WorkspaceResource extends BaseResource {
+    async getContext() {
+        return this.request("GET", "/admin/workspace/context");
+    }
+    async getRecentEvents(limit) {
+        return this.request("GET", `/admin/events?limit=${limit || 20}`);
+    }
+}
+class MemoryResource extends BaseResource {
+    async list() {
+        return this.request("GET", "/admin/memory");
+    }
+    async search(query) {
+        return this.request("GET", `/admin/memory/search?q=${encodeURIComponent(query)}`);
+    }
+    async save(params) {
+        return this.request("POST", "/admin/memory", params);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/memory/${id}`);
+    }
+}
+class NotesResource extends BaseResource {
+    async list(params) {
+        const query = new URLSearchParams();
+        if (params?.q)
+            query.set("q", params.q);
+        if (params?.work)
+            query.set("work", params.work);
+        if (params?.person)
+            query.set("person", params.person);
+        if (params?.limit)
+            query.set("limit", String(params.limit));
+        const qs = query.toString();
+        return this.request("GET", `/admin/notes${qs ? `?${qs}` : ""}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/notes/${id}`);
+    }
+    async create(content, metadata) {
+        return this.request("POST", "/admin/notes", { content, ...metadata });
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/notes/${id}`);
+    }
+}
+class TeamResource extends BaseResource {
+    async list() {
+        return this.request("GET", "/admin/team");
+    }
+    async get(id) {
+        return this.request("GET", `/admin/team/${id}`);
+    }
+    async invite(data) {
+        return this.request("POST", "/admin/team", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/team/${id}`, data);
+    }
+    async remove(id) {
+        return this.request("DELETE", `/admin/team/${id}`);
+    }
+}
+class RecordingsResource extends BaseResource {
+    async list(params) {
+        const limit = params?.limit || 50;
+        return this.request("GET", `/admin/recordings?limit=${limit}`);
+    }
+    /**
+     * Search recordings. The recordings API doesn't support text search,
+     * so we fetch all and filter client-side for text queries.
+     */
+    async search(params) {
+        // Best-effort ceiling: recordings API has no text search, so we fetch up to 200
+        // and filter client-side. Will need server-side search when recordings exceed this.
+        const fetchLimit = params.query ? 200 : params.limit || 50;
+        const qp = new URLSearchParams();
+        qp.set("limit", String(fetchLimit));
+        if (params.offset !== undefined && !params.query)
+            qp.set("offset", String(params.offset));
+        const qs = qp.toString();
+        const result = await this.requestPaginated("GET", `/admin/recordings?${qs}`);
+        if (params.query) {
+            const q = params.query.toLowerCase();
+            const filtered = result.data.filter((r) => (r.title && r.title.toLowerCase().includes(q)) ||
+                (r.isrc && r.isrc.toLowerCase().includes(q)));
+            const limit = params.limit || 20;
+            const start = params.offset || 0;
+            return {
+                data: filtered.slice(start, start + limit),
+                total: filtered.length,
+                hasMore: start + limit < filtered.length,
+            };
+        }
+        return result;
+    }
+    async get(id) {
+        return this.request("GET", `/admin/recordings/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/recordings", data);
+    }
+    async update(id, updates) {
+        return this.request("PATCH", `/admin/recordings/${id}`, updates);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/recordings/${id}`);
+    }
+    async getByWork(workId) {
+        return this.request("GET", `/admin/works/${workId}/recordings`);
+    }
+    async prefixLookup(isrc) {
+        const prefix = isrc
+            .toUpperCase()
+            .replace(/[^A-Z0-9]/g, "")
+            .slice(0, 5);
+        if (prefix.length < 5)
+            return null;
+        try {
+            const result = await this.request("GET", `/admin/isrc/prefix/${prefix}`);
+            return result.data ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+// --- Enrichment Resource ---
+class EnrichmentResource extends BaseResource {
+    async enrichWork(workId) {
+        return this.request("POST", `/admin/works/${workId}/enrich`);
+    }
+    async enrichPerson(personId) {
+        return this.request("POST", `/admin/people/${personId}/enrich`);
+    }
+    async getWorkEnrichmentStatus(workId) {
+        return this.request("GET", `/admin/works/${workId}/enrichment-status`);
+    }
+    async getCandidates() {
+        return this.request("POST", "/admin/enrichment-candidates/refresh");
+    }
+    async enrichWorkMlc(workId) {
+        return this.request("POST", `/admin/works/${workId}/enrich-mlc`);
+    }
+    async enrichWorkMusicBrainz(workId) {
+        return this.request("GET", `/admin/works/${workId}/musicbrainz-preview`);
+    }
+    async enrichWorkDiscogs(workId) {
+        return this.request("GET", `/admin/works/${workId}/discogs-preview`);
+    }
+    async enrichWorkSpotify(workId) {
+        return this.request("POST", `/admin/spotify/enrich/${workId}`);
+    }
+    async enrichWorkYouTube(workId) {
+        return this.request("POST", `/admin/youtube/enrich/${workId}`);
+    }
+}
+// --- Registration Resource ---
+class RegistrationResource extends BaseResource {
+    async getCoverage() {
+        return this.request("GET", "/admin/analytics/enrichment-coverage");
+    }
+    async getWorkCascadeStatus(workId) {
+        return this.request("GET", `/admin/works/${workId}/cascade-status`);
+    }
+}
+// --- Health Resource ---
+class HealthResource extends BaseResource {
+    async getWorksHealth() {
+        return this.request("GET", "/admin/quality/works-health");
+    }
+    async getLowScoreWorks() {
+        return this.request("GET", "/admin/quality/completeness/low-score");
+    }
+    async getWorkCompleteness(workId) {
+        return this.request("GET", `/admin/quality/completeness/${workId}`);
+    }
+}
+// --- Dashboard & Discoveries Resource ---
+class DashboardResource extends BaseResource {
+    async discoveries(params) {
+        const query = new URLSearchParams();
+        if (params?.unread)
+            query.set("unread", "true");
+        if (params?.limit)
+            query.set("limit", String(params.limit));
+        const qs = query.toString();
+        return this.request("GET", `/admin/discoveries${qs ? `?${qs}` : ""}`);
+    }
+    async pendingDiscoveries() {
+        return this.request("GET", "/admin/discoveries/pending");
+    }
+    async reviewDiscovery(discoveryId, status) {
+        return this.request("POST", "/admin/discoveries/review", {
+            discoveryId,
+            status,
+        });
+    }
+    async attentionItems(params) {
+        const query = new URLSearchParams();
+        if (params?.door)
+            query.set("door", params.door);
+        if (params?.limit)
+            query.set("limit", String(params.limit));
+        const qs = query.toString();
+        return this.request("GET", `/admin/dashboard/attention-items${qs ? `?${qs}` : ""}`);
+    }
+    async briefing() {
+        return this.request("GET", "/admin/dashboard/briefing");
+    }
+    async pulse() {
+        return this.request("GET", "/admin/dashboard/pulse");
+    }
+}
+// --- Integrations Resource ---
+class IntegrationsResource extends BaseResource {
+    async oauthConnections() {
+        return this.request("GET", "/admin/integrations/oauth/connections");
+    }
+    async platforms() {
+        return this.request("GET", "/admin/integrations/platforms");
+    }
+}
+// --- Settings Resource (credits history, storage, org profile) ---
+class SettingsResource extends BaseResource {
+    async creditsHistory(params) {
+        const query = new URLSearchParams();
+        if (params?.type)
+            query.set("type", params.type);
+        if (params?.limit)
+            query.set("limit", String(params.limit));
+        const qs = query.toString();
+        return this.request("GET", `/admin/credits/history${qs ? `?${qs}` : ""}`);
+    }
+    async storageConfig() {
+        return this.request("GET", "/admin/settings/storage");
+    }
+    async orgProfile() {
+        return this.request("GET", "/admin/settings/organisation-profile");
+    }
+    async userProfile() {
+        return this.request("GET", "/admin/settings/user-profile");
+    }
+}
+// --- Calendar Resource ---
+class CalendarResource extends BaseResource {
+    async getEvents(params) {
+        const query = new URLSearchParams();
+        query.set("startDate", params.startDate);
+        query.set("endDate", params.endDate);
+        if (params.types?.length) {
+            params.types.forEach((t) => query.append("types[]", t));
+        }
+        if (params.workId)
+            query.set("workId", params.workId);
+        if (params.search)
+            query.set("search", params.search);
+        return this.request("GET", `/admin/calendar?${query.toString()}`);
+    }
+}
+// --- Notifications Resource ---
+class NotificationsResource extends BaseResource {
+    async list() {
+        return this.request("GET", "/admin/notifications");
+    }
+    async markRead(ids) {
+        return this.request("POST", "/admin/notifications", {
+            notificationIds: ids,
+        });
+    }
+    async sendToPerson(params) {
+        return this.request("POST", "/admin/notifications/send-to-person", params);
+    }
+}
+// --- Analytics Resource (carbon, provenance, diligence) ---
+class AnalyticsResource extends BaseResource {
+    async carbonSummary() {
+        return this.request("GET", "/admin/carbon/summary");
+    }
+    async carbonLive() {
+        return this.request("GET", "/admin/carbon/live");
+    }
+    async provenanceStats() {
+        return this.request("GET", "/admin/provenance/stats");
+    }
+    async provenanceWork(workId) {
+        return this.request("GET", `/admin/quality/provenance/${workId}`);
+    }
+    async provenanceCertificate(workId) {
+        return this.request("GET", `/admin/works/${workId}/certificate`);
+    }
+    async catalogDiligence() {
+        return this.request("GET", "/admin/exports/catalog-diligence");
+    }
+}
+// --- Bulk Operations Resource ---
+class BulkResource extends BaseResource {
+    async updateWorks(workIds, updates) {
+        return this.request("POST", "/admin/works/bulk-update", {
+            work_ids: workIds,
+            updates,
+        });
+    }
+    async updatePeopleRoles(personIds, roles) {
+        return this.request("POST", "/admin/people/bulk-update-roles", {
+            person_ids: personIds,
+            roles,
+        });
+    }
+}
+// --- Export Resource ---
+class ExportResource extends BaseResource {
+    async catalogCsv(params) {
+        const query = params?.format ? `?format=${params.format}` : "";
+        return this.request("GET", `/admin/works/export${query}`);
+    }
+    async songRegistration() {
+        return this.request("GET", "/admin/exports/song-registration");
+    }
+    async industryReady() {
+        return this.request("GET", "/admin/exports/industry-ready");
+    }
+    async catalogAssetReport(params) {
+        return this.request("POST", "/admin/exports/catalog-asset-report", params);
+    }
+    async aiConsent() {
+        return this.request("GET", "/admin/exports/ai-consent?format=json");
+    }
+}
+// --- Duplicates Resource ---
+class DuplicatesResource extends BaseResource {
+    async findDuplicates(entityType) {
+        return this.request("GET", `/admin/catalog/duplicates?entity_type=${entityType}`);
+    }
+    async merge(entityType, winnerId, loserIds) {
+        return this.request("POST", "/admin/catalog/merge", {
+            entity_type: entityType,
+            winner_id: winnerId,
+            loser_ids: loserIds,
+        });
+    }
+}
+// --- Entity Context Resource (ADR-116 Phase 3) ---
+class EntityContextResource extends BaseResource {
+    async getWorkFull(workId) {
+        return this.request("GET", `/admin/works/${workId}/full`);
+    }
+    async getPersonFull(personId) {
+        return this.request("GET", `/admin/people/${personId}/full`);
+    }
+}
+// --- Comparisons Resource (ADR-116 Phase 2) ---
+class ComparisonsResource extends BaseResource {
+    async enrichmentCompare(params) {
+        const base = params.entityType === "work"
+            ? `/admin/works/${params.entityId}/enrichment-compare`
+            : `/admin/people/${params.entityId}/enrichment-compare`;
+        return this.request("GET", base);
+    }
+    async registrationsCompare(workId) {
+        return this.request("GET", `/admin/works/${workId}/registration-compare`);
+    }
+}
+// --- Send Hub Resource ---
+class SendResource extends BaseResource {
+    async send(params) {
+        return this.request("POST", "/admin/send", params);
+    }
+    async list(params) {
+        const qp = new URLSearchParams();
+        if (params?.type)
+            qp.set("type", params.type);
+        if (params?.status)
+            qp.set("status", params.status);
+        if (params?.personId)
+            qp.set("person_id", params.personId);
+        if (params?.workId)
+            qp.set("work_id", params.workId);
+        if (params?.limit !== undefined)
+            qp.set("limit", String(params.limit));
+        if (params?.offset !== undefined)
+            qp.set("offset", String(params.offset));
+        const qs = qp.toString();
+        return this.request("GET", `/admin/send${qs ? `?${qs}` : ""}`);
+    }
+    async listPending() {
+        return this.request("GET", "/admin/send/pending");
+    }
+    async resend(id) {
+        return this.request("POST", `/admin/send/${id}/resend`);
+    }
+}
+// --- Assets Resource (physical assets: equipment, instruments, studio gear) ---
+class AssetsResource extends BaseResource {
+    async list(params) {
+        const query = new URLSearchParams();
+        if (params?.category)
+            query.set("category", params.category);
+        if (params?.limit)
+            query.set("limit", String(params.limit));
+        const qs = query.toString();
+        return this.request("GET", `/admin/assets${qs ? `?${qs}` : ""}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/assets/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/assets", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/assets/${id}`, data);
+    }
+    async delete(id) {
+        return this.request("DELETE", `/admin/assets/${id}`);
+    }
+    async stats() {
+        return this.request("GET", "/admin/assets/stats");
+    }
+    async valuations(id) {
+        return this.request("GET", `/admin/assets/${id}/valuations`);
+    }
+    async exportAll() {
+        return this.request("GET", "/admin/assets/export");
+    }
+    async marketCheck(id) {
+        return this.request("GET", `/admin/assets/${id}/market-check`);
+    }
+}
+class StorageResource extends BaseResource {
+    async presignedUpload(params) {
+        return this.request("POST", "/admin/storage/presigned-upload", params);
+    }
+    async completeUpload(params) {
+        return this.request("POST", "/admin/storage/complete-upload", params);
+    }
+}
+class ImportResource extends BaseResource {
+    async analyze(params) {
+        return this.request("POST", "/admin/import/analyze", params);
+    }
+    async suggestMapping(params) {
+        return this.request("POST", "/admin/import/suggest-mapping", params);
+    }
+    async validate(params) {
+        return this.request("POST", "/admin/import/validate", params);
+    }
+    async execute(params) {
+        return this.request("POST", "/admin/import/execute", params);
+    }
+    async getFields(domain) {
+        return this.request("GET", `/admin/import/fields?domain=${domain}`);
+    }
+    async streamingLinkPreview(url) {
+        return this.request("POST", "/admin/import/streaming-link", { url });
+    }
+    async streamingLinkImport(url, selectedTrackIds) {
+        return this.request("POST", "/admin/import/streaming-link", {
+            url,
+            confirm: true,
+            selectedTrackIds,
+        });
+    }
+    async getTemplate(domain) {
+        // Template route returns CSV as text/csv — use raw fetch
+        const url = `${this.baseUrl}/admin/import/template?domain=${domain}`;
+        const response = await fetch(url, {
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+        });
+        if (!response.ok)
+            throw new Error(`Template fetch failed: ${response.status}`);
+        return response.text();
+    }
+}
+// --- Documents Resource ---
+class DocumentsResource extends BaseResource {
+    async analyse(id) {
+        return this.request("POST", `/admin/documents/${id}/analyse`);
+    }
+}
+class CollaboratorsResource extends BaseResource {
+    async invite(params) {
+        return this.request("POST", "/admin/collaborators/invite", params);
+    }
+    async listInvites(params) {
+        const qp = new URLSearchParams();
+        if (params?.status)
+            qp.set("status", params.status);
+        if (params?.workId)
+            qp.set("workId", params.workId);
+        if (params?.limit !== undefined)
+            qp.set("limit", String(params.limit));
+        const qs = qp.toString();
+        return this.request("GET", `/admin/collaborators/invites${qs ? `?${qs}` : ""}`);
+    }
+    async resendInvite(inviteId) {
+        return this.request("POST", `/admin/collaborators/invites/${inviteId}/resend`);
+    }
+}
+class DirectoryResource extends BaseResource {
+    async getSettings() {
+        return this.request("GET", "/admin/directory/settings");
+    }
+    async updateSettings(updates) {
+        return this.request("PATCH", "/admin/directory/settings", updates);
+    }
+}
+class ProjectsResource extends BaseResource {
+    async list(params) {
+        const qs = params?.limit ? `?limit=${params.limit}` : "";
+        return this.request("GET", `/admin/projects${qs}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/projects/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/projects", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/projects/${id}`, data);
+    }
+    async delete(id) {
+        return this.request("DELETE", `/admin/projects/${id}`);
+    }
+}
+class SplitSheetsResource extends BaseResource {
+    async listForWork(workId) {
+        return this.request("GET", `/admin/works/${workId}/split-sheet`);
+    }
+    async generate(workId) {
+        return this.request("POST", `/admin/works/${workId}/split-sheet`);
+    }
+    async get(workId, splitSheetId) {
+        return this.request("GET", `/admin/works/${workId}/split-sheet/${splitSheetId}`);
+    }
+}
+class RecordingSplitsResource extends BaseResource {
+    async list(recordingId) {
+        return this.request("GET", `/admin/recordings/${recordingId}/splits`);
+    }
+    async create(recordingId, data) {
+        return this.request("POST", `/admin/recordings/${recordingId}/splits`, data);
+    }
+    async update(recordingId, splitId, data) {
+        return this.request("PATCH", `/admin/recordings/${recordingId}/splits/${splitId}`, data);
+    }
+    async delete(recordingId, splitId) {
+        return this.request("DELETE", `/admin/recordings/${recordingId}/splits/${splitId}`);
+    }
+    async verify(recordingId, splitId) {
+        return this.request("POST", `/admin/recordings/${recordingId}/splits/${splitId}/verify`);
+    }
+}
+class ReleasesResource extends BaseResource {
+    async list(params) {
+        const qs = params?.limit ? `?limit=${params.limit}` : "";
+        return this.request("GET", `/admin/releases${qs}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/releases/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/releases", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/releases/${id}`, data);
+    }
+    async delete(id) {
+        return this.request("DELETE", `/admin/releases/${id}`);
+    }
+}
+class SessionsResource extends BaseResource {
+    async list(params) {
+        const qs = params?.limit ? `?limit=${params.limit}` : "";
+        return this.request("GET", `/admin/sessions${qs}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/sessions/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/sessions", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/sessions/${id}`, data);
+    }
+    async getTypes() {
+        return this.request("GET", "/admin/sessions/types");
+    }
+}
+class AgreementTemplatesResource extends BaseResource {
+    async list() {
+        return this.request("GET", "/admin/agreement-templates");
+    }
+    async get(id) {
+        return this.request("GET", `/admin/agreement-templates/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/agreement-templates", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/agreement-templates/${id}`, data);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/agreement-templates/${id}`);
+    }
+    async render(id, data) {
+        return this.request("POST", `/admin/agreement-templates/${id}/render`, data);
+    }
+    async duplicate(id) {
+        return this.request("POST", `/admin/agreement-templates/${id}/duplicate`);
+    }
+    async setDefault(id) {
+        return this.request("POST", `/admin/agreement-templates/${id}/set-default`);
+    }
+}
+class ProducerAgreementsResource extends BaseResource {
+    async list() {
+        return this.request("GET", "/admin/producer-agreements");
+    }
+    async get(id) {
+        return this.request("GET", `/admin/producer-agreements/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/producer-agreements", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/producer-agreements/${id}`, data);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/producer-agreements/${id}`);
+    }
+}
+class WorkForHireResource extends BaseResource {
+    async list() {
+        return this.request("GET", "/admin/work-for-hire");
+    }
+    async get(id) {
+        return this.request("GET", `/admin/work-for-hire/${id}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/work-for-hire", data);
+    }
+    async update(id, data) {
+        return this.request("PATCH", `/admin/work-for-hire/${id}`, data);
+    }
+    async delete(id) {
+        await this.request("DELETE", `/admin/work-for-hire/${id}`);
+    }
+}
+class RoyaltiesResource extends BaseResource {
+    async payments(params) {
+        const qp = new URLSearchParams();
+        if (params?.source)
+            qp.set("source", params.source);
+        if (params?.workId)
+            qp.set("workId", params.workId);
+        if (params?.fromDate)
+            qp.set("fromDate", params.fromDate);
+        if (params?.toDate)
+            qp.set("toDate", params.toDate);
+        if (params?.limit)
+            qp.set("limit", String(params.limit));
+        if (params?.offset)
+            qp.set("offset", String(params.offset));
+        const qs = qp.toString();
+        return this.request("GET", `/admin/royalties/payments${qs ? `?${qs}` : ""}`);
+    }
+    async earnings(params) {
+        const qp = new URLSearchParams();
+        if (params?.start_date)
+            qp.set("start_date", params.start_date);
+        if (params?.end_date)
+            qp.set("end_date", params.end_date);
+        if (params?.source)
+            qp.set("source", params.source);
+        if (params?.limit)
+            qp.set("limit", String(params.limit));
+        if (params?.offset)
+            qp.set("offset", String(params.offset));
+        const qs = qp.toString();
+        return this.request("GET", `/admin/royalties/earnings${qs ? `?${qs}` : ""}`);
+    }
+    async gaps(params) {
+        const qp = new URLSearchParams();
+        if (params?.priority)
+            qp.set("priority", params.priority);
+        if (params?.gapType)
+            qp.set("gapType", params.gapType);
+        if (params?.workId)
+            qp.set("workId", params.workId);
+        if (params?.limit)
+            qp.set("limit", String(params.limit));
+        const qs = qp.toString();
+        return this.request("GET", `/admin/royalties/gaps${qs ? `?${qs}` : ""}`);
+    }
+    async stats() {
+        return this.request("GET", "/admin/royalties/stats");
+    }
+}
+class StatementsResource extends BaseResource {
+    async history(params) {
+        const qp = new URLSearchParams();
+        if (params?.source)
+            qp.set("source", params.source);
+        if (params?.dateFrom)
+            qp.set("dateFrom", params.dateFrom);
+        if (params?.dateTo)
+            qp.set("dateTo", params.dateTo);
+        if (params?.search)
+            qp.set("search", params.search);
+        if (params?.limit)
+            qp.set("limit", String(params.limit));
+        if (params?.offset)
+            qp.set("offset", String(params.offset));
+        if (params?.sort)
+            qp.set("sort", params.sort);
+        const qs = qp.toString();
+        return this.request("GET", `/admin/statements/history${qs ? `?${qs}` : ""}`);
+    }
+    async get(batchId) {
+        return this.request("GET", `/admin/statements/${batchId}`);
+    }
+}
+class ShareLinksResource extends BaseResource {
+    async list(params) {
+        const qp = new URLSearchParams();
+        if (params?.work_id)
+            qp.set("work_id", params.work_id);
+        const qs = qp.toString();
+        return this.request("GET", `/admin/share-links${qs ? `?${qs}` : ""}`);
+    }
+    async create(data) {
+        return this.request("POST", "/admin/share-links", data);
+    }
+}
+class DisputesResource extends BaseResource {
+    async list(params) {
+        const qp = new URLSearchParams();
+        if (params?.status)
+            qp.set("status", params.status);
+        const qs = qp.toString();
+        return this.request("GET", `/admin/disputes${qs ? `?${qs}` : ""}`);
+    }
+}
+class ChainResource extends BaseResource {
+    async search(params) {
+        const qp = new URLSearchParams();
+        qp.set("q", params.q);
+        if (params.limit)
+            qp.set("limit", String(params.limit));
+        if (params.expand_first !== undefined)
+            qp.set("expand_first", String(params.expand_first));
+        return this.request("GET", `/admin/chain?${qp.toString()}`);
+    }
+    async getById(type, id) {
+        return this.request("GET", `/admin/chain?type=${type}&id=${id}`);
+    }
+    async traverse(identifier) {
+        return this.request("GET", `/admin/chain?identifier=${encodeURIComponent(identifier)}`);
+    }
+}
+class TelegramResource extends BaseResource {
+    async getStatus() {
+        return this.request("GET", "/admin/settings/telegram");
+    }
+    async sendNotification(message) {
+        return this.request("POST", "/admin/settings/telegram/test", {
+            message,
+        });
+    }
+    async getPreferences() {
+        return this.request("GET", "/admin/settings/telegram/notifications");
+    }
+}
+class ImportDocumentsResource extends BaseResource {
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options?.source)
+            params.set("source", options.source);
+        if (options?.period)
+            params.set("period", options.period);
+        if (options?.document_type)
+            params.set("document_type", options.document_type);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        const qs = params.toString();
+        return this.request("GET", `/admin/import-documents${qs ? `?${qs}` : ""}`);
+    }
+    async get(id) {
+        return this.request("GET", `/admin/import-documents/${id}`);
+    }
+    async ingest(content) {
+        return this.request("POST", "/admin/import-documents", { content });
+    }
+}
+export class PicaClient {
+    works;
+    people;
+    recordings;
+    licensing;
+    credits;
+    creditsBalance;
+    picaScore;
+    audioFiles;
+    multimedia;
+    agreements;
+    workspace;
+    memory;
+    enrichment;
+    registration;
+    health;
+    bulk;
+    exports;
+    duplicates;
+    collaborators;
+    entityContext;
+    comparisons;
+    send;
+    imports;
+    storage;
+    documents;
+    analytics;
+    notifications;
+    calendar;
+    dashboard;
+    integrations;
+    settings;
+    directory;
+    importDocuments;
+    sessions;
+    assets;
+    notes;
+    team;
+    projects;
+    releases;
+    splitSheets;
+    recordingSplits;
+    agreementTemplates;
+    producerAgreements;
+    workForHire;
+    royalties;
+    statements;
+    shareLinks;
+    disputes;
+    chain;
+    telegram;
+    /**
+     * Get accurate catalog stats via SQL counts (no pagination limits)
+     */
+    async catalogStats() {
+        const baseUrl = this.works["baseUrl"];
+        const apiKey = this.works["apiKey"];
+        const res = await fetch(`${baseUrl}/admin/catalog/stats`, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!res.ok)
+            throw new Error(`Catalog stats failed: ${res.status}`);
+        const json = (await res.json());
+        return (json.data || json);
+    }
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error("API key is required");
+        }
+        const baseUrl = config.baseUrl || "https://withpica.com/api";
+        const debug = config.debug || false;
+        this.works = new WorksResource(baseUrl, config.apiKey, debug);
+        this.people = new PeopleResource(baseUrl, config.apiKey, debug);
+        this.recordings = new RecordingsResource(baseUrl, config.apiKey, debug);
+        this.licensing = new LicensingResource(baseUrl, config.apiKey, debug);
+        this.credits = new CreditsResource(baseUrl, config.apiKey, debug);
+        this.creditsBalance = new CreditsBalanceResource(baseUrl, config.apiKey, debug);
+        this.picaScore = new PicaScoreResource(baseUrl, config.apiKey, debug);
+        this.audioFiles = new AudioFilesResource(baseUrl, config.apiKey, debug);
+        this.multimedia = new MultimediaResource(baseUrl, config.apiKey, debug);
+        this.agreements = new AgreementsResource(baseUrl, config.apiKey, debug);
+        this.workspace = new WorkspaceResource(baseUrl, config.apiKey, debug);
+        this.memory = new MemoryResource(baseUrl, config.apiKey, debug);
+        this.enrichment = new EnrichmentResource(baseUrl, config.apiKey, debug);
+        this.registration = new RegistrationResource(baseUrl, config.apiKey, debug);
+        this.health = new HealthResource(baseUrl, config.apiKey, debug);
+        this.bulk = new BulkResource(baseUrl, config.apiKey, debug);
+        this.exports = new ExportResource(baseUrl, config.apiKey, debug);
+        this.duplicates = new DuplicatesResource(baseUrl, config.apiKey, debug);
+        this.collaborators = new CollaboratorsResource(baseUrl, config.apiKey, debug);
+        this.entityContext = new EntityContextResource(baseUrl, config.apiKey, debug);
+        this.comparisons = new ComparisonsResource(baseUrl, config.apiKey, debug);
+        this.send = new SendResource(baseUrl, config.apiKey, debug);
+        this.imports = new ImportResource(baseUrl, config.apiKey, debug);
+        this.storage = new StorageResource(baseUrl, config.apiKey, debug);
+        this.documents = new DocumentsResource(baseUrl, config.apiKey, debug);
+        this.analytics = new AnalyticsResource(baseUrl, config.apiKey, debug);
+        this.notifications = new NotificationsResource(baseUrl, config.apiKey, debug);
+        this.calendar = new CalendarResource(baseUrl, config.apiKey, debug);
+        this.dashboard = new DashboardResource(baseUrl, config.apiKey, debug);
+        this.integrations = new IntegrationsResource(baseUrl, config.apiKey, debug);
+        this.settings = new SettingsResource(baseUrl, config.apiKey, debug);
+        this.directory = new DirectoryResource(baseUrl, config.apiKey, debug);
+        this.importDocuments = new ImportDocumentsResource(baseUrl, config.apiKey, debug);
+        this.sessions = new SessionsResource(baseUrl, config.apiKey, debug);
+        this.assets = new AssetsResource(baseUrl, config.apiKey, debug);
+        this.notes = new NotesResource(baseUrl, config.apiKey, debug);
+        this.team = new TeamResource(baseUrl, config.apiKey, debug);
+        this.projects = new ProjectsResource(baseUrl, config.apiKey, debug);
+        this.releases = new ReleasesResource(baseUrl, config.apiKey, debug);
+        this.splitSheets = new SplitSheetsResource(baseUrl, config.apiKey, debug);
+        this.recordingSplits = new RecordingSplitsResource(baseUrl, config.apiKey, debug);
+        this.agreementTemplates = new AgreementTemplatesResource(baseUrl, config.apiKey, debug);
+        this.producerAgreements = new ProducerAgreementsResource(baseUrl, config.apiKey, debug);
+        this.workForHire = new WorkForHireResource(baseUrl, config.apiKey, debug);
+        this.royalties = new RoyaltiesResource(baseUrl, config.apiKey, debug);
+        this.statements = new StatementsResource(baseUrl, config.apiKey, debug);
+        this.shareLinks = new ShareLinksResource(baseUrl, config.apiKey, debug);
+        this.disputes = new DisputesResource(baseUrl, config.apiKey, debug);
+        this.chain = new ChainResource(baseUrl, config.apiKey, debug);
+        this.telegram = new TelegramResource(baseUrl, config.apiKey, debug);
+    }
+}
+//# sourceMappingURL=pica-sdk.js.map