@withpica/mcp-server 2.1.0

package/dist/pica-sdk.d.ts

@@ -0,0 +1,1162 @@
+/**
+ * Lightweight PICA SDK client for MCP server
+ * Uses the PICA API directly without external dependencies
+ */
+interface CatalogStats {
+    works: {
+        total: number;
+        with_iswc: number;
+    };
+    recordings: {
+        total: number;
+        with_isrc: number;
+    };
+    people: {
+        total: number;
+        with_email: number;
+        with_isni: number;
+        with_musicbrainz: number;
+    };
+    agreements: {
+        total: number;
+    };
+}
+interface PicaClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    debug?: boolean;
+}
+interface PaginatedResult<T> {
+    data: T[];
+    total: number;
+    hasMore: boolean;
+}
+interface Work {
+    id: string;
+    title: string;
+    work_type: string;
+    work_status?: string;
+    release_format?: string;
+    iswc?: string;
+    isrc?: string;
+    primary_artist?: string;
+    duration_seconds?: number;
+    is_verified: boolean;
+    lyrics?: string;
+    genre?: string;
+    mood?: string;
+    label?: string;
+    release_date?: string;
+    album_art_url?: string;
+    spotify_track_uri?: string;
+    youtube_video_id?: string;
+    youtube_view_count?: number;
+    spotify_popularity?: number;
+    spotify_streams?: number;
+    prs_registered?: boolean;
+    ppl_registered?: boolean;
+    published?: boolean;
+    is_featured?: boolean;
+    mlc_song_code?: string;
+    completeness_score?: number | null;
+    ai_disclosure?: Record<string, unknown>;
+    provenance_attestation?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface Person {
+    id: string;
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    biography?: string;
+    isni?: string;
+    musicbrainz_id?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface Recording {
+    id: string;
+    title?: string;
+    isrc?: string;
+    duration_seconds?: number;
+    work_id?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface WorkCredit {
+    person_id: string;
+    role: string;
+    splits: number;
+    person_name?: string;
+    ipi?: string;
+    verified?: boolean;
+    split_status?: string;
+    is_owner?: boolean;
+}
+interface WorkCreditsInput {
+    credits: Array<{
+        person_id: string;
+        role: string;
+        splits: number;
+    }>;
+}
+interface PicaScorePillar {
+    name: string;
+    slug: "income" | "ownership" | "asset" | "verification";
+    score: number;
+    weight: number;
+    status: "strong" | "developing" | "weak";
+    suggestions: string[];
+    details: Record<string, unknown>;
+}
+interface PicaScore {
+    composite: number;
+    grade: "A" | "B" | "C" | "D" | "F";
+    pillars: PicaScorePillar[];
+    topActions: string[];
+    calculatedAt: string;
+}
+interface AudioFile {
+    id: string;
+    work_id: string | null;
+    title: string;
+    filename: string;
+    file_type: "master" | "instrumental" | "stem" | "demo" | "version";
+    file_size: number;
+    audio_format: string;
+    cdn_url?: string;
+    duration_seconds: number | null;
+    detected_bpm: number | null;
+    detected_key: string | null;
+    detected_energy: number | null;
+    detected_valence: number | null;
+    detected_mood: string[] | null;
+    metadata_extracted: boolean;
+    extraction_error: string | null;
+    published: boolean;
+    classification?: string;
+    notes?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface AudioAnalysisStatus {
+    status: "processing" | "completed" | "failed" | "not_started";
+    detected_bpm?: number | null;
+    detected_key?: string | null;
+    duration_seconds?: number | null;
+    error?: string | null;
+}
+interface MultimediaItem {
+    id: string;
+    organisation_id: string;
+    user_id?: string;
+    content_type: string;
+    classification?: string;
+    title: string;
+    caption?: string;
+    description?: string;
+    tags?: string[];
+    url?: string;
+    thumbnail_url?: string;
+    file_name?: string;
+    file_size?: number;
+    mime_type?: string;
+    duration_seconds?: number;
+    youtube_video_id?: string;
+    youtube_url?: string;
+    spotify_track_id?: string;
+    spotify_track_uri?: string;
+    soundcloud_url?: string;
+    is_published?: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface Agreement {
+    id: string;
+    organisation_id: string;
+    title: string;
+    agreement_type: string;
+    status: string;
+    other_party_name: string;
+    other_party_type?: string;
+    signing_date?: string;
+    start_date?: string;
+    end_date?: string;
+    description?: string;
+    notes?: string;
+    tags?: string[];
+    financial_terms?: Record<string, unknown>;
+    agreement_terms?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface AgreementWorkLink {
+    id: string;
+    agreement_id: string;
+    work_id: string;
+    royalty_split_percentage?: number;
+    notes?: string;
+}
+interface SyncSearchParams {
+    mood?: string;
+    genre?: string;
+    min_bpm?: number;
+    max_bpm?: number;
+    key?: string;
+    min_energy?: number;
+    max_energy?: number;
+    min_valence?: number;
+    max_valence?: number;
+    min_duration?: number;
+    max_duration?: number;
+    instrumental_only?: boolean;
+    available_for_sync?: boolean;
+    limit?: number;
+}
+interface SyncTrack {
+    id: string;
+    title: string;
+    filename: string;
+    duration_seconds: number | null;
+    detected_bpm: number | null;
+    detected_key: string | null;
+    detected_energy: number | null;
+    detected_mood: string[] | null;
+    work_id: string | null;
+    work?: {
+        id: string;
+        title: string;
+        primary_artist: string | null;
+    };
+    cdn_url: string | null;
+    published: boolean;
+}
+interface SyncSearchResult {
+    tracks: SyncTrack[];
+    count: number;
+    filters: Record<string, unknown>;
+}
+interface LicenseEnquiryInput {
+    work_id: string;
+    track_title: string;
+    contact_name: string;
+    contact_email: string;
+    company_name?: string;
+    project_type: "tv_ad" | "film" | "social_media" | "game" | "podcast" | "corporate" | "other";
+    project_description: string;
+    territory: string;
+    duration: string;
+    distribution?: string[];
+    proposed_budget_amount: number;
+    proposed_budget_currency: string;
+    budget_notes?: string;
+}
+interface LicenseEnquiry {
+    id: string;
+    organisation_id: string;
+    work_id: string;
+    track_title: string;
+    contact_name: string;
+    contact_email: string;
+    company_name: string | null;
+    project_type: string;
+    project_description: string;
+    territory: string;
+    duration: string;
+    distribution: string[] | null;
+    proposed_budget_amount: number;
+    proposed_budget_currency: string;
+    budget_notes: string | null;
+    status: string;
+    your_counter_offer: number | null;
+    your_notes: string | null;
+    invoice_id: string | null;
+    agreement_id: string | null;
+    responded_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+declare class ApiError extends Error {
+    status: number;
+    retryable: boolean;
+    retryAfterMs?: number | undefined;
+    constructor(message: string, status: number, retryable: boolean, retryAfterMs?: number | undefined);
+}
+declare class BaseResource {
+    protected baseUrl: string;
+    protected apiKey: string;
+    protected debug: boolean;
+    constructor(baseUrl: string, apiKey: string, debug: boolean);
+    private fetchWithTimeout;
+    private fetchWithRetry;
+    protected request<T>(method: string, path: string, body?: any): Promise<T>;
+    /**
+     * Make a request and return paginated result with metadata
+     */
+    protected requestPaginated<T>(method: string, path: string, body?: unknown): Promise<PaginatedResult<T>>;
+}
+export { ApiError };
+declare class WorksResource extends BaseResource {
+    list(params?: {
+        limit?: number;
+    }): Promise<Work[]>;
+    search(params: {
+        query?: string;
+        limit?: number;
+        offset?: number;
+        status?: string;
+        type?: string;
+    }): Promise<PaginatedResult<Work>>;
+    get(id: string): Promise<Work>;
+    create(data: Partial<Work>): Promise<Work>;
+    update(id: string, updates: Partial<Work>): Promise<Work>;
+    delete(id: string): Promise<void>;
+    verify(id: string): Promise<Work>;
+    bulkDelete(ids: string[]): Promise<void>;
+}
+declare class PeopleResource extends BaseResource {
+    list(params?: {
+        limit?: number;
+    }): Promise<Person[]>;
+    search(params: {
+        query?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<PaginatedResult<Person>>;
+    get(id: string): Promise<Person>;
+    create(data: Partial<Person>): Promise<Person>;
+    update(id: string, updates: Partial<Person>): Promise<Person>;
+    delete(id: string): Promise<void>;
+    enrichFromISNI(id: string, isni: string): Promise<Person>;
+    enrichFromMusicBrainz(id: string, musicbrainz_id: string): Promise<Person>;
+}
+declare class LicensingResource extends BaseResource {
+    /**
+     * Search for sync-licensable tracks by audio characteristics
+     */
+    searchForSync(params?: SyncSearchParams): Promise<SyncSearchResult>;
+    /**
+     * Submit a license enquiry for a track
+     */
+    submitEnquiry(enquiry: LicenseEnquiryInput): Promise<LicenseEnquiry>;
+    /**
+     * List license enquiries with optional filters
+     */
+    listEnquiries(params?: {
+        work_id?: string;
+        status?: string;
+        project_type?: string;
+        territory?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<LicenseEnquiry[]>;
+    /**
+     * Get a specific license enquiry by ID
+     */
+    getEnquiry(id: string): Promise<LicenseEnquiry>;
+    /**
+     * Update a license enquiry status
+     */
+    updateEnquiryStatus(id: string, status: string, notes?: string): Promise<LicenseEnquiry>;
+}
+declare class CreditsResource extends BaseResource {
+    listForWork(workId: string): Promise<WorkCredit[]>;
+    updateForWork(workId: string, credits: WorkCreditsInput): Promise<WorkCredit[]>;
+}
+declare class CreditsBalanceResource extends BaseResource {
+    getBalance(): Promise<any>;
+    purchase(params: {
+        package_id: string;
+        currency?: string;
+    }): Promise<any>;
+}
+declare class PicaScoreResource extends BaseResource {
+    get(): Promise<PicaScore>;
+}
+interface PresignedUploadResult {
+    uploadUrl: string;
+    uploadId: string;
+    key: string;
+    bucket: string;
+    expiresAt?: string;
+    metadata: Record<string, unknown>;
+}
+interface CompleteUploadResult {
+    uploadId: string;
+    audioFileId: string;
+    s3Key: string;
+    s3Bucket: string;
+    fileName: string;
+    fileSize: number;
+    status: string;
+    message: string;
+}
+interface IdentifyResult {
+    status?: "matched" | "no_match" | "failed";
+    alreadyIdentified?: boolean;
+    audioFileId?: string;
+    message?: string;
+    match?: {
+        title?: string;
+        artist?: string;
+        album?: string;
+        isrc?: string;
+        label?: string;
+        release_date?: string;
+        confidence: number;
+    };
+}
+declare class AudioFilesResource extends BaseResource {
+    list(params?: {
+        work_id?: string;
+        file_type?: string;
+        unprocessed?: boolean;
+        limit?: number;
+    }): Promise<AudioFile[]>;
+    get(id: string): Promise<AudioFile>;
+    analyze(id: string, options?: {
+        forceReAnalyze?: boolean;
+        enableAudio?: boolean;
+        enableLyrics?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        features?: Record<string, unknown>;
+    }>;
+    getStatus(id: string): Promise<AudioAnalysisStatus>;
+    presignedUpload(params: {
+        filename: string;
+        contentType: string;
+        fileSize: number;
+        workId?: string;
+        title?: string;
+        fileType?: string;
+    }): Promise<PresignedUploadResult>;
+    completeUpload(params: {
+        uploadId: string;
+        key: string;
+        bucket: string;
+        metadata: {
+            filename: string;
+            contentType: string;
+            fileSize: number;
+            workId?: string;
+            title?: string;
+            fileType?: string;
+            stemLabel?: string;
+            versionLabel?: string;
+            recordingId?: string;
+            classification?: string;
+        };
+    }): Promise<CompleteUploadResult>;
+    identify(id: string, options?: {
+        force?: boolean;
+    }): Promise<IdentifyResult>;
+}
+declare class MultimediaResource extends BaseResource {
+    search(params?: {
+        query?: string;
+        content_type?: string;
+        classification?: string;
+        is_published?: boolean;
+        work_id?: string;
+        person_id?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        data: MultimediaItem[];
+        count: number;
+    }>;
+    create(data: Partial<MultimediaItem>): Promise<MultimediaItem>;
+    importFromUrl(params: {
+        url: string;
+        title?: string;
+        source?: string;
+        work_id?: string;
+    }): Promise<MultimediaItem>;
+    linkYoutube(params: {
+        youtube_video_id: string;
+        title: string;
+        classification?: string;
+        work_id?: string;
+        work_relationship_type?: string;
+    }): Promise<MultimediaItem>;
+    linkWork(id: string, workId: string, relationshipType: string, notes?: string): Promise<Record<string, unknown>>;
+}
+declare class AgreementsResource extends BaseResource {
+    list(params?: {
+        query?: string;
+        agreement_type?: string;
+        status?: string;
+        party_name?: string;
+        includeWorkCounts?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<Agreement[]>;
+    get(id: string): Promise<{
+        agreement: Agreement;
+        signatureStatus: unknown;
+        linkedWorks: unknown[];
+    }>;
+    create(data: Partial<Agreement>): Promise<Agreement>;
+    update(id: string, updates: Partial<Agreement>): Promise<Agreement>;
+    delete(id: string): Promise<void>;
+    getWorks(id: string): Promise<AgreementWorkLink[]>;
+    linkWork(id: string, data: {
+        work_id: string;
+        royalty_split_percentage?: number;
+        notes?: string;
+    }): Promise<AgreementWorkLink>;
+}
+declare class WorkspaceResource extends BaseResource {
+    getContext(): Promise<{
+        organisation: {
+            name: string;
+            plan: string | null;
+        };
+        catalog: Record<string, unknown>;
+        health: Record<string, unknown> | null;
+        priorities: string[];
+    }>;
+    getRecentEvents(limit?: number): Promise<{
+        events: Array<{
+            id: string;
+            event: string;
+            status: string;
+            timestamp: string;
+        }>;
+    }>;
+}
+declare class MemoryResource extends BaseResource {
+    list(): Promise<any[]>;
+    search(query: string): Promise<any[]>;
+    save(params: {
+        key: string;
+        content: string;
+        scope?: string;
+        type?: string;
+    }): Promise<any>;
+    delete(id: string): Promise<void>;
+}
+declare class NotesResource extends BaseResource {
+    list(params?: {
+        q?: string;
+        work?: string;
+        person?: string;
+        limit?: number;
+    }): Promise<any[]>;
+    get(id: string): Promise<any>;
+    create(content: string, metadata?: {
+        work_ids?: string[];
+        people_ids?: string[];
+    }): Promise<any>;
+    delete(id: string): Promise<void>;
+}
+declare class TeamResource extends BaseResource {
+    list(): Promise<any>;
+    get(id: string): Promise<any>;
+    invite(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    remove(id: string): Promise<any>;
+}
+declare class RecordingsResource extends BaseResource {
+    list(params?: {
+        limit?: number;
+    }): Promise<Recording[]>;
+    /**
+     * Search recordings. The recordings API doesn't support text search,
+     * so we fetch all and filter client-side for text queries.
+     */
+    search(params: {
+        query?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<PaginatedResult<Recording>>;
+    get(id: string): Promise<Recording>;
+    create(data: Partial<Recording>): Promise<Recording>;
+    update(id: string, updates: Partial<Recording>): Promise<Recording>;
+    delete(id: string): Promise<void>;
+    getByWork(workId: string): Promise<Recording[]>;
+    prefixLookup(isrc: string): Promise<Record<string, unknown> | null>;
+}
+declare class EnrichmentResource extends BaseResource {
+    enrichWork(workId: string): Promise<any>;
+    enrichPerson(personId: string): Promise<any>;
+    getWorkEnrichmentStatus(workId: string): Promise<any>;
+    getCandidates(): Promise<any>;
+    enrichWorkMlc(workId: string): Promise<any>;
+    enrichWorkMusicBrainz(workId: string): Promise<any>;
+    enrichWorkDiscogs(workId: string): Promise<any>;
+    enrichWorkSpotify(workId: string): Promise<any>;
+    enrichWorkYouTube(workId: string): Promise<any>;
+}
+declare class RegistrationResource extends BaseResource {
+    getCoverage(): Promise<any>;
+    getWorkCascadeStatus(workId: string): Promise<any>;
+}
+declare class HealthResource extends BaseResource {
+    getWorksHealth(): Promise<any>;
+    getLowScoreWorks(): Promise<any>;
+    getWorkCompleteness(workId: string): Promise<any>;
+}
+declare class DashboardResource extends BaseResource {
+    discoveries(params?: {
+        unread?: boolean;
+        limit?: number;
+    }): Promise<any>;
+    pendingDiscoveries(): Promise<any>;
+    reviewDiscovery(discoveryId: string, status: string): Promise<any>;
+    attentionItems(params?: {
+        door?: string;
+        limit?: number;
+    }): Promise<any>;
+    briefing(): Promise<any>;
+    pulse(): Promise<any>;
+}
+declare class IntegrationsResource extends BaseResource {
+    oauthConnections(): Promise<any>;
+    platforms(): Promise<any>;
+}
+declare class SettingsResource extends BaseResource {
+    creditsHistory(params?: {
+        type?: string;
+        limit?: number;
+    }): Promise<any>;
+    storageConfig(): Promise<any>;
+    orgProfile(): Promise<any>;
+    userProfile(): Promise<any>;
+}
+declare class CalendarResource extends BaseResource {
+    getEvents(params: {
+        startDate: string;
+        endDate: string;
+        types?: string[];
+        workId?: string;
+        search?: string;
+    }): Promise<any>;
+}
+declare class NotificationsResource extends BaseResource {
+    list(): Promise<any>;
+    markRead(ids: string[]): Promise<any>;
+    sendToPerson(params: {
+        person_id: string;
+        message: string;
+        work_id?: string;
+        notification_type?: string;
+    }): Promise<any>;
+}
+declare class AnalyticsResource extends BaseResource {
+    carbonSummary(): Promise<any>;
+    carbonLive(): Promise<any>;
+    provenanceStats(): Promise<any>;
+    provenanceWork(workId: string): Promise<any>;
+    provenanceCertificate(workId: string): Promise<any>;
+    catalogDiligence(): Promise<any>;
+}
+declare class BulkResource extends BaseResource {
+    updateWorks(workIds: string[], updates: Record<string, any>): Promise<any>;
+    updatePeopleRoles(personIds: string[], roles: string[]): Promise<any>;
+}
+declare class ExportResource extends BaseResource {
+    catalogCsv(params?: {
+        format?: string;
+    }): Promise<any>;
+    songRegistration(): Promise<any>;
+    industryReady(): Promise<any>;
+    catalogAssetReport(params: {
+        sections: {
+            ownership: true;
+            valuation?: boolean;
+            assets?: boolean;
+            agreements?: boolean;
+            intelligence?: boolean;
+            audio?: boolean;
+        };
+        attestation: {
+            signer_name: string;
+            declaration_accepted: boolean;
+        };
+    }): Promise<any>;
+    aiConsent(): Promise<any>;
+}
+declare class DuplicatesResource extends BaseResource {
+    findDuplicates(entityType: "works" | "people"): Promise<any>;
+    merge(entityType: "work" | "person", winnerId: string, loserIds: string[]): Promise<any>;
+}
+declare class EntityContextResource extends BaseResource {
+    getWorkFull(workId: string): Promise<Record<string, unknown>>;
+    getPersonFull(personId: string): Promise<Record<string, unknown>>;
+}
+declare class ComparisonsResource extends BaseResource {
+    enrichmentCompare(params: {
+        entityType: "work" | "person";
+        entityId: string;
+    }): Promise<Record<string, unknown>>;
+    registrationsCompare(workId: string): Promise<Record<string, unknown>>;
+}
+declare class SendResource extends BaseResource {
+    send(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    list(params?: {
+        type?: string;
+        status?: string;
+        personId?: string;
+        workId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        items: Array<Record<string, unknown>>;
+        total: number;
+    }>;
+    listPending(): Promise<Array<Record<string, unknown>>>;
+    resend(id: string): Promise<Record<string, unknown>>;
+}
+declare class AssetsResource extends BaseResource {
+    list(params?: {
+        category?: string;
+        limit?: number;
+    }): Promise<any>;
+    get(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<any>;
+    stats(): Promise<any>;
+    valuations(id: string): Promise<any>;
+    exportAll(): Promise<any>;
+    marketCheck(id: string): Promise<any>;
+}
+interface GenericPresignedResult {
+    uploadUrl: string;
+    uploadId: string;
+    key: string;
+    bucket: string;
+    storageCategory: "audio" | "media" | "documents";
+    expiresAt?: string;
+    metadata: Record<string, unknown>;
+}
+interface GenericCompleteResult {
+    uploadId: string;
+    recordId: string;
+    recordType: string;
+    key: string;
+    bucket: string;
+    storageCategory: string;
+}
+declare class StorageResource extends BaseResource {
+    presignedUpload(params: {
+        filename: string;
+        contentType: string;
+        fileSize: number;
+        storageCategory?: "audio" | "media" | "documents";
+    }): Promise<GenericPresignedResult>;
+    completeUpload(params: {
+        uploadId: string;
+        key: string;
+        bucket: string;
+        metadata: {
+            filename: string;
+            contentType: string;
+            fileSize: number;
+            storageCategory: "audio" | "media" | "documents";
+            title?: string;
+            workId?: string;
+            classification?: string;
+            collectionId?: string;
+            documentCategory?: string;
+            documentTitle?: string;
+            linkedToType?: string;
+            linkedToId?: string;
+        };
+    }): Promise<GenericCompleteResult>;
+}
+type ImportDomain = "works" | "people" | "recordings" | "documents" | "enquiries" | "royalties";
+interface ImportAnalysis {
+    parsed: {
+        headers: string[];
+        rows: Record<string, string>[];
+        totalRows: number;
+    };
+    analysis: {
+        mappings: Record<string, {
+            targetField: string;
+            transform?: string;
+            aiConfidence?: number;
+            required?: boolean;
+        }>;
+        suggestions: string[];
+    };
+}
+interface ImportValidation {
+    valid: boolean;
+    errors: Array<{
+        row: number;
+        field: string;
+        message: string;
+        severity: "error" | "warning";
+    }>;
+    validRowCount: number;
+    invalidRowCount: number;
+    totalRowCount: number;
+    errorsByType: Record<string, number>;
+}
+interface ImportResult {
+    importedCount: number;
+    updatedCount: number;
+    skippedCount: number;
+    createdRecords: Array<{
+        id: string;
+        title?: string;
+    }>;
+    errors: Array<{
+        row: number;
+        field: string;
+        message: string;
+        severity: string;
+    }>;
+    summary: string;
+    dryRun: boolean;
+}
+declare class ImportResource extends BaseResource {
+    analyze(params: {
+        fileContent: string;
+        domain: ImportDomain;
+    }): Promise<ImportAnalysis>;
+    suggestMapping(params: {
+        domain: ImportDomain;
+        headers: string[];
+        sampleRows: Record<string, string>[];
+    }): Promise<{
+        mappings: Array<{
+            csvColumn: string;
+            targetField: string;
+            transformType: string;
+            confidence: number;
+            required: boolean;
+        }>;
+        unmappedCsvColumns: string[];
+        missingRequiredFields: string[];
+        aiSuggestions: string[];
+    }>;
+    validate(params: {
+        domain: ImportDomain;
+        fileContent: string;
+        mapping: Array<{
+            csvColumn: string;
+            targetField: string;
+            transformType?: string;
+        }>;
+    }): Promise<ImportValidation>;
+    execute(params: {
+        domain: ImportDomain;
+        fileContent: string;
+        mapping: Array<{
+            csvColumn: string;
+            targetField: string;
+            transformType?: string;
+        }>;
+        options: {
+            dryRun?: boolean;
+            skipInvalidRows?: boolean;
+            batchSize?: number;
+        };
+    }): Promise<ImportResult>;
+    getFields(domain: ImportDomain): Promise<Array<{
+        name: string;
+        label: string;
+        description?: string;
+        required: boolean;
+        type: string;
+    }>>;
+    streamingLinkPreview(url: string): Promise<{
+        tracks: Array<{
+            title: string;
+            artists: Array<{
+                name: string;
+            }>;
+            album?: string;
+            isrc?: string;
+            platform: string;
+            externalId: string;
+            externalUrl: string;
+        }>;
+        duplicates: Array<{
+            track: {
+                title: string;
+                externalId: string;
+            };
+            existingWorkId: string;
+            existingTitle: string;
+            matchType: string;
+        }>;
+        newTracks: Array<{
+            title: string;
+            artists: Array<{
+                name: string;
+            }>;
+            isrc?: string;
+            externalId: string;
+        }>;
+        source: {
+            platform: string;
+            type: string;
+            name?: string;
+            url: string;
+        };
+    }>;
+    streamingLinkImport(url: string, selectedTrackIds?: string[]): Promise<{
+        worksCreated: number;
+        recordingsCreated: number;
+        peopleCreated: number;
+        creditsCreated: number;
+        multimediaLinked: number;
+        duplicatesSkipped: number;
+        workIds: string[];
+    }>;
+    getTemplate(domain: ImportDomain): Promise<string>;
+}
+declare class DocumentsResource extends BaseResource {
+    analyse(id: string): Promise<Record<string, unknown>>;
+}
+interface CollaboratorInvite {
+    id: string;
+    work_id: string;
+    person_id?: string;
+    email: string;
+    name: string;
+    status: "pending" | "accepted" | "expired";
+    token?: string;
+    created_at: string;
+    updated_at: string;
+}
+declare class CollaboratorsResource extends BaseResource {
+    invite(params: {
+        workId: string;
+        personData: {
+            name: string;
+            email: string;
+            role?: string;
+        };
+        invitedBy: string;
+        creditData: {
+            credit_type: string;
+            percentage_split?: number;
+            role_description?: string;
+        };
+    }): Promise<Record<string, unknown>>;
+    listInvites(params?: {
+        status?: "pending" | "accepted" | "expired";
+        workId?: string;
+        limit?: number;
+    }): Promise<CollaboratorInvite[]>;
+    resendInvite(inviteId: string): Promise<Record<string, unknown>>;
+}
+interface DirectorySettings {
+    organisation_id: string;
+    opted_in: boolean;
+    show_splits: boolean;
+    show_publishers: boolean;
+    show_agreements: boolean;
+    show_audio_preview: boolean;
+    show_stems: boolean;
+    contact_enabled: boolean;
+}
+declare class DirectoryResource extends BaseResource {
+    getSettings(): Promise<{
+        settings: DirectorySettings;
+        eligible_work_count: number;
+    }>;
+    updateSettings(updates: Partial<DirectorySettings>): Promise<DirectorySettings>;
+}
+declare class ProjectsResource extends BaseResource {
+    list(params?: {
+        limit?: number;
+    }): Promise<any>;
+    get(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<any>;
+}
+declare class SplitSheetsResource extends BaseResource {
+    listForWork(workId: string): Promise<any>;
+    generate(workId: string): Promise<any>;
+    get(workId: string, splitSheetId: string): Promise<any>;
+}
+declare class RecordingSplitsResource extends BaseResource {
+    list(recordingId: string): Promise<any>;
+    create(recordingId: string, data: Record<string, any>): Promise<any>;
+    update(recordingId: string, splitId: string, data: Record<string, any>): Promise<any>;
+    delete(recordingId: string, splitId: string): Promise<any>;
+    verify(recordingId: string, splitId: string): Promise<any>;
+}
+declare class ReleasesResource extends BaseResource {
+    list(params?: {
+        limit?: number;
+    }): Promise<any>;
+    get(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<any>;
+}
+declare class SessionsResource extends BaseResource {
+    list(params?: {
+        limit?: number;
+    }): Promise<any>;
+    get(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    getTypes(): Promise<any>;
+}
+declare class AgreementTemplatesResource extends BaseResource {
+    list(): Promise<any[]>;
+    get(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<void>;
+    render(id: string, data: Record<string, any>): Promise<any>;
+    duplicate(id: string): Promise<any>;
+    setDefault(id: string): Promise<any>;
+}
+declare class ProducerAgreementsResource extends BaseResource {
+    list(): Promise<any[]>;
+    get(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<void>;
+}
+declare class WorkForHireResource extends BaseResource {
+    list(): Promise<any[]>;
+    get(id: string): Promise<any>;
+    create(data: Record<string, any>): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<void>;
+}
+declare class RoyaltiesResource extends BaseResource {
+    payments(params?: {
+        source?: string;
+        workId?: string;
+        fromDate?: string;
+        toDate?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    earnings(params?: {
+        start_date?: string;
+        end_date?: string;
+        source?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<any>;
+    gaps(params?: {
+        priority?: string;
+        gapType?: string;
+        workId?: string;
+        limit?: number;
+    }): Promise<any[]>;
+    stats(): Promise<any>;
+}
+declare class StatementsResource extends BaseResource {
+    history(params?: {
+        source?: string;
+        dateFrom?: string;
+        dateTo?: string;
+        search?: string;
+        limit?: number;
+        offset?: number;
+        sort?: string;
+    }): Promise<any>;
+    get(batchId: string): Promise<any>;
+}
+declare class ShareLinksResource extends BaseResource {
+    list(params?: {
+        work_id?: string;
+    }): Promise<any[]>;
+    create(data: Record<string, any>): Promise<any>;
+}
+declare class DisputesResource extends BaseResource {
+    list(params?: {
+        status?: string;
+    }): Promise<any>;
+}
+declare class ChainResource extends BaseResource {
+    search(params: {
+        q: string;
+        limit?: number;
+        expand_first?: boolean;
+    }): Promise<any>;
+    getById(type: string, id: string): Promise<any>;
+    traverse(identifier: string): Promise<any>;
+}
+declare class TelegramResource extends BaseResource {
+    getStatus(): Promise<any>;
+    sendNotification(message: string): Promise<any>;
+    getPreferences(): Promise<any>;
+}
+declare class ImportDocumentsResource extends BaseResource {
+    list(options?: {
+        source?: string;
+        period?: string;
+        document_type?: string;
+        limit?: number;
+    }): Promise<any[]>;
+    get(id: string): Promise<any>;
+    ingest(content: string): Promise<any>;
+}
+export declare class PicaClient {
+    works: WorksResource;
+    people: PeopleResource;
+    recordings: RecordingsResource;
+    licensing: LicensingResource;
+    credits: CreditsResource;
+    creditsBalance: CreditsBalanceResource;
+    picaScore: PicaScoreResource;
+    audioFiles: AudioFilesResource;
+    multimedia: MultimediaResource;
+    agreements: AgreementsResource;
+    workspace: WorkspaceResource;
+    memory: MemoryResource;
+    enrichment: EnrichmentResource;
+    registration: RegistrationResource;
+    health: HealthResource;
+    bulk: BulkResource;
+    exports: ExportResource;
+    duplicates: DuplicatesResource;
+    collaborators: CollaboratorsResource;
+    entityContext: EntityContextResource;
+    comparisons: ComparisonsResource;
+    send: SendResource;
+    imports: ImportResource;
+    storage: StorageResource;
+    documents: DocumentsResource;
+    analytics: AnalyticsResource;
+    notifications: NotificationsResource;
+    calendar: CalendarResource;
+    dashboard: DashboardResource;
+    integrations: IntegrationsResource;
+    settings: SettingsResource;
+    directory: DirectoryResource;
+    importDocuments: ImportDocumentsResource;
+    sessions: SessionsResource;
+    assets: AssetsResource;
+    notes: NotesResource;
+    team: TeamResource;
+    projects: ProjectsResource;
+    releases: ReleasesResource;
+    splitSheets: SplitSheetsResource;
+    recordingSplits: RecordingSplitsResource;
+    agreementTemplates: AgreementTemplatesResource;
+    producerAgreements: ProducerAgreementsResource;
+    workForHire: WorkForHireResource;
+    royalties: RoyaltiesResource;
+    statements: StatementsResource;
+    shareLinks: ShareLinksResource;
+    disputes: DisputesResource;
+    chain: ChainResource;
+    telegram: TelegramResource;
+    /**
+     * Get accurate catalog stats via SQL counts (no pagination limits)
+     */
+    catalogStats(): Promise<CatalogStats>;
+    constructor(config: PicaClientConfig);
+}
+export type { Work, Person, Recording, PaginatedResult, PicaClientConfig, SyncSearchParams, SyncTrack, SyncSearchResult, LicenseEnquiryInput, LicenseEnquiry, WorkCredit, WorkCreditsInput, PicaScore, PicaScorePillar, AudioFile, AudioAnalysisStatus, PresignedUploadResult, CompleteUploadResult, IdentifyResult, MultimediaItem, Agreement, AgreementWorkLink, };
+//# sourceMappingURL=pica-sdk.d.ts.map