@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/graph/types/enums.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Graph Database Enums
+ *
+ * Type definitions for graph database operations
+ * Based on Ductape Graph API documentation
+ */
+/**
+ * Supported graph database types
+ * As documented in overview.md
+ */
+export declare enum GraphType {
+    NEO4J = "neo4j",
+    NEPTUNE = "neptune",
+    ARANGODB = "arangodb",
+    MEMGRAPH = "memgraph"
+}
+/**
+ * Traversal direction for graph queries
+ * As documented in traversals.md
+ */
+export declare enum TraversalDirection {
+    OUTGOING = "OUTGOING",
+    INCOMING = "INCOMING",
+    BOTH = "BOTH"
+}
+/**
+ * Node index types
+ * As documented in overview.md
+ */
+export declare enum NodeIndexType {
+    BTREE = "btree",
+    FULLTEXT = "fulltext",
+    VECTOR = "vector",
+    RANGE = "range",
+    POINT = "point",
+    TEXT = "text"
+}
+/**
+ * Node constraint types
+ * As documented in overview.md
+ */
+export declare enum NodeConstraintType {
+    UNIQUE = "UNIQUE",
+    EXISTS = "EXISTS",
+    NODE_KEY = "NODE_KEY"
+}
+/**
+ * Transaction isolation levels for graph databases
+ * As documented in transactions.md
+ */
+export declare enum GraphIsolationLevel {
+    READ_COMMITTED = "READ_COMMITTED",
+    SERIALIZABLE = "SERIALIZABLE"
+}
+/**
+ * Transaction status
+ */
+export declare enum GraphTransactionStatus {
+    ACTIVE = "active",
+    COMMITTED = "committed",
+    ROLLED_BACK = "rolled_back",
+    FAILED = "failed"
+}
+/**
+ * Error types for graph operations
+ * As documented in overview.md
+ */
+export declare enum GraphErrorType {
+    CONNECTION_ERROR = "CONNECTION_ERROR",
+    QUERY_ERROR = "QUERY_ERROR",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    NOT_FOUND = "NOT_FOUND",
+    CONSTRAINT_ERROR = "CONSTRAINT_ERROR",
+    TRANSACTION_ERROR = "TRANSACTION_ERROR",
+    TIMEOUT_ERROR = "TIMEOUT_ERROR",
+    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
+    CONFIGURATION_ERROR = "CONFIGURATION_ERROR",
+    UNSUPPORTED_OPERATION = "UNSUPPORTED_OPERATION"
+}
+/**
+ * Graph database features (for capability checking)
+ */
+export declare enum GraphFeature {
+    TRANSACTIONS = "transactions",
+    SCHEMA_INDEXES = "schema_indexes",
+    FULL_TEXT_SEARCH = "full_text_search",
+    VECTOR_SEARCH = "vector_search",
+    COMPUTED_PROPERTIES = "computed_properties",
+    TRIGGERS = "triggers",
+    CHANGE_STREAMS = "change_streams",
+    MULTI_TENANCY = "multi_tenancy",
+    GRAPH_ALGORITHMS = "graph_algorithms",
+    GEOSPATIAL = "geospatial"
+}
+/**
+ * Sort order for query results
+ */
+export declare enum GraphSortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}

package/dist/graph/types/enums.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Graph Database Enums
+ *
+ * Type definitions for graph database operations
+ * Based on Ductape Graph API documentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphSortOrder = exports.GraphFeature = exports.GraphErrorType = exports.GraphTransactionStatus = exports.GraphIsolationLevel = exports.NodeConstraintType = exports.NodeIndexType = exports.TraversalDirection = exports.GraphType = void 0;
+/**
+ * Supported graph database types
+ * As documented in overview.md
+ */
+var GraphType;
+(function (GraphType) {
+    GraphType["NEO4J"] = "neo4j";
+    GraphType["NEPTUNE"] = "neptune";
+    GraphType["ARANGODB"] = "arangodb";
+    GraphType["MEMGRAPH"] = "memgraph";
+})(GraphType || (exports.GraphType = GraphType = {}));
+/**
+ * Traversal direction for graph queries
+ * As documented in traversals.md
+ */
+var TraversalDirection;
+(function (TraversalDirection) {
+    TraversalDirection["OUTGOING"] = "OUTGOING";
+    TraversalDirection["INCOMING"] = "INCOMING";
+    TraversalDirection["BOTH"] = "BOTH";
+})(TraversalDirection || (exports.TraversalDirection = TraversalDirection = {}));
+/**
+ * Node index types
+ * As documented in overview.md
+ */
+var NodeIndexType;
+(function (NodeIndexType) {
+    NodeIndexType["BTREE"] = "btree";
+    NodeIndexType["FULLTEXT"] = "fulltext";
+    NodeIndexType["VECTOR"] = "vector";
+    NodeIndexType["RANGE"] = "range";
+    NodeIndexType["POINT"] = "point";
+    NodeIndexType["TEXT"] = "text";
+})(NodeIndexType || (exports.NodeIndexType = NodeIndexType = {}));
+/**
+ * Node constraint types
+ * As documented in overview.md
+ */
+var NodeConstraintType;
+(function (NodeConstraintType) {
+    NodeConstraintType["UNIQUE"] = "UNIQUE";
+    NodeConstraintType["EXISTS"] = "EXISTS";
+    NodeConstraintType["NODE_KEY"] = "NODE_KEY";
+})(NodeConstraintType || (exports.NodeConstraintType = NodeConstraintType = {}));
+/**
+ * Transaction isolation levels for graph databases
+ * As documented in transactions.md
+ */
+var GraphIsolationLevel;
+(function (GraphIsolationLevel) {
+    GraphIsolationLevel["READ_COMMITTED"] = "READ_COMMITTED";
+    GraphIsolationLevel["SERIALIZABLE"] = "SERIALIZABLE";
+})(GraphIsolationLevel || (exports.GraphIsolationLevel = GraphIsolationLevel = {}));
+/**
+ * Transaction status
+ */
+var GraphTransactionStatus;
+(function (GraphTransactionStatus) {
+    GraphTransactionStatus["ACTIVE"] = "active";
+    GraphTransactionStatus["COMMITTED"] = "committed";
+    GraphTransactionStatus["ROLLED_BACK"] = "rolled_back";
+    GraphTransactionStatus["FAILED"] = "failed";
+})(GraphTransactionStatus || (exports.GraphTransactionStatus = GraphTransactionStatus = {}));
+/**
+ * Error types for graph operations
+ * As documented in overview.md
+ */
+var GraphErrorType;
+(function (GraphErrorType) {
+    GraphErrorType["CONNECTION_ERROR"] = "CONNECTION_ERROR";
+    GraphErrorType["QUERY_ERROR"] = "QUERY_ERROR";
+    GraphErrorType["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    GraphErrorType["NOT_FOUND"] = "NOT_FOUND";
+    GraphErrorType["CONSTRAINT_ERROR"] = "CONSTRAINT_ERROR";
+    GraphErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
+    GraphErrorType["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
+    GraphErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+    GraphErrorType["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+    GraphErrorType["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
+})(GraphErrorType || (exports.GraphErrorType = GraphErrorType = {}));
+/**
+ * Graph database features (for capability checking)
+ */
+var GraphFeature;
+(function (GraphFeature) {
+    GraphFeature["TRANSACTIONS"] = "transactions";
+    GraphFeature["SCHEMA_INDEXES"] = "schema_indexes";
+    GraphFeature["FULL_TEXT_SEARCH"] = "full_text_search";
+    GraphFeature["VECTOR_SEARCH"] = "vector_search";
+    GraphFeature["COMPUTED_PROPERTIES"] = "computed_properties";
+    GraphFeature["TRIGGERS"] = "triggers";
+    GraphFeature["CHANGE_STREAMS"] = "change_streams";
+    GraphFeature["MULTI_TENANCY"] = "multi_tenancy";
+    GraphFeature["GRAPH_ALGORITHMS"] = "graph_algorithms";
+    GraphFeature["GEOSPATIAL"] = "geospatial";
+})(GraphFeature || (exports.GraphFeature = GraphFeature = {}));
+/**
+ * Sort order for query results
+ */
+var GraphSortOrder;
+(function (GraphSortOrder) {
+    GraphSortOrder["ASC"] = "asc";
+    GraphSortOrder["DESC"] = "desc";
+})(GraphSortOrder || (exports.GraphSortOrder = GraphSortOrder = {}));
+//# sourceMappingURL=enums.js.map

package/dist/graph/types/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../src/graph/types/enums.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH;;;GAGG;AACH,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,4BAAe,CAAA;IACf,gCAAmB,CAAA;IACnB,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;AACvB,CAAC,EALW,SAAS,yBAAT,SAAS,QAKpB;AAED;;;GAGG;AACH,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,2CAAqB,CAAA;IACrB,2CAAqB,CAAA;IACrB,mCAAa,CAAA;AACf,CAAC,EAJW,kBAAkB,kCAAlB,kBAAkB,QAI7B;AAED;;;GAGG;AACH,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,sCAAqB,CAAA;IACrB,kCAAiB,CAAA;IACjB,gCAAe,CAAA;IACf,gCAAe,CAAA;IACf,8BAAa,CAAA;AACf,CAAC,EAPW,aAAa,6BAAb,aAAa,QAOxB;AAED;;;GAGG;AACH,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;IACjB,uCAAiB,CAAA;IACjB,2CAAqB,CAAA;AACvB,CAAC,EAJW,kBAAkB,kCAAlB,kBAAkB,QAI7B;AAED;;;GAGG;AACH,IAAY,mBAGX;AAHD,WAAY,mBAAmB;IAC7B,wDAAiC,CAAA;IACjC,oDAA6B,CAAA;AAC/B,CAAC,EAHW,mBAAmB,mCAAnB,mBAAmB,QAG9B;AAED;;GAEG;AACH,IAAY,sBAKX;AALD,WAAY,sBAAsB;IAChC,2CAAiB,CAAA;IACjB,iDAAuB,CAAA;IACvB,qDAA2B,CAAA;IAC3B,2CAAiB,CAAA;AACnB,CAAC,EALW,sBAAsB,sCAAtB,sBAAsB,QAKjC;AAED;;;GAGG;AACH,IAAY,cAWX;AAXD,WAAY,cAAc;IACxB,uDAAqC,CAAA;IACrC,6CAA2B,CAAA;IAC3B,uDAAqC,CAAA;IACrC,yCAAuB,CAAA;IACvB,uDAAqC,CAAA;IACrC,yDAAuC,CAAA;IACvC,iDAA+B,CAAA;IAC/B,+DAA6C,CAAA;IAC7C,6DAA2C,CAAA;IAC3C,iEAA+C,CAAA;AACjD,CAAC,EAXW,cAAc,8BAAd,cAAc,QAWzB;AAED;;GAEG;AACH,IAAY,YAWX;AAXD,WAAY,YAAY;IACtB,6CAA6B,CAAA;IAC7B,iDAAiC,CAAA;IACjC,qDAAqC,CAAA;IACrC,+CAA+B,CAAA;IAC/B,2DAA2C,CAAA;IAC3C,qCAAqB,CAAA;IACrB,iDAAiC,CAAA;IACjC,+CAA+B,CAAA;IAC/B,qDAAqC,CAAA;IACrC,yCAAyB,CAAA;AAC3B,CAAC,EAXW,YAAY,4BAAZ,YAAY,QAWvB;AAED;;GAEG;AACH,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,6BAAW,CAAA;IACX,+BAAa,CAAA;AACf,CAAC,EAHW,cAAc,8BAAd,cAAc,QAGzB"}

package/dist/graph/types/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Graph Types Module
+ *
+ * Exports all graph database type definitions
+ */
+export { GraphType, TraversalDirection, NodeIndexType, NodeConstraintType, GraphIsolationLevel, GraphTransactionStatus, GraphErrorType, GraphFeature, GraphSortOrder, } from './enums';
+export { IGraphEnvConfig, IGraphConfig, IGraphConnectionConfig, IGraphConnectionOptions, IGraphConnectionResult, IGraphConnectionContext, IGraphServiceConfig, IGraphTestConnectionResult, } from './connection.interface';
+export { IGraphFilterOperator, IGraphWhereClause, IRawQueryOptions, IRawQueryResult, ICountNodesOptions, ICountNodesResult, ICountRelationshipsOptions, ICountRelationshipsResult, IGraphStatistics, IFullTextSearchOptions, IFullTextSearchResult, IVectorSearchOptions, IVectorSearchResult, } from './query.interface';
+export { NodeProperties, INode, ICreateNodeOptions, ICreateNodeResult, IFindNodesOptions, IGraphOrderBy, IFindNodesResult, IUpdateNodeOptions, INodePropertyUpdate, IUpdateNodeResult, IDeleteNodeOptions, IDeleteNodeResult, IMergeNodeOptions, IMergeNodeResult, INodeFilter, IAddLabelsOptions, IAddLabelsResult, IRemoveLabelsOptions, IRemoveLabelsResult, ISetLabelsOptions, ISetLabelsResult, } from './node.interface';
+export { RelationshipProperties, IRelationship, ICreateRelationshipOptions, ICreateRelationshipResult, IFindRelationshipsOptions, IFindRelationshipsResult, IUpdateRelationshipOptions, IRelationshipPropertyUpdate, IUpdateRelationshipResult, IDeleteRelationshipOptions, IDeleteRelationshipResult, IMergeRelationshipOptions, IMergeRelationshipResult, IRelationshipFilter, ICreateRelationshipIndexOptions, } from './relationship.interface';
+export { IPath, ITraverseOptions, ITraverseResult, IShortestPathOptions, IShortestPathResult, IAllPathsOptions, IAllPathsResult, INeighborhoodOptions, INeighborhoodResult, IConnectedComponentsOptions, IConnectedComponent, IConnectedComponentsResult, } from './traversal.interface';
+export { IGraphTransaction, IGraphTransactionOptions, TransactionCallback, IGraphTransactionResult, } from './transaction.interface';
+export { ICreateNodeIndexOptions, ICreateNodeConstraintOptions, IGraphIndex, IGraphConstraint, IListIndexesResult, IListConstraintsResult, ICreateIndexResult, ICreateConstraintResult, IDropIndexResult, IDropConstraintResult, GraphPropertyType, IGraphLabelProperty, IGraphLabel, IListLabelsResult, IGraphRelationshipType, IListRelationshipTypesResult, GraphActionParameterType, IGraphActionParameter, IGraphAction, ICreateGraphActionOptions, IUpdateGraphActionOptions, IExecuteGraphActionOptions, IExecuteGraphActionResult, IListGraphActionsResult, } from './schema.interface';

package/dist/graph/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Graph Types Module
+ *
+ * Exports all graph database type definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphSortOrder = exports.GraphFeature = exports.GraphErrorType = exports.GraphTransactionStatus = exports.GraphIsolationLevel = exports.NodeConstraintType = exports.NodeIndexType = exports.TraversalDirection = exports.GraphType = void 0;
+// Enums
+var enums_1 = require("./enums");
+Object.defineProperty(exports, "GraphType", { enumerable: true, get: function () { return enums_1.GraphType; } });
+Object.defineProperty(exports, "TraversalDirection", { enumerable: true, get: function () { return enums_1.TraversalDirection; } });
+Object.defineProperty(exports, "NodeIndexType", { enumerable: true, get: function () { return enums_1.NodeIndexType; } });
+Object.defineProperty(exports, "NodeConstraintType", { enumerable: true, get: function () { return enums_1.NodeConstraintType; } });
+Object.defineProperty(exports, "GraphIsolationLevel", { enumerable: true, get: function () { return enums_1.GraphIsolationLevel; } });
+Object.defineProperty(exports, "GraphTransactionStatus", { enumerable: true, get: function () { return enums_1.GraphTransactionStatus; } });
+Object.defineProperty(exports, "GraphErrorType", { enumerable: true, get: function () { return enums_1.GraphErrorType; } });
+Object.defineProperty(exports, "GraphFeature", { enumerable: true, get: function () { return enums_1.GraphFeature; } });
+Object.defineProperty(exports, "GraphSortOrder", { enumerable: true, get: function () { return enums_1.GraphSortOrder; } });
+//# sourceMappingURL=index.js.map

package/dist/graph/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/graph/types/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,QAAQ;AACR,iCAUiB;AATf,kGAAA,SAAS,OAAA;AACT,2GAAA,kBAAkB,OAAA;AAClB,sGAAA,aAAa,OAAA;AACb,2GAAA,kBAAkB,OAAA;AAClB,4GAAA,mBAAmB,OAAA;AACnB,+GAAA,sBAAsB,OAAA;AACtB,uGAAA,cAAc,OAAA;AACd,qGAAA,YAAY,OAAA;AACZ,uGAAA,cAAc,OAAA"}

package/dist/graph/types/node.interface.d.ts

@@ -0,0 +1,248 @@
+/**
+ * Graph Node Interfaces
+ *
+ * Types for node CRUD operations
+ * Based on Ductape Graph API documentation (nodes.md, overview.md)
+ */
+import { IGraphWhereClause } from './query.interface';
+/**
+ * Generic node properties type
+ */
+export type NodeProperties = Record<string, any>;
+/**
+ * Node structure
+ * As documented in nodes.md
+ */
+export interface INode<T = NodeProperties> {
+    /** Database-specific ID */
+    id: string | number;
+    /** Node labels/types */
+    labels: string[];
+    /** Node properties */
+    properties: T;
+    /** Neo4j 5.x element ID */
+    elementId?: string;
+    /** Distance from start node (for traversals) */
+    distance?: number;
+}
+/**
+ * Options for creating a node
+ * As documented in nodes.md
+ */
+export interface ICreateNodeOptions<T = NodeProperties> {
+    /** Node labels (e.g., ['Person', 'User']) */
+    labels: string[];
+    /** Node properties */
+    properties: T;
+}
+/**
+ * Result of creating a node
+ * As documented in nodes.md
+ */
+export interface ICreateNodeResult<T = NodeProperties> {
+    /** The created node */
+    node: INode<T>;
+    /** Always true for create */
+    created: boolean;
+}
+/**
+ * Options for finding nodes
+ * As documented in nodes.md
+ */
+export interface IFindNodesOptions {
+    /** Node labels to filter by */
+    labels?: string[];
+    /** Filter conditions */
+    where?: IGraphWhereClause;
+    /** Maximum number of results */
+    limit?: number;
+    /** Number of results to skip */
+    offset?: number;
+    /** Number of results to skip (alias for offset) */
+    skip?: number;
+    /** Order by properties */
+    orderBy?: IGraphOrderBy[];
+    /** Properties to return (projection) */
+    select?: string[];
+    /** Cache tag for result caching */
+    cache?: string;
+}
+/**
+ * Order by specification
+ */
+export interface IGraphOrderBy {
+    /** Property name */
+    property: string;
+    /** Sort direction */
+    direction: 'asc' | 'desc' | 'ASC' | 'DESC';
+}
+/**
+ * Result of finding nodes
+ * As documented in nodes.md
+ */
+export interface IFindNodesResult<T = NodeProperties> {
+    /** Array of matching nodes */
+    nodes: INode<T>[];
+    /** Total count (for pagination) */
+    count?: number;
+    /** Total count (alias for count) */
+    total?: number;
+}
+/**
+ * Options for updating a node
+ * As documented in nodes.md
+ */
+export interface IUpdateNodeOptions<T = NodeProperties> {
+    /** Node ID to update */
+    id?: string | number;
+    /** Node labels to filter by (for batch update) */
+    labels?: string[];
+    /** Filter conditions (for batch update) */
+    where?: IGraphWhereClause;
+    /** Properties to update */
+    properties: Partial<T> | INodePropertyUpdate;
+}
+/**
+ * Property update operations
+ * As documented in nodes.md
+ */
+export interface INodePropertyUpdate {
+    [key: string]: any | {
+        $INCREMENT: number;
+    } | {
+        $SET: any;
+    } | {
+        $UNSET: boolean;
+    };
+}
+/**
+ * Result of updating a node
+ * As documented in nodes.md
+ */
+export interface IUpdateNodeResult<T = NodeProperties> {
+    /** Updated node (if single update) */
+    node?: INode<T>;
+    /** Updated nodes (if batch update) */
+    nodes?: INode<T>[];
+    /** Number of nodes updated */
+    updatedCount?: number;
+    /** Whether the node was updated */
+    updated?: boolean;
+}
+/**
+ * Options for deleting a node
+ * As documented in nodes.md
+ */
+export interface IDeleteNodeOptions {
+    /** Node ID to delete */
+    id?: string | number;
+    /** Node labels to filter by (for batch delete) */
+    labels?: string[];
+    /** Filter conditions (for batch delete) */
+    where?: IGraphWhereClause;
+    /** Also delete connected relationships */
+    detach?: boolean;
+}
+/**
+ * Result of deleting a node
+ * As documented in nodes.md
+ */
+export interface IDeleteNodeResult {
+    /** Whether deletion succeeded */
+    deleted: boolean;
+    /** Number of nodes deleted */
+    deletedCount?: number;
+    /** ID of deleted node */
+    id?: string | number;
+}
+/**
+ * Options for merge (upsert) operation
+ * As documented in nodes.md
+ */
+export interface IMergeNodeOptions<T = NodeProperties> {
+    /** Node labels */
+    labels: string[];
+    /** Properties to match on */
+    matchProperties: Partial<T>;
+    /** Properties to set if node is created */
+    onCreate?: Partial<T>;
+    /** Properties to set if node already exists */
+    onMatch?: Partial<T> | INodePropertyUpdate;
+}
+/**
+ * Result of merge operation
+ * As documented in nodes.md
+ */
+export interface IMergeNodeResult<T = NodeProperties> {
+    /** The resulting node */
+    node: INode<T>;
+    /** true if created, false if matched */
+    created: boolean;
+    /** Whether the merge operation completed */
+    merged?: boolean;
+}
+/**
+ * Node filter for traversals
+ */
+export interface INodeFilter {
+    /** Labels to filter by */
+    labels?: string[];
+    /** Property filter conditions */
+    where?: IGraphWhereClause;
+}
+/**
+ * Options for adding labels to a node
+ */
+export interface IAddLabelsOptions {
+    /** Node ID */
+    id: string | number;
+    /** Labels to add */
+    labels: string[];
+}
+/**
+ * Result of adding labels
+ */
+export interface IAddLabelsResult<T = NodeProperties> {
+    /** Updated node with new labels */
+    node: INode<T>;
+    /** Labels that were added */
+    addedLabels: string[];
+}
+/**
+ * Options for removing labels from a node
+ */
+export interface IRemoveLabelsOptions {
+    /** Node ID */
+    id: string | number;
+    /** Labels to remove */
+    labels: string[];
+}
+/**
+ * Result of removing labels
+ */
+export interface IRemoveLabelsResult<T = NodeProperties> {
+    /** Updated node without removed labels */
+    node: INode<T>;
+    /** Labels that were removed */
+    removedLabels: string[];
+}
+/**
+ * Options for setting labels on a node (replaces all existing labels)
+ */
+export interface ISetLabelsOptions {
+    /** Node ID */
+    id: string | number;
+    /** New labels to set (replaces existing) */
+    labels: string[];
+}
+/**
+ * Result of setting labels
+ */
+export interface ISetLabelsResult<T = NodeProperties> {
+    /** Updated node with new labels */
+    node: INode<T>;
+    /** Previous labels */
+    previousLabels: string[];
+    /** New labels */
+    newLabels: string[];
+}

package/dist/graph/types/node.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Graph Node Interfaces
+ *
+ * Types for node CRUD operations
+ * Based on Ductape Graph API documentation (nodes.md, overview.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=node.interface.js.map

package/dist/graph/types/node.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.interface.js","sourceRoot":"","sources":["../../../src/graph/types/node.interface.ts"],"names":[],"mappings":";AAAA;;;;;GAKG"}