@trustgraph/react-state 0.2.0

package/dist/state/llm-models.d.ts

@@ -0,0 +1,29 @@
+import { EnumOption } from "../model/llm-models";
+export declare const useLLMModels: () => {
+    parameterTypes: {
+        name: any;
+        type: any;
+        description: any;
+        default: any;
+        enum: any;
+        required: any;
+    }[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error;
+    updateParameter: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        name: string;
+        enum: EnumOption[];
+        default: string;
+    }, unknown>;
+    isUpdating: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        name: any;
+        type: any;
+        description: any;
+        default: any;
+        enum: any;
+        required: any;
+    }[], Error>>;
+};
+//# sourceMappingURL=llm-models.d.ts.map

package/dist/state/llm-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-models.d.ts","sourceRoot":"","sources":["../../src/state/llm-models.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,eAAO,MAAM,YAAY;;;;;;;;;;;;;cA8Cb,MAAM;cACN,UAAU,EAAE;iBACT,MAAM;;;;;;;;;;;CAkDpB,CAAC"}

package/dist/state/load.d.ts

@@ -0,0 +1,33 @@
+/**
+ * State interface for managing document loading and upload operations
+ * Handles file uploads, text input, metadata, and processing operations
+ */
+export interface LoadState {
+    title: string;
+    comments: string;
+    url: string;
+    keywords: string[];
+    operation: string;
+    files: File[];
+    uploaded: string[];
+    text: string;
+    setTitle: (v: string) => void;
+    setComments: (v: string) => void;
+    setUrl: (v: string) => void;
+    setKeywords: (v: string[]) => void;
+    setOperation: (v: string) => void;
+    setFiles: (v: File[]) => void;
+    setUploaded: (v: string[]) => void;
+    setText: (v: string) => void;
+    addUploaded: (v: string) => void;
+    removeFile: (v: File) => void;
+    textUploads: number;
+    setTextUploads: (v: number) => void;
+    incTextUploads: () => void;
+}
+/**
+ * Zustand store for managing document loading state
+ * Provides centralized state management for the document upload/loading workflow
+ */
+export declare const useLoadStateStore: import("zustand").UseBoundStore<import("zustand").StoreApi<LoadState>>;
+//# sourceMappingURL=load.d.ts.map

package/dist/state/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/state/load.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,WAAW,SAAS;IAExB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,EAAE,CAAC;IAGnB,SAAS,EAAE,MAAM,CAAC;IAGlB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IAGb,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAGnC,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAGlC,QAAQ,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;IAC9B,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;IAG9B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,wEA6E3B,CAAC"}

package/dist/state/mcp-tools.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Custom hook for managing MCP tools (create, read, update, delete operations)
+ * Provides CRUD operations for MCP tools stored in the TrustGraph configuration
+ */
+export declare const useMcpTools: () => {
+    tools: any[][];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error;
+    updateTool: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isUpdatingTool: boolean;
+    createTool: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isCreatingTool: boolean;
+    deleteTool: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isDeletingTool: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<any[][], Error>>;
+};
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/state/mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../../src/state/mcp-tools.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;CAiKvB,CAAC"}

package/dist/state/nlp-query.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom hook for managing NLP query operations
+ * Provides functionality for converting natural language questions to GraphQL queries
+ */
+export declare const useNlpQuery: () => {
+    convertQuery: import("@tanstack/react-query").UseMutateFunction<import("@trustgraph/client").NlpQueryResponse, unknown, {
+        question: string;
+        maxResults?: number;
+    }, unknown>;
+    convertQueryAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@trustgraph/client").NlpQueryResponse, unknown, {
+        question: string;
+        maxResults?: number;
+    }, unknown>;
+    isConverting: boolean;
+    error: unknown;
+    data: import("@trustgraph/client").NlpQueryResponse;
+    graphqlQuery: string;
+    variables: Record<string, unknown>;
+    detectedSchemas: Record<string, unknown>[];
+    confidence: number;
+    reset: () => void;
+    isReady: boolean;
+};
+//# sourceMappingURL=nlp-query.d.ts.map

package/dist/state/nlp-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nlp-query.d.ts","sourceRoot":"","sources":["../../src/state/nlp-query.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,eAAO,MAAM,WAAW;;kBAoBR,MAAM;qBACH,MAAM;;;kBADT,MAAM;qBACH,MAAM;;;;;;;;;;;CAmDxB,CAAC"}

package/dist/state/node-details.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Custom hook for managing node details operations
+ * Provides functionality for fetching triples and processing outbound relationships
+ * for a selected graph node
+ * @param nodeId - The ID of the selected node
+ * @param flowId - The flow ID to use for the query
+ * @returns {Object} Node details state and processed data
+ */
+export declare const useNodeDetails: (nodeId: string | undefined, flowId: string) => {
+    outboundTriples: import("@trustgraph/client").Triple[];
+    inboundTriples: import("@trustgraph/client").Triple[];
+    properties: import("@trustgraph/client").Triple[];
+    triplesLoading: boolean;
+    propertiesLoading: boolean;
+    labelsLoading: boolean;
+    isLoading: boolean;
+    outboundTriplesLoading: boolean;
+    inboundTriplesLoading: boolean;
+    propertiesQueryLoading: boolean;
+    outboundLabelsLoading: boolean;
+    inboundLabelsLoading: boolean;
+    propertyLabelsLoading: boolean;
+    triplesError: boolean;
+    propertiesError: boolean;
+    labelsError: boolean;
+    hasError: boolean;
+    outboundTriplesError: boolean;
+    inboundTriplesError: boolean;
+    outboundLabelsError: boolean;
+    inboundLabelsError: boolean;
+    outboundTriplesErrorMessage: Error;
+    inboundTriplesErrorMessage: Error;
+    propertiesErrorMessage: Error;
+    outboundLabelsErrorMessage: Error;
+    inboundLabelsErrorMessage: Error;
+    propertyLabelsErrorMessage: Error;
+    outboundRelationships: string[];
+    inboundRelationships: string[];
+    propertyURIs: string[];
+    outboundRelationshipsWithLabels: {
+        uri: string;
+        label: string;
+    }[];
+    inboundRelationshipsWithLabels: {
+        uri: string;
+        label: string;
+    }[];
+    propertiesWithLabels: {
+        predicate: {
+            uri: string;
+            label: string;
+        };
+        value: string;
+    }[];
+    refetchOutbound: () => void;
+    refetchInbound: () => void;
+    refetchProperties: () => void;
+    refetch: () => void;
+};
+//# sourceMappingURL=node-details.d.ts.map

package/dist/state/node-details.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-details.d.ts","sourceRoot":"","sources":["../../src/state/node-details.ts"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,GAAG,SAAS,EAAE,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAigBxE,CAAC"}

package/dist/state/objects-query.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom hook for managing GraphQL objects queries
+ * Provides functionality for executing GraphQL queries against structured data objects
+ */
+export declare const useObjectsQuery: () => {
+    executeQuery: import("@tanstack/react-query").UseMutateFunction<Record<string, unknown>, unknown, {
+        query: string;
+        collection?: string;
+        variables?: Record<string, unknown>;
+        operationName?: string;
+    }, unknown>;
+    executeQueryAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Record<string, unknown>, unknown, {
+        query: string;
+        collection?: string;
+        variables?: Record<string, unknown>;
+        operationName?: string;
+    }, unknown>;
+    isExecuting: boolean;
+    error: unknown;
+    data: Record<string, unknown>;
+    reset: () => void;
+    isReady: boolean;
+};
+//# sourceMappingURL=objects-query.d.ts.map

package/dist/state/objects-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects-query.d.ts","sourceRoot":"","sources":["../../src/state/objects-query.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,eAAO,MAAM,eAAe;;eAwBf,MAAM;qBACA,MAAM;oBACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;wBACnB,MAAM;;;eAHf,MAAM;qBACA,MAAM;oBACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;wBACnB,MAAM;;;;;;;CA6C3B,CAAC"}

package/dist/state/ontologies.d.ts

@@ -0,0 +1,76 @@
+export interface OntologyMetadata {
+    name: string;
+    description: string;
+    version: string;
+    created: string;
+    modified: string;
+    creator: string;
+    namespace: string;
+    imports?: string[];
+}
+export interface OWLClass {
+    uri: string;
+    type: "owl:Class";
+    "rdfs:label"?: Array<{
+        value: string;
+        lang?: string;
+    }>;
+    "rdfs:comment"?: string;
+    "rdfs:subClassOf"?: string;
+    "owl:equivalentClass"?: string[];
+    "owl:disjointWith"?: string[];
+    "dcterms:identifier"?: string;
+}
+export interface OWLBaseProperty {
+    uri: string;
+    "rdfs:label"?: Array<{
+        value: string;
+        lang?: string;
+    }>;
+    "rdfs:domain"?: string;
+    "rdfs:range"?: string;
+    "rdfs:comment"?: string;
+    "owl:functionalProperty"?: boolean;
+    "owl:minCardinality"?: number;
+    "owl:maxCardinality"?: number;
+    "owl:cardinality"?: number;
+    "rdfs:subPropertyOf"?: string;
+}
+export interface OWLObjectProperty extends OWLBaseProperty {
+    type: "owl:ObjectProperty";
+    "owl:inverseOf"?: string;
+    "owl:inverseFunctionalProperty"?: boolean;
+}
+export interface OWLDatatypeProperty extends OWLBaseProperty {
+    type: "owl:DatatypeProperty";
+}
+export interface Ontology {
+    metadata: OntologyMetadata;
+    classes: Record<string, OWLClass>;
+    objectProperties: Record<string, OWLObjectProperty>;
+    datatypeProperties: Record<string, OWLDatatypeProperty>;
+}
+export declare const useOntologies: () => {
+    ontologies: any[][];
+    ontologiesLoading: boolean;
+    ontologiesError: Error;
+    updateOntology: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        id: string;
+        ontology: Ontology;
+        onSuccess?: () => void;
+    }, unknown>;
+    isUpdatingOntology: boolean;
+    createOntology: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        id: string;
+        ontology: Ontology;
+        onSuccess?: () => void;
+    }, unknown>;
+    isCreatingOntology: boolean;
+    deleteOntology: import("@tanstack/react-query").UseMutateFunction<void, Error, {
+        id: string;
+        onSuccess?: () => void;
+    }, unknown>;
+    isDeletingOntology: boolean;
+    refetch: () => void;
+};
+//# sourceMappingURL=ontologies.d.ts.map

package/dist/state/ontologies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ontologies.d.ts","sourceRoot":"","sources":["../../src/state/ontologies.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,WAAW,CAAC;IAClB,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+BAA+B,CAAC,EAAE,OAAO,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,IAAI,EAAE,sBAAsB,CAAC;CAC9B;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACpD,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CACzD;AAED,eAAO,MAAM,aAAa;;;;;YAkChB,MAAM;kBACA,QAAQ;oBACN,MAAM,IAAI;;;;YAmClB,MAAM;kBACA,QAAQ;oBACN,MAAM,IAAI;;;;YAkClB,MAAM;oBACE,MAAM,IAAI;;;;CAmD3B,CAAC"}

package/dist/state/processing.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Custom hook for managing processing operations
+ * Provides functionality for fetching, deleting, and creating processing
+ * @returns {Object} Processing state and operations
+ */
+export declare const useProcessing: () => {
+    processing: any[] | import("@trustgraph/client").ProcessingMetadata;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<any[] | import("@trustgraph/client").ProcessingMetadata, Error>>;
+};
+//# sourceMappingURL=processing.d.ts.map

package/dist/state/processing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing.d.ts","sourceRoot":"","sources":["../../src/state/processing.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;CAsCzB,CAAC"}

package/dist/state/progress.d.ts

@@ -0,0 +1,9 @@
+export interface ProgressState {
+    activity: Set<string>;
+    error: string;
+    addActivity: (act: string) => void;
+    removeActivity: (act: string) => void;
+    setError: (error: string) => void;
+}
+export declare const useProgressStateStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ProgressState>>;
+//# sourceMappingURL=progress.d.ts.map

package/dist/state/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/state/progress.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAG5B,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAGtB,KAAK,EAAE,MAAM,CAAC;IAGd,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAGnC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAGtC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAID,eAAO,MAAM,qBAAqB,4EAqC/B,CAAC"}

package/dist/state/prompts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Custom hook for managing AI prompts (system prompt and prompt templates)
+ * Provides CRUD operations for both the system prompt and user-defined prompt templates
+ */
+export declare const usePrompts: () => {
+    systemPrompt: any;
+    systemPromptLoading: boolean;
+    systemPromptError: Error;
+    prompts: any;
+    promptsLoading: boolean;
+    promptsError: Error;
+    updateSystemPrompt: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isUpdatingSystemPrompt: boolean;
+    updatePrompt: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isUpdatingPrompt: boolean;
+    createPrompt: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isCreatingPrompt: boolean;
+    deletePrompt: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isDeletingPrompt: boolean;
+    refetch: () => void;
+};
+//# sourceMappingURL=prompts.d.ts.map

package/dist/state/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/state/prompts.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;CAqRtB,CAAC"}

package/dist/state/schemas.d.ts

@@ -0,0 +1,13 @@
+export declare const useSchemas: () => {
+    schemas: any[][];
+    schemasLoading: boolean;
+    schemasError: Error;
+    updateSchema: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isUpdatingSchema: boolean;
+    createSchema: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isCreatingSchema: boolean;
+    deleteSchema: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isDeletingSchema: boolean;
+    refetch: () => void;
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/state/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/state/schemas.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,UAAU;;;;;;;;;;;CAyItB,CAAC"}

package/dist/state/search.d.ts

@@ -0,0 +1,9 @@
+import { Row } from "../utils/row";
+export interface SearchState {
+    rows: Row[];
+    setRows: (v: Row[]) => void;
+    input: string;
+    setInput: (v: string) => void;
+}
+export declare const useSearchStateStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SearchState>>;
+//# sourceMappingURL=search.d.ts.map

package/dist/state/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/state/search.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGnC,MAAM,WAAW,WAAW;IAE1B,IAAI,EAAE,GAAG,EAAE,CAAC;IAGZ,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IAG5B,KAAK,EAAE,MAAM,CAAC;IAGd,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/B;AAGD,eAAO,MAAM,mBAAmB,0EAiB7B,CAAC"}

package/dist/state/session.d.ts

@@ -0,0 +1,9 @@
+export interface SessionState {
+    flowId: string;
+    flow: string | null;
+    flowDescription: string;
+    setFlowId: (v: string) => void;
+    setFlow: (v: string) => void;
+}
+export declare const useSessionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SessionState>>;
+//# sourceMappingURL=session.d.ts.map

package/dist/state/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/state/session.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAE3B,MAAM,EAAE,MAAM,CAAC;IAGf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAGpB,eAAe,EAAE,MAAM,CAAC;IAGxB,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAG/B,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAGD,eAAO,MAAM,eAAe,2EAczB,CAAC"}

package/dist/state/settings.d.ts

@@ -0,0 +1,21 @@
+import { Settings } from "../model/settings-types";
+/**
+ * Custom hook for managing application settings
+ * Uses TanStack Query for consistent async patterns while storing in localStorage
+ * Ready for future backend integration when needed
+ */
+export declare const useSettings: () => {
+    settings: Settings;
+    isLoaded: boolean;
+    isLoading: boolean;
+    error: Error;
+    updateSetting: (path: string, value: unknown) => void;
+    saveSettings: (newSettings: Settings) => void;
+    resetSettings: () => void;
+    exportSettings: () => string;
+    importSettings: (jsonString: string) => void;
+    isSaving: boolean;
+    isResetting: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<Settings, Error>>;
+};
+//# sourceMappingURL=settings.d.ts.map

package/dist/state/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/state/settings.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAGT,MAAM,yBAAyB,CAAC;AAoDjC;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;0BAwGO,MAAM,SAAS,OAAO;gCAKhB,QAAQ;;0BAahB,MAAM;iCAKG,MAAM;;;;CAiC3C,CAAC"}

package/dist/state/structured-query.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom hook for managing structured query operations
+ * Provides functionality for executing natural language questions against structured data
+ * Combines NLP query conversion and GraphQL execution in a single operation
+ */
+export declare const useStructuredQuery: () => {
+    executeQuery: import("@tanstack/react-query").UseMutateFunction<Record<string, unknown>, Error, {
+        question: string;
+        collection?: string;
+    }, unknown>;
+    executeQueryAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Record<string, unknown>, Error, {
+        question: string;
+        collection?: string;
+    }, unknown>;
+    isExecuting: boolean;
+    error: Error;
+    data: Record<string, unknown>;
+    queryData: unknown;
+    queryErrors: unknown;
+    hasErrors: boolean;
+    reset: () => void;
+    isReady: boolean;
+};
+//# sourceMappingURL=structured-query.d.ts.map

package/dist/state/structured-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-query.d.ts","sourceRoot":"","sources":["../../src/state/structured-query.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;kBAsBf,MAAM;qBACH,MAAM;;;kBADT,MAAM;qBACH,MAAM;;;;;;;;;;CAwDxB,CAAC"}

package/dist/state/token-costs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Custom hook for managing token cost operations
+ * Provides functionality for fetching, deleting, and updating token costs
+ * for AI models
+ * @returns {Object} Token cost state and operations
+ */
+export declare const useTokenCosts: () => {
+    tokenCosts: {
+        model: unknown;
+        input_price: number;
+        output_price: number;
+    }[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error;
+    deleteTokenCosts: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isDeleting: boolean;
+    deleteError: Error;
+    updateTokenCost: import("@tanstack/react-query").UseMutateFunction<void, Error, void, unknown>;
+    isSubmitting: boolean;
+    submitError: Error;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        model: unknown;
+        input_price: number;
+        output_price: number;
+    }[], Error>>;
+};
+//# sourceMappingURL=token-costs.d.ts.map

package/dist/state/token-costs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-costs.d.ts","sourceRoot":"","sources":["../../src/state/token-costs.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;CAgJzB,CAAC"}

package/dist/state/triples.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Custom hook for managing token cost operations
+ * Provides functionality for fetching, deleting, and updating token costs
+ * for AI models
+ * @returns {Object} Token cost state and operations
+ */
+export declare const useTriples: ({ flow, s, p, o, limit, collection }: {
+    flow: any;
+    s: any;
+    p: any;
+    o: any;
+    limit: any;
+    collection: any;
+}) => {
+    triples: void | import("@trustgraph/client").Triple[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<void | import("@trustgraph/client").Triple[], Error>>;
+};
+//# sourceMappingURL=triples.d.ts.map

package/dist/state/triples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triples.d.ts","sourceRoot":"","sources":["../../src/state/triples.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI;;;;;;;CAAoC;;;;;;CAkD9D,CAAC"}

package/dist/state/vector-search.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Custom hook for managing vector search operations
+ * Provides functionality for searching entities using vector embeddings
+ * @returns {Object} Vector search state and operations
+ */
+export declare const useVectorSearch: () => {
+    startSearch: ({ flow, term, limit, collection }: {
+        flow: any;
+        term: any;
+        limit: any;
+        collection: any;
+    }) => void;
+    data: any;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error;
+    searchParams: any;
+};
+//# sourceMappingURL=vector-search.d.ts.map

package/dist/state/vector-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-search.d.ts","sourceRoot":"","sources":["../../src/state/vector-search.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;CAsE3B,CAAC"}

package/dist/state/workbench.d.ts

@@ -0,0 +1,20 @@
+import { Entity } from "../model/entity";
+/**
+ * State interface for the main workbench/workspace application
+ * Manages the current tool selection, entity selection, and available entities
+ */
+export interface WorkbenchState {
+    selected?: Entity;
+    tool: string;
+    entities: Entity[];
+    setSelected: (e: Entity) => void;
+    unsetSelected: () => void;
+    setTool: (v: string) => void;
+    setEntities: (ents: Entity[]) => void;
+}
+/**
+ * Zustand store for managing the main workbench application state
+ * Provides centralized state management for tool navigation and entity selection
+ */
+export declare const useWorkbenchStateStore: import("zustand").UseBoundStore<import("zustand").StoreApi<WorkbenchState>>;
+//# sourceMappingURL=workbench.d.ts.map

package/dist/state/workbench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench.d.ts","sourceRoot":"","sources":["../../src/state/workbench.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,cAAc;IAE7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,IAAI,EAAE,MAAM,CAAC;IAEb,QAAQ,EAAE,MAAM,EAAE,CAAC;IAGnB,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,aAAa,EAAE,MAAM,IAAI,CAAC;IAG1B,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAG7B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CACvC;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,6EA+BhC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Interface for notification handlers
+ * Applications can implement this interface to integrate their own toast/notification UI
+ */
+export interface NotificationHandler {
+    /**
+     * Display a success notification
+     * @param message - The success message to display
+     */
+    success: (message: string) => void;
+    /**
+     * Display an error notification
+     * @param message - The error message to display
+     */
+    error: (message: string) => void;
+    /**
+     * Display a warning notification
+     * @param message - The warning message to display
+     */
+    warning: (message: string) => void;
+    /**
+     * Display an informational notification
+     * @param message - The informational message to display
+     */
+    info: (message: string) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnC;;;OAGG;IACH,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEjC;;;OAGG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnC;;;OAGG;IACH,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC"}

package/dist/utils/document-encoding.d.ts

@@ -0,0 +1,23 @@
+/**
+ * textToBase64 using TextEncoder
+ */
+export declare const textToBase64: (input: any) => string;
+/**
+ * Converts a text string to Base64 encoding with proper UTF-8 handling
+ *
+ * WHY THIS LOOKS WEIRD:
+ * FileReader.readAsDataURL() returns a data URL like
+ * "data:image/png;base64,iVBORw0KGgoA..."
+ * but we only want the Base64 part. The regex removes the "data:" prefix
+ * and everything up to the comma, leaving just the Base64 data.
+ *
+ * ISSUES WITH CURRENT IMPLEMENTATION:
+ * - Type assertion (as string) is unsafe - reader.result could be ArrayBuffer
+ * - No error handling for failed file reads
+ * - Regex is overly complex for simple string removal
+ *
+ * @param {File} file - The file to convert to Base64
+ * @returns {Promise<string>} Promise that resolves to Base64 string
+ */
+export declare const fileToBase64: (file: any) => Promise<unknown>;
+//# sourceMappingURL=document-encoding.d.ts.map

package/dist/utils/document-encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-encoding.d.ts","sourceRoot":"","sources":["../../src/utils/document-encoding.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,UAAK,WAUjC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,GAAI,SAAI,qBAgBhC,CAAC"}