@inkeep/agents-manage-api 0.1.0

package/dist/data/conversations.d.ts

@@ -0,0 +1,59 @@
+import { type ConversationScopeOptions, type ConversationHistoryConfig, type AgentConversationHistoryConfig } from '@inkeep/agents-core';
+/**
+ * Creates default conversation history configuration
+ * @param mode - The conversation history mode ('full' | 'scoped' | 'none')
+ * @returns Default AgentConversationHistoryConfig
+ */
+export declare function createDefaultConversationHistoryConfig(mode?: 'full' | 'scoped' | 'none'): AgentConversationHistoryConfig;
+/**
+ * Saves the result of an A2A client sendMessage call as a conversation message
+ * @param response - The response from a2aClient.sendMessage()
+ * @param params - Parameters for saving the message
+ * @returns The saved message or null if no text content was found
+ */
+export declare function saveA2AMessageResponse(response: any, // SendMessageResponse type
+params: {
+    tenantId: string;
+    projectId: string;
+    conversationId: string;
+    messageType: 'a2a-response' | 'a2a-request';
+    visibility: 'internal' | 'external' | 'user-facing';
+    fromAgentId?: string;
+    toAgentId?: string;
+    fromExternalAgentId?: string;
+    toExternalAgentId?: string;
+    a2aTaskId?: string;
+    a2aSessionId?: string;
+    metadata?: Record<string, unknown>;
+}): Promise<any | null>;
+/**
+ * Applies filtering based on agent, task, or both criteria
+ * Returns the filtered messages array
+ */
+export declare function getScopedHistory({ tenantId, projectId, conversationId, filters, options, }: {
+    tenantId: string;
+    projectId: string;
+    conversationId: string;
+    filters?: ConversationScopeOptions;
+    options?: ConversationHistoryConfig;
+}): Promise<any[]>;
+/**
+ * Get user-facing conversation history (for client display)
+ */
+export declare function getUserFacingHistory(tenantId: string, projectId: string, conversationId: string, limit?: number): Promise<any[]>;
+/**
+ * Get full conversation context (for agent processing)
+ */
+export declare function getFullConversationContext(tenantId: string, projectId: string, conversationId: string, maxTokens?: number): Promise<any[]>;
+/**
+ * Get formatted conversation history for a2a
+ */
+export declare function getFormattedConversationHistory({ tenantId, projectId, conversationId, currentMessage, options, filters, }: {
+    tenantId: string;
+    projectId: string;
+    conversationId: string;
+    currentMessage?: string;
+    options?: ConversationHistoryConfig;
+    filters?: ConversationScopeOptions;
+}): Promise<string>;
+//# sourceMappingURL=conversations.d.ts.map

package/dist/data/conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversations.d.ts","sourceRoot":"","sources":["../../src/data/conversations.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,EAEpC,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,GAAE,MAAM,GAAG,QAAQ,GAAG,MAAe,GACxC,8BAA8B,CAQhC;AAYD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,GAAG,EAAE,2BAA2B;AAC1C,MAAM,EAAE;IACN,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,cAAc,GAAG,aAAa,CAAC;IAC5C,UAAU,EAAE,UAAU,GAAG,UAAU,GAAG,aAAa,CAAC;IACpD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,GACA,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CAkDrB;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,QAAQ,EACR,SAAS,EACT,cAAc,EACd,OAAO,EACP,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC,OAAO,CAAC,EAAE,yBAAyB,CAAC;CACrC,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAyDjB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,KAAK,SAAK,GACT,OAAO,CAAC,GAAG,EAAE,CAAC,CAUhB;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,GAAG,EAAE,CAAC,CAUhB;AAED;;GAEG;AACH,wBAAsB,+BAA+B,CAAC,EACpD,QAAQ,EACR,SAAS,EACT,cAAc,EACd,cAAc,EACd,OAAO,EACP,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,yBAAyB,CAAC;IACpC,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACpC,GAAG,OAAO,CAAC,MAAM,CAAC,CAuDlB"}

package/dist/data/conversations.js

@@ -0,0 +1,216 @@
+import { nanoid } from 'nanoid';
+import dbClient from './db/dbClient.js';
+import { createMessage, getConversationHistory, } from '@inkeep/agents-core';
+/**
+ * Creates default conversation history configuration
+ * @param mode - The conversation history mode ('full' | 'scoped' | 'none')
+ * @returns Default AgentConversationHistoryConfig
+ */
+export function createDefaultConversationHistoryConfig(mode = 'full') {
+    return {
+        mode,
+        limit: 50,
+        includeInternal: true,
+        messageTypes: ['chat'],
+        maxOutputTokens: 4000,
+    };
+}
+/**
+ * Extracts text content from A2A Message parts array
+ */
+function extractA2AMessageText(parts) {
+    return parts
+        .filter((part) => part.kind === 'text' && part.text)
+        .map((part) => part.text)
+        .join('');
+}
+/**
+ * Saves the result of an A2A client sendMessage call as a conversation message
+ * @param response - The response from a2aClient.sendMessage()
+ * @param params - Parameters for saving the message
+ * @returns The saved message or null if no text content was found
+ */
+export async function saveA2AMessageResponse(response, // SendMessageResponse type
+params) {
+    // Handle error responses
+    if (response.error) {
+        throw new Error(response.error.message);
+    }
+    // Extract text content based on result type
+    let messageText = '';
+    if (response.result.kind === 'message') {
+        // Handle Message type with parts array
+        messageText = extractA2AMessageText(response.result.parts);
+    }
+    else if (response.result.kind === 'task') {
+        // Handle Task type - extract text from artifacts if available
+        if (response.result.artifacts && response.result.artifacts.length > 0) {
+            const firstArtifact = response.result.artifacts[0];
+            if (firstArtifact.parts) {
+                messageText = extractA2AMessageText(firstArtifact.parts);
+            }
+        }
+    }
+    else if (typeof response.result === 'string') {
+        // Handle direct string responses (for backward compatibility)
+        messageText = response.result;
+    }
+    // Only save if we have meaningful text content
+    if (!messageText || messageText.trim() === '') {
+        return null;
+    }
+    // Save the message
+    return await createMessage(dbClient)({
+        id: nanoid(),
+        tenantId: params.tenantId,
+        projectId: params.projectId,
+        conversationId: params.conversationId,
+        role: 'agent',
+        content: {
+            text: messageText,
+        },
+        visibility: params.visibility,
+        messageType: params.messageType,
+        fromAgentId: params.fromAgentId,
+        toAgentId: params.toAgentId,
+        fromExternalAgentId: params.fromExternalAgentId,
+        toExternalAgentId: params.toExternalAgentId,
+        a2aTaskId: params.a2aTaskId,
+        a2aSessionId: params.a2aSessionId,
+        metadata: params.metadata,
+    });
+}
+/**
+ * Applies filtering based on agent, task, or both criteria
+ * Returns the filtered messages array
+ */
+export async function getScopedHistory({ tenantId, projectId, conversationId, filters, options, }) {
+    try {
+        // Get conversation history with internal messages included
+        const messages = await getConversationHistory(dbClient)({
+            scopes: { tenantId, projectId },
+            conversationId,
+            options,
+        });
+        // If no filters provided, return all messages
+        if (!filters || (!filters.agentId && !filters.taskId)) {
+            return messages;
+        }
+        // Filter messages based on provided criteria
+        const relevantMessages = messages.filter((msg) => {
+            // Always include user messages
+            if (msg.role === 'user')
+                return true;
+            let matchesAgent = true;
+            let matchesTask = true;
+            // Apply agent filtering if agentId is provided
+            if (filters.agentId) {
+                matchesAgent =
+                    (msg.role === 'agent' && msg.visibility === 'user-facing') ||
+                        msg.toAgentId === filters.agentId ||
+                        msg.fromAgentId === filters.agentId;
+            }
+            // Apply task filtering if taskId is provided
+            if (filters.taskId) {
+                matchesTask = msg.taskId === filters.taskId || msg.a2aTaskId === filters.taskId;
+            }
+            // For combined filtering (both agent and task), both must match
+            // For single filtering, only the relevant one needs to match
+            if (filters.agentId && filters.taskId) {
+                return matchesAgent && matchesTask;
+            }
+            if (filters.agentId) {
+                return matchesAgent;
+            }
+            if (filters.taskId) {
+                return matchesTask;
+            }
+            return false;
+        });
+        return relevantMessages;
+    }
+    catch (error) {
+        console.error('Failed to fetch scoped messages:', error);
+        return [];
+    }
+}
+/**
+ * Get user-facing conversation history (for client display)
+ */
+export async function getUserFacingHistory(tenantId, projectId, conversationId, limit = 50) {
+    return await getConversationHistory(dbClient)({
+        scopes: { tenantId, projectId },
+        conversationId,
+        options: {
+            limit,
+            includeInternal: false,
+            messageTypes: ['chat'],
+        },
+    });
+}
+/**
+ * Get full conversation context (for agent processing)
+ */
+export async function getFullConversationContext(tenantId, projectId, conversationId, maxTokens) {
+    return await getConversationHistory(dbClient)({
+        scopes: { tenantId, projectId },
+        conversationId,
+        options: {
+            limit: 100,
+            includeInternal: true,
+            maxOutputTokens: maxTokens,
+        },
+    });
+}
+/**
+ * Get formatted conversation history for a2a
+ */
+export async function getFormattedConversationHistory({ tenantId, projectId, conversationId, currentMessage, options, filters, }) {
+    // Ensure includeInternal defaults to true for formatted history
+    const historyOptions = options ?? { includeInternal: true };
+    // Get filtered conversation history using unified function
+    const conversationHistory = await getScopedHistory({
+        tenantId,
+        projectId,
+        conversationId,
+        filters,
+        options: historyOptions,
+    });
+    // Filter out the current message if it's the most recent one
+    let messagesToFormat = conversationHistory;
+    if (currentMessage && conversationHistory.length > 0) {
+        const lastMessage = conversationHistory[conversationHistory.length - 1];
+        if (lastMessage.content.text === currentMessage) {
+            // Remove the last message if it matches the current prompt
+            messagesToFormat = conversationHistory.slice(0, -1);
+        }
+    }
+    if (!messagesToFormat.length) {
+        return '';
+    }
+    const formattedHistory = messagesToFormat
+        .map((msg) => {
+        let roleLabel;
+        if (msg.role === 'user') {
+            roleLabel = 'user';
+        }
+        else if (msg.role === 'agent' &&
+            (msg.messageType === 'a2a-request' || msg.messageType === 'a2a-response')) {
+            // For agent messages, include sender and recipient info when available
+            const fromAgent = msg.fromAgentId || msg.fromExternalAgentId || 'unknown';
+            const toAgent = msg.toAgentId || msg.toExternalAgentId || 'unknown';
+            roleLabel = `${fromAgent} to ${toAgent}`;
+        }
+        else if (msg.role === 'agent' && msg.messageType === 'chat') {
+            const fromAgent = msg.fromAgentId || 'unknown';
+            roleLabel = `${fromAgent} to User`;
+        }
+        else {
+            // System or other message types
+            roleLabel = msg.role || 'system';
+        }
+        return `${roleLabel}: """${msg.content.text}"""`; // TODO: add timestamp?
+    })
+        .join('\n');
+    return `<conversation_history>\n${formattedHistory}\n</conversation_history>\n`;
+}

package/dist/data/db/clean.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Truncates all tables in the database, respecting foreign key constraints
+ * Tables are cleared in dependency order (child tables first, then parent tables)
+ */
+export declare function cleanDatabase(): Promise<void>;
+//# sourceMappingURL=clean.d.ts.map

package/dist/data/db/clean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../../src/data/db/clean.ts"],"names":[],"mappings":"AAwBA;;;GAGG;AACH,wBAAsB,aAAa,kBA6DlC"}

package/dist/data/db/clean.js

@@ -0,0 +1,77 @@
+import { sql } from 'drizzle-orm';
+import { env } from '../../env.js';
+import { agentArtifactComponents, agentDataComponents, agentGraph, agentRelations, agents, agentToolRelations, artifactComponents, contextCache, contextConfigs, conversations, credentialReferences, dataComponents, externalAgents, ledgerArtifacts, messages, taskRelations, tasks, tools, } from '@inkeep/agents-core';
+import dbClient from './dbClient.js';
+/**
+ * Truncates all tables in the database, respecting foreign key constraints
+ * Tables are cleared in dependency order (child tables first, then parent tables)
+ */
+export async function cleanDatabase() {
+    console.log(`🗑️  Cleaning database for environment: ${env.ENVIRONMENT}`);
+    console.log(`📁 Using database: ${env.DB_FILE_NAME}`);
+    console.log('---');
+    try {
+        // Disable foreign key constraints temporarily to make cleanup easier
+        await dbClient.run(sql `PRAGMA foreign_keys = OFF`);
+        // Order matters: clear dependent tables first
+        const tablesToClear = [
+            { table: messages, name: 'messages' },
+            { table: conversations, name: 'conversations' },
+            { table: taskRelations, name: 'task_relations' },
+            { table: tasks, name: 'tasks' },
+            { table: agentArtifactComponents, name: 'agent_artifact_components' },
+            { table: agentDataComponents, name: 'agent_data_components' },
+            { table: agentToolRelations, name: 'agent_tool_relations' },
+            { table: agentRelations, name: 'agent_relations' },
+            { table: agentGraph, name: 'agent_graph' },
+            { table: artifactComponents, name: 'artifact_components' },
+            { table: dataComponents, name: 'data_components' },
+            { table: tools, name: 'tools' },
+            { table: agents, name: 'agents' },
+            { table: externalAgents, name: 'external_agents' },
+            { table: ledgerArtifacts, name: 'ledger_artifacts' },
+            { table: credentialReferences, name: 'credential_references' },
+            { table: contextConfigs, name: 'context_configs' },
+            { table: contextCache, name: 'context_cache' },
+        ];
+        for (const { table, name } of tablesToClear) {
+            try {
+                await dbClient.delete(table).run();
+                console.log(`✅ Cleared table: ${name}`);
+            }
+            catch (error) {
+                // Handle case where table doesn't exist
+                const errorMessage = error?.message || '';
+                const causeMessage = error?.cause?.message || '';
+                if (errorMessage.includes('no such table') ||
+                    causeMessage.includes('no such table') ||
+                    (error?.cause?.code === 'SQLITE_ERROR' && causeMessage.includes('no such table'))) {
+                    console.log(`⚠️  Table ${name} doesn't exist, skipping`);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        // Re-enable foreign key constraints
+        await dbClient.run(sql `PRAGMA foreign_keys = ON`);
+        console.log('---');
+        console.log('🎉 Database cleaned successfully');
+    }
+    catch (error) {
+        console.error('❌ Failed to clean database:', error);
+        throw error;
+    }
+}
+// Run the clean function if executed directly
+if (import.meta.url === new URL(import.meta.url).href) {
+    cleanDatabase()
+        .then(() => {
+        console.log('Database cleanup completed');
+        process.exit(0);
+    })
+        .catch((error) => {
+        console.error('Database cleanup failed:', error);
+        process.exit(1);
+    });
+}

package/dist/data/db/dbClient.d.ts

@@ -0,0 +1,3 @@
+declare const dbClient: import("@inkeep/agents-core").DatabaseClient;
+export default dbClient;
+//# sourceMappingURL=dbClient.d.ts.map

package/dist/data/db/dbClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbClient.d.ts","sourceRoot":"","sources":["../../../src/data/db/dbClient.ts"],"names":[],"mappings":"AAcA,QAAA,MAAM,QAAQ,8CAA4C,CAAC;AAC3D,eAAe,QAAQ,CAAC"}

package/dist/data/db/dbClient.js

@@ -0,0 +1,13 @@
+import { env } from '../../env.js';
+import { createDatabaseClient } from '@inkeep/agents-core';
+// Create database URL - use in-memory for tests, file for other environments
+const getDbUrl = () => {
+    // Use in-memory database for tests - each worker gets its own isolated database
+    if (env.ENVIRONMENT === 'test') {
+        return ':memory:';
+    }
+    return env.DB_FILE_NAME;
+};
+// Create the SQLite client
+const dbClient = createDatabaseClient({ url: getDbUrl() });
+export default dbClient;

package/dist/data/graphFull.d.ts

@@ -0,0 +1,11 @@
+import { type FullGraphDefinition } from '@inkeep/agents-core';
+/**
+ * Client-side implementation of createFullGraph that makes HTTP requests to the API endpoint.
+ * This function should be used by client code instead of directly accessing the data layer.
+ */
+export declare const createFullGraph: (tenantId: string, graphData: FullGraphDefinition) => Promise<FullGraphDefinition>;
+/**
+ * Client-side implementation of updateFullGraph that makes HTTP requests to the API endpoint.
+ */
+export declare const updateFullGraph: (tenantId: string, graphId: string, graphData: FullGraphDefinition) => Promise<FullGraphDefinition>;
+//# sourceMappingURL=graphFull.d.ts.map

package/dist/data/graphFull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphFull.d.ts","sourceRoot":"","sources":["../../src/data/graphFull.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,mBAAmB,EAA4B,MAAM,qBAAqB,CAAC;AAIzF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,WAAW,mBAAmB,KAC7B,OAAO,CAAC,mBAAmB,CAkD7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,SAAS,MAAM,EACf,WAAW,mBAAmB,KAC7B,OAAO,CAAC,mBAAmB,CAyD7B,CAAC"}

package/dist/data/graphFull.js

@@ -0,0 +1,90 @@
+import { env } from '../env.js';
+import { getLogger } from '../logger.js';
+import { validateAndTypeGraphData } from '@inkeep/agents-core';
+const logger = getLogger('graphFull');
+/**
+ * Client-side implementation of createFullGraph that makes HTTP requests to the API endpoint.
+ * This function should be used by client code instead of directly accessing the data layer.
+ */
+export const createFullGraph = async (tenantId, graphData) => {
+    logger.info({
+        tenantId,
+        graphId: graphData.id,
+        agentCount: Object.keys(graphData.agents || {}).length,
+    }, 'Creating full graph via API endpoint');
+    try {
+        const baseUrl = env.AGENT_BASE_URL || `http://localhost:${env.PORT}`;
+        const endpoint = `${baseUrl}/tenants/${tenantId}/crud/graph`;
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(graphData),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP error ${response.status}: ${errorText}`);
+        }
+        const result = await response.json();
+        logger.info({
+            tenantId,
+            graphId: graphData.id,
+            status: response.status,
+        }, 'Full graph created successfully via API');
+        return result.data;
+    }
+    catch (error) {
+        logger.error({
+            tenantId,
+            graphId: graphData.id,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        }, 'Failed to create full graph via API');
+        throw error;
+    }
+};
+/**
+ * Client-side implementation of updateFullGraph that makes HTTP requests to the API endpoint.
+ */
+export const updateFullGraph = async (tenantId, graphId, graphData) => {
+    const typed = validateAndTypeGraphData(graphData);
+    // Validate that the graphId matches the data.id
+    if (graphId !== typed.id) {
+        throw new Error(`Graph ID mismatch: expected ${graphId}, got ${typed.id}`);
+    }
+    logger.info({
+        tenantId,
+        graphId,
+        agentCount: Object.keys(graphData.agents || {}).length,
+    }, 'Updating full graph via API endpoint');
+    try {
+        const baseUrl = env.AGENT_BASE_URL || `http://localhost:${env.PORT}`;
+        const endpoint = `${baseUrl}/tenants/${tenantId}/crud/graph/${graphId}`;
+        const response = await fetch(endpoint, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(graphData),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP error ${response.status}: ${errorText}`);
+        }
+        const result = await response.json();
+        logger.info({
+            tenantId,
+            graphId,
+            status: response.status,
+        }, 'Full graph updated successfully via API');
+        return result.data;
+    }
+    catch (error) {
+        logger.error({
+            tenantId,
+            graphId,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        }, 'Failed to update full graph via API');
+        throw error;
+    }
+};

package/dist/data/graphFullClient.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Client-side functions for interacting with the Full Graph API
+ * These functions make HTTP requests to the server instead of direct database calls
+ */
+import type { FullGraphDefinition } from '@inkeep/agents-core';
+/**
+ * Create a full graph via HTTP API
+ */
+export declare function createFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphData: FullGraphDefinition): Promise<FullGraphDefinition>;
+/**
+ * Update a full graph via HTTP API (upsert behavior)
+ */
+export declare function updateFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphId: string, graphData: FullGraphDefinition): Promise<FullGraphDefinition>;
+/**
+ * Get a full graph via HTTP API
+ */
+export declare function getFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphId: string): Promise<FullGraphDefinition | null>;
+/**
+ * Delete a full graph via HTTP API
+ */
+export declare function deleteFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphId: string): Promise<boolean>;
+//# sourceMappingURL=graphFullClient.d.ts.map

package/dist/data/graphFullClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphFullClient.d.ts","sourceRoot":"","sources":["../../src/data/graphFullClient.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAI/D;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CAyD9B;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CAyD9B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA4DrC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CA0DlB"}