@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/cli/dist/src/transfer/export.js

@@ -0,0 +1,113 @@
+/**
+ * Pattern Export Pipeline
+ * Export patterns with anonymization and optional IPFS upload
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { serializeToJson, serializeToBuffer, getFileExtension } from './serialization/cfp.js';
+import { anonymizeCFP, scanCFPForPII } from './anonymization/index.js';
+import { uploadToIPFS } from './ipfs/upload.js';
+/**
+ * Export patterns to file or IPFS
+ */
+export async function exportPatterns(cfp, options = {}) {
+    const { output, format = 'json', anonymize = 'standard', redactPii = true, stripPaths = false, toIpfs = false, pin = true, gateway = 'https://w3s.link', } = options;
+    // Step 1: Scan for PII
+    const piiScan = scanCFPForPII(cfp);
+    if (piiScan.found && redactPii) {
+        console.log(`Found ${piiScan.count} PII items, will be redacted`);
+    }
+    // Step 2: Apply anonymization
+    const { cfp: anonymizedCfp, transforms } = anonymizeCFP(cfp, anonymize);
+    console.log(`Applied ${transforms.length} anonymization transforms: ${transforms.join(', ')}`);
+    // Step 3: Serialize
+    const serialized = format === 'json'
+        ? serializeToJson(anonymizedCfp)
+        : serializeToBuffer(anonymizedCfp, format);
+    const size = typeof serialized === 'string' ? Buffer.byteLength(serialized) : serialized.length;
+    // Step 4: Output
+    let outputPath;
+    let cid;
+    if (toIpfs) {
+        // Upload to IPFS
+        const ipfsResult = await uploadToIPFS(Buffer.isBuffer(serialized) ? serialized : Buffer.from(serialized), {
+            pin,
+            gateway,
+            name: anonymizedCfp.metadata.name || 'patterns',
+        });
+        cid = ipfsResult.cid;
+        anonymizedCfp.ipfs = {
+            cid: ipfsResult.cid,
+            pinnedAt: ipfsResult.pinnedAt ? [ipfsResult.pinnedAt] : [],
+            gateway: ipfsResult.gateway,
+            size: ipfsResult.size,
+        };
+        console.log(`Uploaded to IPFS: ${cid}`);
+        console.log(`Gateway URL: ${gateway}/ipfs/${cid}`);
+    }
+    if (output) {
+        // Write to file
+        const ext = getFileExtension(format);
+        outputPath = output.endsWith(ext) ? output : output + ext;
+        // Ensure directory exists
+        const dir = path.dirname(outputPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Write file
+        if (typeof serialized === 'string') {
+            fs.writeFileSync(outputPath, serialized, 'utf-8');
+        }
+        else {
+            fs.writeFileSync(outputPath, serialized);
+        }
+        console.log(`Exported to: ${outputPath}`);
+    }
+    // Calculate pattern count
+    const patternCount = (cfp.patterns.routing?.length || 0) +
+        (cfp.patterns.complexity?.length || 0) +
+        (cfp.patterns.coverage?.length || 0) +
+        (cfp.patterns.trajectory?.length || 0) +
+        (cfp.patterns.custom?.length || 0);
+    return {
+        success: true,
+        outputPath,
+        cid,
+        gateway: cid ? gateway : undefined,
+        size,
+        patternCount,
+        anonymizationLevel: anonymize,
+    };
+}
+/**
+ * Export Seraphine genesis model
+ */
+export async function exportSeraphine(options = {}) {
+    // Dynamically import to avoid circular dependency
+    const { createSeraphineGenesis } = await import('./models/seraphine.js');
+    const genesis = createSeraphineGenesis();
+    return exportPatterns(genesis, options);
+}
+/**
+ * Quick export to file
+ */
+export async function quickExport(cfp, outputPath) {
+    return exportPatterns(cfp, {
+        output: outputPath,
+        format: 'json',
+        anonymize: 'standard',
+    });
+}
+/**
+ * Quick export to IPFS
+ */
+export async function quickExportToIPFS(cfp, options = {}) {
+    return exportPatterns(cfp, {
+        toIpfs: true,
+        pin: options.pin ?? true,
+        gateway: options.gateway ?? 'https://w3s.link',
+        format: 'json',
+        anonymize: 'strict',
+    });
+}
+//# sourceMappingURL=export.js.map

package/v3/@claude-flow/cli/dist/src/transfer/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Transfer Module
+ * Pattern export, import, anonymization, and IPFS sharing
+ */
+export * from './types.js';
+export { createCFP, serializeToJson, serializeToBuffer, deserializeCFP, validateCFP, getFileExtension, detectFormat, } from './serialization/cfp.js';
+export { detectPII, redactPII, anonymizeCFP, scanCFPForPII, } from './anonymization/index.js';
+export { exportPatterns, exportSeraphine, quickExport, quickExportToIPFS, } from './export.js';
+export { uploadToIPFS, pinContent, unpinContent, checkContent, getGatewayURL, getIPNSURL, } from './ipfs/upload.js';
+export { SERAPHINE_VERSION, SERAPHINE_METADATA, SERAPHINE_ROUTING_PATTERNS, SERAPHINE_COMPLEXITY_PATTERNS, SERAPHINE_COVERAGE_PATTERNS, SERAPHINE_TRAJECTORY_PATTERNS, SERAPHINE_CUSTOM_PATTERNS, createSeraphinePatterns, createSeraphineGenesis, getSeraphineInfo, } from './models/seraphine.js';
+export { type PatternEntry, type PatternAuthor, type PatternCategory, type PatternRegistry, type SearchOptions, type SearchResult, type PublishOptions, type PublishResult, type DownloadOptions, type DownloadResult, type KnownRegistry, type StoreConfig, type DiscoveryResult, type IPNSResolution, type DownloadProgressCallback, type ContributionRequest, REGISTRY_VERSION, BOOTSTRAP_REGISTRIES, DEFAULT_STORE_CONFIG, createRegistry, getDefaultCategories, addPatternToRegistry, removePatternFromRegistry, serializeRegistry, deserializeRegistry, signRegistry, verifyRegistrySignature, mergeRegistries, generatePatternId, PatternDiscovery, createDiscoveryService, searchPatterns, getFeaturedPatterns, getTrendingPatterns, getNewestPatterns, getPatternById, getPatternByName, getPatternsByAuthor, getPatternsByCategory, getSimilarPatterns, getCategoryStats, getTagCloud, getSearchSuggestions, PatternDownloader, batchDownload, createDownloader, PatternPublisher, submitContribution, checkContributionStatus, createPublisher, quickPublish, PatternStore, createPatternStore, } from './store/index.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/cli/dist/src/transfer/index.js

@@ -0,0 +1,31 @@
+/**
+ * Transfer Module
+ * Pattern export, import, anonymization, and IPFS sharing
+ */
+// Types
+export * from './types.js';
+// Serialization
+export { createCFP, serializeToJson, serializeToBuffer, deserializeCFP, validateCFP, getFileExtension, detectFormat, } from './serialization/cfp.js';
+// Anonymization
+export { detectPII, redactPII, anonymizeCFP, scanCFPForPII, } from './anonymization/index.js';
+// Export
+export { exportPatterns, exportSeraphine, quickExport, quickExportToIPFS, } from './export.js';
+// IPFS
+export { uploadToIPFS, pinContent, unpinContent, checkContent, getGatewayURL, getIPNSURL, } from './ipfs/upload.js';
+// Models
+export { SERAPHINE_VERSION, SERAPHINE_METADATA, SERAPHINE_ROUTING_PATTERNS, SERAPHINE_COMPLEXITY_PATTERNS, SERAPHINE_COVERAGE_PATTERNS, SERAPHINE_TRAJECTORY_PATTERNS, SERAPHINE_CUSTOM_PATTERNS, createSeraphinePatterns, createSeraphineGenesis, getSeraphineInfo, } from './models/seraphine.js';
+// Store - Decentralized Pattern Marketplace
+export { 
+// Registry
+REGISTRY_VERSION, BOOTSTRAP_REGISTRIES, DEFAULT_STORE_CONFIG, createRegistry, getDefaultCategories, addPatternToRegistry, removePatternFromRegistry, serializeRegistry, deserializeRegistry, signRegistry, verifyRegistrySignature, mergeRegistries, generatePatternId, 
+// Discovery
+PatternDiscovery, createDiscoveryService, 
+// Search
+searchPatterns, getFeaturedPatterns, getTrendingPatterns, getNewestPatterns, getPatternById, getPatternByName, getPatternsByAuthor, getPatternsByCategory, getSimilarPatterns, getCategoryStats, getTagCloud, getSearchSuggestions, 
+// Download
+PatternDownloader, batchDownload, createDownloader, 
+// Publish
+PatternPublisher, submitContribution, checkContributionStatus, createPublisher, quickPublish, 
+// High-level API
+PatternStore, createPatternStore, } from './store/index.js';
+//# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/transfer/ipfs/client.d.ts

@@ -0,0 +1,109 @@
+/**
+ * IPFS Client Module
+ * Low-level IPFS operations for discovery and fetching
+ *
+ * Supports multiple gateways with automatic fallback:
+ * - Pinata (recommended for pinned content)
+ * - Cloudflare IPFS
+ * - Protocol Labs ipfs.io
+ * - dweb.link (LibP2P)
+ */
+/**
+ * Available IPFS gateways in priority order
+ */
+export declare const IPFS_GATEWAYS: string[];
+/**
+ * IPNS resolvers
+ */
+export declare const IPNS_RESOLVERS: string[];
+/**
+ * Gateway configuration
+ */
+export interface GatewayConfig {
+    url: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    priority?: number;
+}
+/**
+ * Fetch result with metadata
+ */
+export interface FetchResult<T> {
+    data: T;
+    gateway: string;
+    cid: string;
+    cached: boolean;
+    latencyMs: number;
+}
+/**
+ * Resolve IPNS name to CID with fallback across multiple gateways
+ *
+ * @param ipnsName - IPNS key or DNSLink domain
+ * @param preferredGateway - Optional preferred gateway to try first
+ * @returns CID string or null if resolution fails
+ */
+export declare function resolveIPNS(ipnsName: string, preferredGateway?: string): Promise<string | null>;
+/**
+ * Fetch content from IPFS by CID with fallback across multiple gateways
+ *
+ * @param cid - Content Identifier
+ * @param preferredGateway - Optional preferred gateway to try first
+ * @returns Parsed JSON content or null if fetch fails
+ */
+export declare function fetchFromIPFS<T>(cid: string, preferredGateway?: string): Promise<T | null>;
+/**
+ * Fetch with full result metadata
+ */
+export declare function fetchFromIPFSWithMetadata<T>(cid: string, preferredGateway?: string): Promise<FetchResult<T> | null>;
+/**
+ * Check if CID is pinned/available on a gateway
+ */
+export declare function isPinned(cid: string, gateway?: string): Promise<boolean>;
+/**
+ * Check availability across multiple gateways
+ */
+export declare function checkAvailability(cid: string): Promise<{
+    available: boolean;
+    gateways: Array<{
+        url: string;
+        available: boolean;
+        latencyMs: number;
+    }>;
+}>;
+/**
+ * Get IPFS gateway URL for a CID
+ */
+export declare function getGatewayUrl(cid: string, gateway?: string): string;
+/**
+ * Get multiple gateway URLs for redundancy
+ */
+export declare function getGatewayUrls(cid: string): string[];
+/**
+ * Validate CID format (CIDv0 and CIDv1)
+ */
+export declare function isValidCID(cid: string): boolean;
+/**
+ * Validate IPNS name format
+ */
+export declare function isValidIPNS(ipnsName: string): boolean;
+/**
+ * Generate content hash for verification
+ */
+export declare function hashContent(content: Buffer | string): string;
+/**
+ * Verify Ed25519 signature (async import to avoid bundling issues)
+ */
+export declare function verifyEd25519Signature(message: string, signature: string, publicKey: string): Promise<boolean>;
+/**
+ * Parse CID to extract metadata
+ */
+export declare function parseCID(cid: string): {
+    version: 0 | 1;
+    codec: string;
+    hash: string;
+} | null;
+/**
+ * Format bytes to human readable
+ */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=client.d.ts.map

package/v3/@claude-flow/cli/dist/src/transfer/ipfs/client.js

@@ -0,0 +1,307 @@
+/**
+ * IPFS Client Module
+ * Low-level IPFS operations for discovery and fetching
+ *
+ * Supports multiple gateways with automatic fallback:
+ * - Pinata (recommended for pinned content)
+ * - Cloudflare IPFS
+ * - Protocol Labs ipfs.io
+ * - dweb.link (LibP2P)
+ */
+import * as crypto from 'crypto';
+/**
+ * Available IPFS gateways in priority order
+ */
+export const IPFS_GATEWAYS = [
+    'https://gateway.pinata.cloud',
+    'https://cloudflare-ipfs.com',
+    'https://ipfs.io',
+    'https://dweb.link',
+    'https://w3s.link', // web3.storage gateway
+];
+/**
+ * IPNS resolvers
+ */
+export const IPNS_RESOLVERS = [
+    'https://gateway.pinata.cloud',
+    'https://dweb.link',
+    'https://ipfs.io',
+];
+/**
+ * Resolve IPNS name to CID with fallback across multiple gateways
+ *
+ * @param ipnsName - IPNS key or DNSLink domain
+ * @param preferredGateway - Optional preferred gateway to try first
+ * @returns CID string or null if resolution fails
+ */
+export async function resolveIPNS(ipnsName, preferredGateway) {
+    const resolvers = preferredGateway
+        ? [preferredGateway, ...IPNS_RESOLVERS.filter(r => r !== preferredGateway)]
+        : IPNS_RESOLVERS;
+    console.log(`[IPFS] Resolving IPNS: ${ipnsName}`);
+    for (const gateway of resolvers) {
+        try {
+            const startTime = Date.now();
+            let cid = null;
+            // Method 1: DNSLink resolution for domain names
+            if (ipnsName.includes('.')) {
+                const response = await fetch(`${gateway}/api/v0/name/resolve?arg=/ipns/${ipnsName}`, {
+                    signal: AbortSignal.timeout(10000),
+                    headers: { 'Accept': 'application/json' },
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    cid = data.Path?.replace('/ipfs/', '') || null;
+                }
+            }
+            // Method 2: Direct IPNS key resolution via gateway redirect
+            if (!cid) {
+                const response = await fetch(`${gateway}/ipns/${ipnsName}`, {
+                    method: 'HEAD',
+                    signal: AbortSignal.timeout(10000),
+                    redirect: 'follow',
+                });
+                if (response.ok) {
+                    // Extract CID from the final URL after redirects
+                    const finalUrl = response.url;
+                    const cidMatch = finalUrl.match(/\/ipfs\/([a-zA-Z0-9]+)/);
+                    if (cidMatch) {
+                        cid = cidMatch[1];
+                    }
+                }
+            }
+            if (cid) {
+                const latency = Date.now() - startTime;
+                console.log(`[IPFS] Resolved ${ipnsName} -> ${cid} via ${gateway} (${latency}ms)`);
+                return cid;
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.warn(`[IPFS] Gateway ${gateway} failed: ${errorMsg}`);
+            continue;
+        }
+    }
+    console.warn(`[IPFS] IPNS resolution failed for ${ipnsName} on all gateways`);
+    return null;
+}
+/**
+ * Fetch content from IPFS by CID with fallback across multiple gateways
+ *
+ * @param cid - Content Identifier
+ * @param preferredGateway - Optional preferred gateway to try first
+ * @returns Parsed JSON content or null if fetch fails
+ */
+export async function fetchFromIPFS(cid, preferredGateway) {
+    if (!isValidCID(cid))
+        return null;
+    const gateways = preferredGateway
+        ? [preferredGateway, ...IPFS_GATEWAYS.filter(g => g !== preferredGateway)]
+        : IPFS_GATEWAYS;
+    console.log(`[IPFS] Fetching CID: ${cid}`);
+    for (const gateway of gateways) {
+        try {
+            const startTime = Date.now();
+            const url = `${gateway}/ipfs/${cid}`;
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(30000),
+                headers: {
+                    'Accept': 'application/json',
+                    'Cache-Control': 'max-age=3600',
+                },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                const latency = Date.now() - startTime;
+                console.log(`[IPFS] Fetched ${cid} from ${gateway} (${latency}ms)`);
+                return data;
+            }
+            // Handle specific error codes
+            if (response.status === 504) {
+                console.warn(`[IPFS] Gateway timeout on ${gateway}, trying next...`);
+            }
+            else if (response.status === 429) {
+                console.warn(`[IPFS] Rate limited on ${gateway}, trying next...`);
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.warn(`[IPFS] Gateway ${gateway} failed: ${errorMsg}`);
+            continue;
+        }
+    }
+    console.warn(`[IPFS] Fetch failed for ${cid} on all gateways`);
+    return null;
+}
+/**
+ * Fetch with full result metadata
+ */
+export async function fetchFromIPFSWithMetadata(cid, preferredGateway) {
+    if (!isValidCID(cid))
+        return null;
+    const gateways = preferredGateway
+        ? [preferredGateway, ...IPFS_GATEWAYS.filter(g => g !== preferredGateway)]
+        : IPFS_GATEWAYS;
+    for (const gateway of gateways) {
+        try {
+            const startTime = Date.now();
+            const url = `${gateway}/ipfs/${cid}`;
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(30000),
+                headers: {
+                    'Accept': 'application/json',
+                },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                const latencyMs = Date.now() - startTime;
+                const cached = response.headers.get('X-Cache')?.includes('HIT') ||
+                    response.headers.get('CF-Cache-Status') === 'HIT';
+                return {
+                    data,
+                    gateway,
+                    cid,
+                    cached,
+                    latencyMs,
+                };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Check if CID is pinned/available on a gateway
+ */
+export async function isPinned(cid, gateway = 'https://ipfs.io') {
+    if (!isValidCID(cid))
+        return false;
+    try {
+        const response = await fetch(`${gateway}/ipfs/${cid}`, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(5000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check availability across multiple gateways
+ */
+export async function checkAvailability(cid) {
+    if (!isValidCID(cid))
+        return { available: false, gateways: [] };
+    const results = await Promise.all(IPFS_GATEWAYS.map(async (gateway) => {
+        const startTime = Date.now();
+        try {
+            const response = await fetch(`${gateway}/ipfs/${cid}`, {
+                method: 'HEAD',
+                signal: AbortSignal.timeout(5000),
+            });
+            return {
+                url: gateway,
+                available: response.ok,
+                latencyMs: Date.now() - startTime,
+            };
+        }
+        catch {
+            return {
+                url: gateway,
+                available: false,
+                latencyMs: Date.now() - startTime,
+            };
+        }
+    }));
+    return {
+        available: results.some(r => r.available),
+        gateways: results,
+    };
+}
+/**
+ * Get IPFS gateway URL for a CID
+ */
+export function getGatewayUrl(cid, gateway = 'https://ipfs.io') {
+    return `${gateway}/ipfs/${cid}`;
+}
+/**
+ * Get multiple gateway URLs for redundancy
+ */
+export function getGatewayUrls(cid) {
+    return IPFS_GATEWAYS.map(gateway => `${gateway}/ipfs/${cid}`);
+}
+/**
+ * Validate CID format (CIDv0 and CIDv1)
+ */
+export function isValidCID(cid) {
+    // CIDv0 starts with 'Qm' and is 46 characters (base58btc)
+    // CIDv1 starts with 'b' (base32) or 'z' (base58btc) or 'f' (base16)
+    return /^(Qm[1-9A-HJ-NP-Za-km-z]{44}|b[a-z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|f[0-9a-f]{50,})$/i.test(cid);
+}
+/**
+ * Validate IPNS name format
+ */
+export function isValidIPNS(ipnsName) {
+    // IPNS key format (k51...) or DNSLink domain
+    return /^(k51[a-z0-9]{59,}|[a-z0-9.-]+\.[a-z]{2,})$/i.test(ipnsName);
+}
+/**
+ * Generate content hash for verification
+ */
+export function hashContent(content) {
+    const buffer = typeof content === 'string' ? Buffer.from(content) : content;
+    return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+/**
+ * Verify Ed25519 signature (async import to avoid bundling issues)
+ */
+export async function verifyEd25519Signature(message, signature, publicKey) {
+    try {
+        // Dynamic import to avoid bundling @noble/ed25519 if not used
+        const ed = await import('@noble/ed25519');
+        // Handle prefixed public key (e.g., "ed25519:abc123...")
+        const pubKeyHex = publicKey.replace(/^ed25519:/, '');
+        const isValid = await ed.verifyAsync(Buffer.from(signature, 'hex'), new TextEncoder().encode(message), Buffer.from(pubKeyHex, 'hex'));
+        return isValid;
+    }
+    catch (error) {
+        console.warn('[IPFS] Signature verification failed:', error);
+        return false;
+    }
+}
+/**
+ * Parse CID to extract metadata
+ */
+export function parseCID(cid) {
+    if (!isValidCID(cid)) {
+        return null;
+    }
+    if (cid.startsWith('Qm')) {
+        return {
+            version: 0,
+            codec: 'dag-pb',
+            hash: cid,
+        };
+    }
+    // CIDv1 - simplified parsing
+    return {
+        version: 1,
+        codec: 'dag-cbor', // Most common for JSON
+        hash: cid,
+    };
+}
+/**
+ * Format bytes to human readable
+ */
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+//# sourceMappingURL=client.js.map

package/v3/@claude-flow/cli/dist/src/transfer/ipfs/upload.d.ts

@@ -0,0 +1,95 @@
+/**
+ * IPFS Upload Module
+ * Real upload support via web3.storage, Pinata, or local IPFS
+ *
+ * @module @claude-flow/cli/transfer/ipfs/upload
+ * @version 3.0.0
+ */
+import type { PinningService } from '../types.js';
+/**
+ * IPFS upload options
+ */
+export interface IPFSUploadOptions {
+    pin?: boolean;
+    pinningService?: PinningService;
+    gateway?: string;
+    name?: string;
+    wrapWithDirectory?: boolean;
+    apiKey?: string;
+    apiSecret?: string;
+}
+/**
+ * IPFS upload result
+ */
+export interface IPFSUploadResult {
+    cid: string;
+    size: number;
+    gateway: string;
+    pinnedAt?: string;
+    url: string;
+}
+/**
+ * Upload content to IPFS
+ *
+ * Supports (in order of preference):
+ * - Local/Custom IPFS node (IPFS_API_URL) - FREE, your own node
+ * - web3.storage (WEB3_STORAGE_TOKEN) - Free 5GB tier
+ * - Pinata (PINATA_API_KEY + PINATA_API_SECRET) - Free 1GB tier
+ * - Demo mode (generates deterministic CIDs when no credentials)
+ */
+export declare function uploadToIPFS(content: Buffer, options?: IPFSUploadOptions): Promise<IPFSUploadResult>;
+/**
+ * Pin content by CID
+ */
+export declare function pinContent(cid: string, options?: {
+    service?: PinningService;
+    name?: string;
+}): Promise<{
+    success: boolean;
+    pinnedAt: string;
+}>;
+/**
+ * Unpin content by CID
+ */
+export declare function unpinContent(cid: string, options?: {
+    service?: PinningService;
+}): Promise<{
+    success: boolean;
+}>;
+/**
+ * Check if content exists on IPFS
+ */
+export declare function checkContent(cid: string, gateway?: string): Promise<{
+    exists: boolean;
+    size?: number;
+}>;
+/**
+ * Get gateway URL for CID
+ */
+export declare function getGatewayURL(cid: string, gateway?: string): string;
+/**
+ * Get IPNS URL for name
+ */
+export declare function getIPNSURL(name: string, gateway?: string): string;
+/**
+ * Check if local IPFS node is available
+ */
+declare function checkLocalIPFSNode(): Promise<boolean>;
+/**
+ * Check if real IPFS credentials are available
+ */
+export declare function hasIPFSCredentials(): boolean;
+/**
+ * Get IPFS service status
+ */
+export declare function getIPFSServiceStatus(): {
+    service: 'local' | 'web3storage' | 'pinata' | 'demo';
+    configured: boolean;
+    message: string;
+    apiUrl?: string;
+};
+/**
+ * Export the local IPFS check for external use
+ */
+export { checkLocalIPFSNode };
+//# sourceMappingURL=upload.d.ts.map