@aaronsb/kg-cli 0.6.1

package/dist/api/client.d.ts

@@ -0,0 +1,867 @@
+/**
+ * Knowledge Graph API Client
+ *
+ * Wraps HTTP calls to the FastAPI server
+ */
+import { ApiConfig, JobStatus, JobSubmitResponse, DuplicateJobResponse, IngestRequest, SearchRequest, SearchResponse, SourceSearchRequest, SourceSearchResponse, ConceptDetailsResponse, RelatedConceptsRequest, RelatedConceptsResponse, FindConnectionRequest, FindConnectionResponse, FindConnectionBySearchRequest, FindConnectionBySearchResponse, DatabaseStatsResponse, DatabaseInfoResponse, DatabaseHealthResponse, OntologyListResponse, OntologyInfoResponse, OntologyFilesResponse, OntologyDeleteResponse, OntologyRenameResponse, SystemStatusResponse, BackupRequest, ListBackupsResponse, ResetRequest, ResetResponse, ResourceCreate, ResourceRead, ResourceUpdate, RoleCreate, RoleRead, RoleUpdate, PermissionCreate, PermissionRead, UserRoleAssign, UserRoleRead, PermissionCheckRequest, PermissionCheckResponse } from '../types';
+export declare class KnowledgeGraphClient {
+    private client;
+    private config;
+    private mcpJwtToken;
+    constructor(config: ApiConfig);
+    /**
+     * Set JWT token for MCP server authentication
+     *
+     * This allows the MCP server to inject a JWT token obtained via automatic login,
+     * making authentication transparent to the AI using the MCP tools.
+     *
+     * @param token JWT access token from login response
+     */
+    setMcpJwtToken(token: string | null): void;
+    /**
+     * Health check
+     */
+    health(): Promise<{
+        status: string;
+    }>;
+    /**
+     * Get API info
+     */
+    info(): Promise<any>;
+    /**
+     * Ingest a document file
+     */
+    ingestFile(filePath: string, request: IngestRequest): Promise<JobSubmitResponse | DuplicateJobResponse>;
+    /**
+     * Ingest raw text
+     */
+    ingestText(text: string, request: IngestRequest): Promise<JobSubmitResponse | DuplicateJobResponse>;
+    /**
+     * Ingest image (ADR-057)
+     */
+    ingestImage(filePath: string, request: IngestRequest & {
+        vision_provider?: string;
+        vision_model?: string;
+    }): Promise<JobSubmitResponse | DuplicateJobResponse>;
+    /**
+     * Get job status
+     */
+    getJob(jobId: string): Promise<JobStatus>;
+    /**
+     * Get job status (alias for getJob)
+     */
+    getJobStatus(jobId: string): Promise<JobStatus>;
+    /**
+     * List jobs
+     */
+    listJobs(status?: string, clientId?: string, limit?: number, offset?: number): Promise<JobStatus[]>;
+    /**
+     * Cancel a job
+     */
+    cancelJob(jobId: string): Promise<{
+        job_id: string;
+        cancelled: boolean;
+        message: string;
+    }>;
+    /**
+     * Clear all jobs (nuclear option - requires confirmation)
+     */
+    clearAllJobs(confirm?: boolean): Promise<{
+        success: boolean;
+        jobs_deleted: number;
+        message: string;
+    }>;
+    /**
+     * Approve a job for processing (ADR-014)
+     */
+    approveJob(jobId: string): Promise<{
+        job_id: string;
+        status: string;
+        message: string;
+    }>;
+    /**
+     * Poll job until completion
+     *
+     * @param jobId Job ID to poll
+     * @param onProgress Optional callback for progress updates
+     * @param pollInterval Poll interval in ms (default: 2000)
+     * @returns Final job status
+     */
+    pollJob(jobId: string, onProgress?: (job: JobStatus) => void, pollInterval?: number): Promise<JobStatus>;
+    /**
+     * Search for concepts using semantic similarity
+     */
+    searchConcepts(request: SearchRequest): Promise<SearchResponse>;
+    /**
+     * Search source text using semantic similarity (ADR-068 Phase 3)
+     */
+    searchSources(request: SourceSearchRequest): Promise<SourceSearchResponse>;
+    /**
+     * Get detailed information about a concept
+     */
+    getConceptDetails(conceptId: string, includeGrounding?: boolean, includeDiversity?: boolean, diversityMaxHops?: number): Promise<ConceptDetailsResponse>;
+    /**
+     * Find concepts related through graph traversal
+     */
+    findRelatedConcepts(request: RelatedConceptsRequest): Promise<RelatedConceptsResponse>;
+    /**
+     * Find shortest paths between two concepts
+     */
+    findConnection(request: FindConnectionRequest): Promise<FindConnectionResponse>;
+    /**
+     * Find shortest paths between concepts using natural language queries
+     */
+    findConnectionBySearch(request: FindConnectionBySearchRequest): Promise<FindConnectionBySearchResponse>;
+    /**
+     * Get image for a source node (ADR-057)
+     * @param sourceId - Source ID from concept instance
+     * @returns Image as Buffer (binary data)
+     */
+    getSourceImage(sourceId: string): Promise<Buffer>;
+    /**
+     * Get image for a source node as base64 string (ADR-057)
+     * Useful for MCP server to return images to Claude
+     * @param sourceId - Source ID from concept instance
+     * @returns Base64-encoded image string
+     */
+    getSourceImageBase64(sourceId: string): Promise<string>;
+    /**
+     * List source nodes with optional filtering
+     * @param options - Filter and pagination options
+     * @returns List of sources with metadata
+     */
+    listSources(options?: {
+        ontology?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        sources: Array<{
+            source_id: string;
+            document: string;
+            paragraph: number;
+            content_type?: string;
+            has_garage_key: boolean;
+        }>;
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    /**
+     * Get original document for a source node (ADR-081)
+     * @param sourceId - Source ID from search results or concept details
+     * @returns Document content as Buffer (binary data)
+     */
+    getSourceDocument(sourceId: string): Promise<Buffer>;
+    /**
+     * Get source metadata
+     * @param sourceId - Source ID
+     * @returns Source metadata including garage_key, content_hash, etc.
+     */
+    getSourceMetadata(sourceId: string): Promise<{
+        source_id: string;
+        document: string;
+        paragraph: number;
+        full_text: string;
+        file_path?: string;
+        content_type?: string;
+        storage_key?: string;
+        garage_key?: string;
+        content_hash?: string;
+        char_offset_start?: number;
+        char_offset_end?: number;
+        chunk_index?: number;
+        has_visual_embedding: boolean;
+        has_text_embedding: boolean;
+    }>;
+    /**
+     * Search documents using semantic similarity
+     * Aggregates chunk-level matches to document level
+     */
+    searchDocuments(request: {
+        query: string;
+        min_similarity?: number;
+        limit?: number;
+        ontology?: string;
+    }): Promise<{
+        documents: Array<{
+            document_id: string;
+            filename: string;
+            ontology: string;
+            content_type: string;
+            best_similarity: number;
+            source_count: number;
+            resources: Array<{
+                type: string;
+                garage_key: string;
+            }>;
+            concept_ids: string[];
+        }>;
+        returned: number;
+        total_matches: number;
+    }>;
+    /**
+     * List documents with optional ontology filter
+     */
+    listDocuments(options?: {
+        ontology?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        documents: Array<{
+            document_id: string;
+            filename: string;
+            ontology: string;
+            content_type: string;
+            source_count: number;
+            concept_count: number;
+        }>;
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    /**
+     * Get document content from Garage
+     */
+    getDocumentContent(documentId: string): Promise<{
+        document_id: string;
+        content_type: string;
+        content: {
+            document?: string;
+            image?: string;
+            prose?: string;
+            encoding: string;
+            error?: string;
+        };
+        chunks: Array<{
+            source_id: string;
+            paragraph: number;
+            full_text: string;
+            char_offset_start?: number;
+            char_offset_end?: number;
+        }>;
+    }>;
+    /**
+     * Get concepts extracted from a document
+     */
+    getDocumentConcepts(documentId: string): Promise<{
+        document_id: string;
+        filename: string;
+        concepts: Array<{
+            concept_id: string;
+            name: string;
+            source_id: string;
+            instance_count: number;
+        }>;
+        total: number;
+    }>;
+    /**
+     * Get database statistics
+     */
+    getDatabaseStats(): Promise<DatabaseStatsResponse>;
+    /**
+     * Get database connection information
+     */
+    getDatabaseInfo(): Promise<DatabaseInfoResponse>;
+    /**
+     * Check database health
+     */
+    getDatabaseHealth(): Promise<DatabaseHealthResponse>;
+    /**
+     * Execute a custom cypher query (ADR-048)
+     * @param query - openCypher/GQL query string
+     * @param params - Optional query parameters
+     * @param namespace - Optional namespace: 'concept', 'vocab', or null for raw
+     */
+    executeCypherQuery(query: string, params?: Record<string, any>, namespace?: string | null): Promise<any>;
+    /**
+     * Get all graph metrics counters organized by type (ADR-079)
+     */
+    getDatabaseCounters(): Promise<any>;
+    /**
+     * Refresh graph metrics counters from current graph state (ADR-079)
+     */
+    refreshDatabaseCounters(): Promise<any>;
+    /**
+     * List all ontologies
+     */
+    listOntologies(): Promise<OntologyListResponse>;
+    /**
+     * Get ontology information
+     */
+    getOntologyInfo(ontologyName: string): Promise<OntologyInfoResponse>;
+    /**
+     * List files in an ontology
+     */
+    getOntologyFiles(ontologyName: string): Promise<OntologyFilesResponse>;
+    /**
+     * Delete an ontology
+     */
+    deleteOntology(ontologyName: string, force?: boolean): Promise<OntologyDeleteResponse>;
+    /**
+     * Rename an ontology
+     */
+    renameOntology(oldName: string, newName: string): Promise<OntologyRenameResponse>;
+    /**
+     * Get system status
+     */
+    getSystemStatus(): Promise<SystemStatusResponse>;
+    /**
+     * List available backup files
+     */
+    listBackups(): Promise<ListBackupsResponse>;
+    /**
+     * Create a database backup (ADR-015 Phase 2: Streaming Download)
+     *
+     * Downloads backup as a stream and saves to specified path.
+     * Provides progress callback for tracking download.
+     *
+     * @param request Backup request (type and optional ontology)
+     * @param savePath Where to save the backup file
+     * @param onProgress Optional callback for progress updates (bytes downloaded, total bytes, percent)
+     * @returns Metadata about the downloaded backup
+     */
+    createBackup(request: BackupRequest, savePath: string, onProgress?: (downloaded: number, total: number, percent: number) => void): Promise<{
+        filename: string;
+        path: string;
+        size: number;
+    }>;
+    /**
+     * Restore a database backup (ADR-015 Phase 2: Multipart Upload)
+     *
+     * Uploads backup file as multipart/form-data and queues restore job.
+     * Server validates backup, creates checkpoint, then executes restore with progress tracking.
+     * Uses OAuth authentication (token from login).
+     *
+     * @param backupFilePath Path to backup file (.tar.gz archive or .json)
+     * @param overwrite Whether to overwrite existing data
+     * @param handleExternalDeps How to handle external dependencies ('prune', 'stitch', 'defer')
+     * @param onUploadProgress Optional callback for upload progress (bytes uploaded, total bytes, percent)
+     * @returns Job ID and initial status for polling restore progress
+     */
+    restoreBackup(backupFilePath: string, overwrite?: boolean, handleExternalDeps?: string, onUploadProgress?: (uploaded: number, total: number, percent: number) => void): Promise<{
+        job_id: string;
+        status: string;
+        message: string;
+        backup_stats: any;
+        integrity_warnings: number;
+    }>;
+    /**
+     * Reset database (destructive - requires authentication)
+     */
+    resetDatabase(request: ResetRequest): Promise<ResetResponse>;
+    /**
+     * Get job scheduler status and statistics (ADR-014)
+     */
+    getSchedulerStatus(): Promise<any>;
+    /**
+     * Manually trigger job scheduler cleanup (ADR-014)
+     */
+    triggerSchedulerCleanup(): Promise<any>;
+    /**
+     * Regenerate embeddings for concept nodes in the graph
+     */
+    regenerateConceptEmbeddings(params: {
+        only_missing?: boolean;
+        ontology?: string;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Unified embedding regeneration for all graph text entities (ADR-068 Phase 4).
+     *
+     * Regenerate embeddings for concepts, sources, or vocabulary (relationship types).
+     * Useful for model migrations, fixing missing/corrupted embeddings, or bulk regeneration.
+     */
+    regenerateEmbeddings(params: {
+        embedding_type: 'concept' | 'source' | 'vocabulary' | 'all';
+        only_missing?: boolean;
+        only_incompatible?: boolean;
+        ontology?: string;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Get comprehensive embedding status for all graph text entities.
+     *
+     * Shows count, percentage, compatibility verification, and hash verification
+     * for embeddings across concepts, sources, vocabulary, and images.
+     */
+    getEmbeddingStatus(ontology?: string): Promise<any>;
+    /**
+     * List all registered resource types
+     */
+    listResources(): Promise<ResourceRead[]>;
+    /**
+     * Get a specific resource type
+     */
+    getResource(resourceType: string): Promise<ResourceRead>;
+    /**
+     * Register a new resource type
+     */
+    createResource(resource: ResourceCreate): Promise<ResourceRead>;
+    /**
+     * Update a resource type
+     */
+    updateResource(resourceType: string, update: ResourceUpdate): Promise<ResourceRead>;
+    /**
+     * Delete a resource type
+     */
+    deleteResource(resourceType: string): Promise<void>;
+    /**
+     * List all roles
+     */
+    listRoles(includeInactive?: boolean): Promise<RoleRead[]>;
+    /**
+     * Get a specific role
+     */
+    getRole(roleName: string): Promise<RoleRead>;
+    /**
+     * Create a new role
+     */
+    createRole(role: RoleCreate): Promise<RoleRead>;
+    /**
+     * Update a role
+     */
+    updateRole(roleName: string, update: RoleUpdate): Promise<RoleRead>;
+    /**
+     * Delete a role
+     */
+    deleteRole(roleName: string): Promise<void>;
+    /**
+     * List permissions (optionally filtered)
+     */
+    listPermissions(roleName?: string, resourceType?: string): Promise<PermissionRead[]>;
+    /**
+     * Grant a permission to a role
+     */
+    createPermission(permission: PermissionCreate): Promise<PermissionRead>;
+    /**
+     * Revoke a permission from a role
+     */
+    deletePermission(permissionId: number): Promise<void>;
+    /**
+     * List role assignments for a user
+     */
+    listUserRoles(userId: number): Promise<UserRoleRead[]>;
+    /**
+     * Assign a role to a user
+     */
+    assignUserRole(assignment: UserRoleAssign): Promise<UserRoleRead>;
+    /**
+     * Revoke a role assignment from a user
+     */
+    revokeUserRole(assignmentId: number): Promise<void>;
+    /**
+     * Check if a user has a specific permission
+     */
+    checkPermission(request: PermissionCheckRequest): Promise<PermissionCheckResponse>;
+    /**
+     * Get current vocabulary status
+     */
+    getVocabularyStatus(): Promise<any>;
+    /**
+     * List all edge types with statistics
+     */
+    listEdgeTypes(includeInactive?: boolean, includeBuiltin?: boolean): Promise<any>;
+    /**
+     * Manually add a new edge type (curator action)
+     */
+    addEdgeType(request: {
+        relationship_type: string;
+        category: string;
+        description?: string;
+        is_builtin?: boolean;
+    }): Promise<any>;
+    /**
+     * Generate vocabulary optimization recommendations
+     */
+    getVocabularyRecommendations(): Promise<any>;
+    /**
+     * Execute all auto-approved recommendations
+     */
+    executeAutoRecommendations(): Promise<any>;
+    /**
+     * Get detailed vocabulary analysis
+     */
+    getVocabularyAnalysis(): Promise<any>;
+    /**
+     * Get vocabulary configuration
+     */
+    getVocabularyConfig(): Promise<any>;
+    /**
+     * Get vocabulary configuration details (admin endpoint)
+     */
+    getVocabularyConfigDetail(): Promise<any>;
+    /**
+     * Update vocabulary configuration (admin endpoint)
+     */
+    updateVocabularyConfig(config: {
+        vocab_min?: number;
+        vocab_max?: number;
+        vocab_emergency?: number;
+        pruning_mode?: string;
+        aggressiveness_profile?: string;
+        auto_expand_enabled?: boolean;
+        synonym_threshold_strong?: number;
+        synonym_threshold_moderate?: number;
+        low_value_threshold?: number;
+        consolidation_similarity_threshold?: number;
+        updated_by: string;
+    }): Promise<any>;
+    /**
+     * List aggressiveness profiles (admin endpoint)
+     */
+    listAggressivenessProfiles(): Promise<any>;
+    /**
+     * Get specific aggressiveness profile (admin endpoint)
+     */
+    getAggressivenessProfile(profileName: string): Promise<any>;
+    /**
+     * Create custom aggressiveness profile (admin endpoint)
+     */
+    createAggressivenessProfile(profile: {
+        profile_name: string;
+        control_x1: number;
+        control_y1: number;
+        control_x2: number;
+        control_y2: number;
+        description: string;
+    }): Promise<any>;
+    /**
+     * Delete custom aggressiveness profile (admin endpoint)
+     */
+    deleteAggressivenessProfile(profileName: string): Promise<any>;
+    /**
+     * Merge two edge types (curator action)
+     */
+    mergeEdgeTypes(request: {
+        deprecated_type: string;
+        target_type: string;
+        performed_by: string;
+        reason?: string;
+    }): Promise<any>;
+    /**
+     * Get category similarity scores for a relationship type (ADR-047)
+     */
+    getCategoryScores(relationshipType: string): Promise<any>;
+    /**
+     * Refresh category assignments for vocabulary types (ADR-047)
+     */
+    refreshCategories(onlyComputed?: boolean): Promise<any>;
+    /**
+     * Generate embeddings for vocabulary types (bulk operation)
+     */
+    generateVocabularyEmbeddings(forceRegenerate?: boolean, onlyMissing?: boolean): Promise<any>;
+    /**
+     * Run AITL vocabulary consolidation workflow (ADR-032)
+     */
+    consolidateVocabulary(request: {
+        target_size?: number;
+        batch_size?: number;
+        auto_execute_threshold?: number;
+        dry_run?: boolean;
+        prune_unused?: boolean;
+    }): Promise<any>;
+    /**
+     * Measure epistemic status for vocabulary types (ADR-065 Phase 2)
+     */
+    measureEpistemicStatus(request: {
+        sample_size?: number;
+        store?: boolean;
+        verbose?: boolean;
+    }): Promise<any>;
+    /**
+     * List vocabulary types with epistemic status (ADR-065 Phase 2)
+     */
+    listEpistemicStatus(statusFilter?: string): Promise<any>;
+    /**
+     * Get epistemic status for a specific vocabulary type (ADR-065 Phase 2)
+     */
+    getEpistemicStatus(relationshipType: string): Promise<any>;
+    /**
+     * Sync missing edge types from graph to vocabulary (ADR-077)
+     */
+    syncVocabulary(dryRun?: boolean): Promise<any>;
+    /**
+     * Get current embedding configuration (public endpoint)
+     */
+    getEmbeddingConfig(): Promise<any>;
+    /**
+     * Get detailed embedding configuration (admin endpoint)
+     */
+    getEmbeddingConfigDetail(): Promise<any>;
+    /**
+     * Update embedding configuration (admin endpoint)
+     */
+    updateEmbeddingConfig(config: any): Promise<any>;
+    /**
+     * Hot reload embedding model (admin endpoint)
+     */
+    reloadEmbeddingModel(): Promise<any>;
+    /**
+     * List all embedding configurations (admin endpoint)
+     */
+    listEmbeddingConfigs(): Promise<any[]>;
+    /**
+     * Set protection flags on an embedding config (admin endpoint)
+     */
+    protectEmbeddingConfig(configId: number, deleteProtected?: boolean, changeProtected?: boolean): Promise<any>;
+    /**
+     * Delete an embedding configuration (admin endpoint)
+     */
+    deleteEmbeddingConfig(configId: number): Promise<any>;
+    /**
+     * Activate an embedding configuration with automatic protection management (admin endpoint)
+     */
+    activateEmbeddingConfig(configId: number, force?: boolean): Promise<any>;
+    /**
+     * Get current extraction configuration (public endpoint)
+     */
+    getExtractionConfig(): Promise<any>;
+    /**
+     * Get detailed extraction configuration (admin endpoint)
+     */
+    getExtractionConfigDetail(): Promise<any>;
+    /**
+     * Update extraction configuration (admin endpoint)
+     */
+    updateExtractionConfig(config: any): Promise<any>;
+    /**
+     * List API keys with validation status (admin endpoint)
+     */
+    listApiKeys(): Promise<any[]>;
+    /**
+     * Set API key for a provider (admin endpoint)
+     */
+    setApiKey(provider: string, apiKey: string): Promise<any>;
+    /**
+     * Delete API key for a provider (admin endpoint)
+     */
+    deleteApiKey(provider: string): Promise<any>;
+    /**
+     * Get similar edge types via embedding similarity (ADR-053)
+     */
+    getSimilarTypes(relationshipType: string, limit?: number, reverse?: boolean): Promise<any>;
+    /**
+     * Get detailed vocabulary analysis (ADR-053)
+     */
+    analyzeVocabularyType(relationshipType: string): Promise<any>;
+    /**
+     * Analyze polarity axis between two concept poles (ADR-070)
+     */
+    analyzePolarityAxis(request: {
+        positive_pole_id: string;
+        negative_pole_id: string;
+        candidate_ids?: string[];
+        auto_discover?: boolean;
+        max_candidates?: number;
+        max_hops?: number;
+        discovery_slot_pct?: number;
+        max_workers?: number;
+        chunk_size?: number;
+        timeout_seconds?: number;
+    }): Promise<any>;
+    /**
+     * Submit async polarity analysis job with artifact creation (ADR-083)
+     */
+    submitPolarityJob(request: {
+        positive_pole_id: string;
+        negative_pole_id: string;
+        candidate_ids?: string[];
+        auto_discover?: boolean;
+        max_candidates?: number;
+        max_hops?: number;
+        discovery_slot_pct?: number;
+        max_workers?: number;
+        chunk_size?: number;
+        timeout_seconds?: number;
+        create_artifact?: boolean;
+    }): Promise<{
+        job_id: string;
+        status: string;
+        message: string;
+    }>;
+    /**
+     * Get available projection algorithms
+     */
+    getProjectionAlgorithms(): Promise<{
+        available: string[];
+        default: string;
+    }>;
+    /**
+     * Get cached projection for an ontology
+     */
+    getProjection(ontology: string): Promise<any>;
+    /**
+     * Regenerate projection for an ontology
+     */
+    regenerateProjection(ontology: string, options?: {
+        force?: boolean;
+        algorithm?: 'tsne' | 'umap';
+        perplexity?: number;
+        center?: boolean;
+        include_grounding?: boolean;
+        include_diversity?: boolean;
+        create_artifact?: boolean;
+    }): Promise<{
+        status: string;
+        job_id?: string;
+        message: string;
+        changelist_id?: string;
+        artifact_id?: number;
+    }>;
+    /**
+     * Invalidate (delete) cached projection
+     */
+    invalidateProjection(ontology: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * List artifacts with optional filtering
+     */
+    listArtifacts(params?: {
+        artifact_type?: string;
+        representation?: string;
+        ontology?: string;
+        owner_id?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        artifacts: any[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    /**
+     * Get artifact metadata by ID
+     */
+    getArtifact(artifactId: number): Promise<any>;
+    /**
+     * Get artifact with full payload
+     */
+    getArtifactPayload(artifactId: number): Promise<any>;
+    /**
+     * Create a new artifact
+     */
+    createArtifact(artifact: {
+        artifact_type: string;
+        representation: string;
+        name?: string;
+        parameters: Record<string, any>;
+        payload: Record<string, any>;
+        metadata?: Record<string, any>;
+        ontology?: string;
+        concept_ids?: string[];
+        expires_at?: string;
+        query_definition_id?: number;
+    }): Promise<{
+        id: number;
+        artifact_type: string;
+        representation: string;
+        name?: string;
+        graph_epoch: number;
+        storage_location: string;
+        garage_key?: string;
+        created_at: string;
+    }>;
+    /**
+     * Delete an artifact
+     */
+    deleteArtifact(artifactId: number): Promise<void>;
+    /**
+     * List groups
+     */
+    listGroups(params?: {
+        include_system?: boolean;
+        include_member_count?: boolean;
+    }): Promise<{
+        groups: any[];
+        total: number;
+    }>;
+    /**
+     * Create a group
+     */
+    createGroup(group: {
+        group_name: string;
+        display_name?: string;
+        description?: string;
+    }): Promise<any>;
+    /**
+     * List group members
+     */
+    listGroupMembers(groupId: number): Promise<{
+        group_id: number;
+        group_name: string;
+        members: any[];
+        total: number;
+    }>;
+    /**
+     * Add member to group
+     */
+    addGroupMember(groupId: number, userId: number): Promise<any>;
+    /**
+     * Remove member from group
+     */
+    removeGroupMember(groupId: number, userId: number): Promise<void>;
+    /**
+     * Create a resource grant
+     */
+    createGrant(grant: {
+        resource_type: string;
+        resource_id: string;
+        principal_type: 'user' | 'group';
+        principal_id: number;
+        permission: 'read' | 'write' | 'admin';
+    }): Promise<any>;
+    /**
+     * List grants for a resource
+     */
+    listResourceGrants(resourceType: string, resourceId: string): Promise<{
+        grants: any[];
+        total: number;
+    }>;
+    /**
+     * Revoke a grant
+     */
+    revokeGrant(grantId: number): Promise<void>;
+    /**
+     * List query definitions
+     */
+    listQueryDefinitions(params?: {
+        definition_type?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        definitions: any[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    /**
+     * Get a query definition by ID
+     */
+    getQueryDefinition(definitionId: number): Promise<any>;
+    /**
+     * Create a query definition
+     */
+    createQueryDefinition(definition: {
+        name: string;
+        definition_type: string;
+        definition: Record<string, any>;
+    }): Promise<any>;
+    /**
+     * Update a query definition
+     */
+    updateQueryDefinition(definitionId: number, update: {
+        name?: string;
+        definition?: Record<string, any>;
+    }): Promise<any>;
+    /**
+     * Delete a query definition
+     */
+    deleteQueryDefinition(definitionId: number): Promise<void>;
+}
+/**
+ * Create a client from environment variables and config file
+ * Priority: CLI flags > env vars > config file > defaults
+ */
+export declare function createClientFromEnv(): KnowledgeGraphClient;
+//# sourceMappingURL=client.d.ts.map