@burdenoff/be-sdk 2026.510.79

package/dist/index-BS2idbnr.d.ts

@@ -0,0 +1,874 @@
+import { B as BurdenoffGraphQLClient } from './graphql-BAVrUgBF.js';
+import { S as SDKContext } from './index-CHbVw5M7.js';
+import { P as PrismaClientBase } from './client-CSjIrYKS.js';
+import { N as NatsGraphEventEmitter, E as EntityEventRbacMetadata } from './graph-emitter-Bk0FqD53.js';
+import { G as GraphEventEmitter, E as EntityEventType, a as GraphMiddlewareConfig, b as addGraphExtension } from './prisma-extension-krXnYnrN.js';
+
+type GraphEventType = 'entity.created' | 'entity.updated' | 'entity.deleted' | 'relationship.created' | 'relationship.updated' | 'relationship.deleted';
+interface GraphEvent {
+    eventId: string;
+    eventType: GraphEventType;
+    organizationId: string;
+    productSource: string;
+    timestamp: string;
+    entity: {
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+    };
+    relationship?: {
+        from: {
+            id: string;
+            type: string;
+        };
+        to: {
+            id: string;
+            type: string;
+        };
+        type: string;
+        metadata: Record<string, unknown>;
+    };
+    metadata: {
+        userId?: string;
+        correlationId: string;
+        causedBy?: string;
+        retryCount?: number;
+    };
+}
+interface EntityVertex {
+    _key: string;
+    _id?: string;
+    organizationId: string;
+    workspaceId?: string;
+    projectId?: string;
+    productSource: string;
+    entityType: string;
+    entityId: string;
+    title?: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+    isPlaceholder?: boolean;
+}
+interface EdgeDocument {
+    _key?: string;
+    _from: string;
+    _to: string;
+    organizationId: string;
+    productSource: string;
+    createdAt: string;
+    updatedAt: string;
+    isActive?: boolean;
+    deletedAt?: string;
+    [key: string]: unknown;
+}
+interface RegistryEntityRbacConfig {
+    resourceTypeName: string;
+    extractName?: (data: Record<string, unknown>) => string | undefined;
+    extractIdentifier?: (data: Record<string, unknown>) => string | undefined;
+    parentResourceField?: string;
+    createResource?: boolean;
+}
+interface EntityGraphConfig {
+    fields?: string[];
+    collection?: string;
+    extractTitle?: (entity: Record<string, unknown>) => string;
+    enabled?: boolean;
+    rbac?: RegistryEntityRbacConfig;
+}
+interface RelationshipGraphConfig {
+    from: string;
+    fromField: string;
+    to: string;
+    toField?: string;
+    label: string;
+    description?: string;
+    extractMetadata?: (record: Record<string, unknown>) => Record<string, unknown>;
+    polymorphicTypeField?: string;
+    enabled?: boolean;
+}
+interface ModuleGraphConfig {
+    moduleName: string;
+    entities: Record<string, EntityGraphConfig>;
+    relationships?: Record<string, RelationshipGraphConfig>;
+}
+interface SearchFilters {
+    productSources?: string[];
+    entityTypes?: string[];
+    dateRange?: {
+        from?: string;
+        to?: string;
+    };
+    metadataFilters?: {
+        field: string;
+        operator: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'in';
+        value: unknown;
+    }[];
+    limit?: number;
+    offset?: number;
+}
+interface SearchResult {
+    id: string;
+    type: string;
+    productSource: string;
+    title: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    score: number;
+    highlights?: string[];
+    url: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface ProductFacet {
+    product: string;
+    count: number;
+}
+interface TypeFacet {
+    type: string;
+    count: number;
+}
+interface SearchFacets {
+    byProduct: ProductFacet[];
+    byType: TypeFacet[];
+}
+interface SearchResponse {
+    entities: SearchResult[];
+    total: number;
+    hasMore: boolean;
+    facets: SearchFacets;
+}
+
+interface ResolvedEntityGraphConfig extends Omit<EntityGraphConfig, 'fields'> {
+    fields: string[];
+    getOrgId?: (data: Record<string, unknown>) => string | undefined;
+    getWorkspaceId?: (data: Record<string, unknown>) => string | undefined;
+    rbac?: RegistryEntityRbacConfig;
+}
+declare class GraphRegistry {
+    private static entityMappings;
+    private static relationshipMappings;
+    private static registeredModules;
+    private static resolveFields;
+    static registerModule(config: ModuleGraphConfig): void;
+    static getEntityConfig(entityType: string): ResolvedEntityGraphConfig | undefined;
+    static getRelationshipConfig(relationshipType: string): RelationshipGraphConfig | undefined;
+    static getAllEntityTypes(): string[];
+    static getAllRelationshipTypes(): string[];
+    static getRegisteredModules(): string[];
+    static isEntityRegistered(entityType: string): boolean;
+    static isRelationshipRegistered(relationshipType: string): boolean;
+    static getOrganizationId(entityType: string, data: Record<string, unknown>): string | undefined;
+    static getWorkspaceId(entityType: string, data: Record<string, unknown>): string | undefined;
+    static getRbacConfig(entityType: string): RegistryEntityRbacConfig | undefined;
+    static resolveRbacMetadata(entityType: string, entityData: Record<string, unknown>): {
+        resourceTypeName: string;
+        name?: string;
+        identifier?: string;
+        parentResourceIdentifier?: string;
+        createResource?: boolean;
+    } | undefined;
+    static getStats(): {
+        modules: number;
+        entities: number;
+        relationships: number;
+        collections: Set<string>;
+        edgeTypes: Set<string>;
+    };
+    static clear(): void;
+    static getRelationshipsForEntity(entityType: string): Array<[string, RelationshipGraphConfig]>;
+    static printStatus(): void;
+}
+
+declare function createEntityEvent(eventType: GraphEventType, organizationId: string, entity: {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+}, metadata?: {
+    userId?: string;
+    correlationId?: string;
+    workspaceId?: string;
+    projectId?: string;
+}, productSource?: string): GraphEvent;
+declare function createRelationshipEvent(eventType: GraphEventType, organizationId: string, relationship: {
+    from: {
+        id: string;
+        type: string;
+    };
+    to: {
+        id: string;
+        type: string;
+    };
+    type: string;
+    metadata: Record<string, unknown>;
+}, metadata?: {
+    userId?: string;
+    correlationId?: string;
+}, productSource?: string): GraphEvent;
+declare function extractMinimalFields(modelName: string, entity: Record<string, unknown>): Record<string, unknown>;
+declare function parseRelationship(modelName: string, relationship: Record<string, unknown>): {
+    from: {
+        id: string;
+        type: string;
+    };
+    to: {
+        id: string;
+        type: string;
+    };
+    relationshipType: string;
+    metadata: Record<string, unknown>;
+};
+declare function getCollectionForEntity(entityType: string): string;
+declare function extractEntityTitle(entityType: string, entity: Record<string, unknown>): string;
+declare function shouldSyncEntity(entityType: string): boolean;
+declare function shouldSyncRelationship(relationshipType: string): boolean;
+
+type FieldMapper<T = string> = (data: Record<string, unknown>) => T | undefined;
+interface EntityRbacConfig$1 {
+    resourceTypeName: string;
+    extractName?: (data: Record<string, unknown>) => string | undefined;
+    extractIdentifier?: (data: Record<string, unknown>) => string | undefined;
+    parentResourceField?: string;
+    createResource?: boolean;
+}
+interface GenericEntityConfig {
+    collection?: string;
+    fields: string[];
+    getWorkspaceId: FieldMapper<string>;
+    getOrgId: FieldMapper<string>;
+    getProjectId?: FieldMapper<string>;
+    extractTitle?: FieldMapper<string>;
+    enabled?: boolean;
+    rbac?: EntityRbacConfig$1;
+}
+interface GenericRelationshipConfig {
+    from: string;
+    to: string;
+    fromField: string;
+    toField?: string;
+    label: string;
+    description?: string;
+    extractMetadata?: (record: Record<string, unknown>) => Record<string, unknown>;
+    polymorphicTypeField?: string;
+    enabled?: boolean;
+}
+interface GenericGraphConfig {
+    moduleName: string;
+    entities: Record<string, GenericEntityConfig>;
+    relationships?: Record<string, GenericRelationshipConfig>;
+}
+type ValidationErrorType = 'MISSING_WORKSPACE_ID' | 'MISSING_ORG_ID' | 'ORPHANED_ENTITY' | 'INVALID_ENTITY_TYPE' | 'INVALID_RELATIONSHIP' | 'DUPLICATE_ENTITY_TYPE' | 'DUPLICATE_RELATIONSHIP_LABEL' | 'CIRCULAR_DEPENDENCY';
+interface GraphValidationError {
+    type: ValidationErrorType;
+    entityType?: string;
+    relationshipKey?: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+interface GraphValidationResult {
+    valid: boolean;
+    errors: GraphValidationError[];
+    warnings: string[];
+}
+interface ExtractedEntityData {
+    id: string;
+    type: string;
+    workspaceId: string;
+    organizationId: string;
+    projectId?: string;
+    title: string;
+    fields: Record<string, unknown>;
+}
+interface ExtractedRelationshipData {
+    from: {
+        id: string;
+        type: string;
+    };
+    to: {
+        id: string;
+        type: string;
+    };
+    label: string;
+    metadata?: Record<string, unknown>;
+}
+
+interface PrismaGraphIntegrationOptions<TPrismaClient = unknown> {
+    serviceName: string;
+    graphConfig: GenericGraphConfig;
+    productName?: string;
+    validateRuntime?: boolean;
+    autoInit?: boolean;
+    createPrismaClient: () => TPrismaClient;
+}
+declare function createPrismaGraphIntegration<TPrismaClient extends PrismaClientBase>(options: PrismaGraphIntegrationOptions<TPrismaClient>): {
+    initializeGraphEmitter: () => Promise<void>;
+    db: () => {
+        client: TPrismaClient;
+    };
+    prisma: TPrismaClient;
+    cleanup: () => Promise<void>;
+    getGraphEmitter: () => NatsGraphEventEmitter | null;
+    isInitialized: () => boolean;
+};
+type PrismaGraphIntegration<TPrismaClient extends PrismaClientBase> = ReturnType<typeof createPrismaGraphIntegration<TPrismaClient>>;
+
+interface GraphEventPublishOptions {
+    userId?: string;
+    correlationId?: string;
+}
+interface GraphRelationshipData {
+    from: {
+        id: string;
+        type: string;
+    };
+    to: {
+        id: string;
+        type: string;
+    };
+    relationType: string;
+    metadata?: Record<string, unknown>;
+}
+interface GraphEntityConfig {
+    type: string;
+    getOrgId?: (data: Record<string, unknown>) => string | undefined;
+    getWorkspaceId?: (data: Record<string, unknown>) => string | undefined;
+    onCreated?: (data: Record<string, unknown>, publisher: GraphEventsPublisher, options?: GraphEventPublishOptions) => Promise<void>;
+    onUpdated?: (data: Record<string, unknown>, publisher: GraphEventsPublisher, options?: GraphEventPublishOptions) => Promise<void>;
+    onDeleted?: (data: Record<string, unknown>, publisher: GraphEventsPublisher, options?: GraphEventPublishOptions) => Promise<void>;
+}
+interface GraphEventsHelperConfig {
+    moduleName: string;
+    entities: Record<string, GraphEntityConfig>;
+}
+interface EntityEventData {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    organizationId?: string;
+    workspaceId?: string;
+}
+declare class GraphEventsPublisher {
+    private static instance;
+    private productName;
+    private initialized;
+    private emitter;
+    constructor(productName?: string);
+    static getInstance(productName?: string): GraphEventsPublisher;
+    setProductName(name: string): void;
+    initialize(): Promise<void>;
+    private ensureInitialized;
+    publishEntityCreated(entity: EntityEventData, options?: GraphEventPublishOptions): Promise<void>;
+    publishEntityUpdated(entity: EntityEventData, options?: GraphEventPublishOptions): Promise<void>;
+    publishEntityDeleted(entity: EntityEventData, options?: GraphEventPublishOptions): Promise<void>;
+    publishRelationshipCreated(relationship: GraphRelationshipData, organizationId: string, options?: GraphEventPublishOptions): Promise<void>;
+    publishRelationshipDeleted(relationship: GraphRelationshipData, organizationId: string, options?: GraphEventPublishOptions): Promise<void>;
+    private publishEntityEvent;
+    private publishRelationshipEvent;
+    shutdown(): Promise<void>;
+    static reset(): void;
+}
+declare function getGraphEventsPublisher(productName?: string): GraphEventsPublisher;
+type EntityEventHandler = (data: Record<string, unknown>, options?: GraphEventPublishOptions) => Promise<void>;
+interface EntityEvents {
+    created: EntityEventHandler;
+    updated: EntityEventHandler;
+    deleted: EntityEventHandler;
+}
+type GraphEventsHelper = Record<string, EntityEvents>;
+declare function createGraphEventsHelper(config: GraphEventsHelperConfig): GraphEventsHelper;
+
+interface GraphEntityExport {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    organizationId?: string;
+    workspaceId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GraphRelationshipExport {
+    id: string;
+    type: string;
+    fromId: string;
+    fromType: string;
+    toId: string;
+    toType: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GraphExportResponse {
+    moduleName: string;
+    productSource: string;
+    exportedAt: string;
+    schema: {
+        entities: Record<string, {
+            fields: string[];
+            collection: string;
+        }>;
+        relationships: Record<string, {
+            from: string;
+            fromType: string;
+            to: string;
+            toType: string;
+            edgeType: string;
+        }>;
+    };
+    data: {
+        entities: Record<string, GraphEntityExport[]>;
+        relationships: GraphRelationshipExport[];
+    };
+    stats: {
+        totalEntities: number;
+        totalRelationships: number;
+        entityCounts: Record<string, number>;
+    };
+}
+type EntityFetcher$1<T = Record<string, unknown>> = (organizationId?: string, workspaceId?: string) => Promise<T[]>;
+type RelationshipFetcher$1 = (organizationId?: string, workspaceId?: string) => Promise<GraphRelationshipExport[]>;
+interface GraphExportServiceConfig {
+    moduleName: string;
+    config: ModuleGraphConfig;
+    fetchers: Record<string, EntityFetcher$1>;
+    relationshipFetchers?: Record<string, RelationshipFetcher$1>;
+    transformEntity?: (type: string, item: Record<string, unknown>) => GraphEntityExport;
+}
+declare class GraphExportService {
+    private readonly moduleName;
+    private readonly config;
+    private readonly fetchers;
+    private readonly relationshipFetchers;
+    private readonly customTransformer?;
+    constructor(serviceConfig: GraphExportServiceConfig);
+    getSchema(): {
+        moduleName: string;
+        entities: Record<string, {
+            fields: string[];
+            collection: string;
+        }>;
+        relationships: Record<string, {
+            from: string;
+            fromType: string;
+            to: string;
+            toType: string;
+            edgeType: string;
+        }>;
+    };
+    exportEntities(organizationId?: string, workspaceId?: string, entityTypes?: string[]): Promise<Record<string, GraphEntityExport[]>>;
+    exportRelationships(organizationId?: string, workspaceId?: string): Promise<GraphRelationshipExport[]>;
+    exportAll(organizationId?: string, workspaceId?: string): Promise<GraphExportResponse>;
+    private transformEntity;
+}
+declare function createGraphExportService(config: GraphExportServiceConfig): GraphExportService;
+declare function createRelationshipFromEntity(entity: Record<string, unknown>, relationConfig: RelationshipGraphConfig, relationType: string): GraphRelationshipExport | null;
+
+interface GraphEventOptions {
+    actorId?: string;
+    correlationId?: string;
+}
+interface RelationshipEventData {
+    from: {
+        id: string;
+        type: string;
+    };
+    to: {
+        id: string;
+        type: string;
+    };
+    relationType: string;
+    metadata?: Record<string, unknown>;
+}
+interface EntityEventContext {
+    publishRelationship: (data: RelationshipEventData, orgId?: string) => Promise<void>;
+    deleteRelationship: (data: RelationshipEventData, orgId?: string) => Promise<void>;
+    getOrgId: (data: Record<string, unknown>) => string | undefined;
+    getWorkspaceId: (data: Record<string, unknown>) => string | undefined;
+}
+type EntityEventHook = (data: Record<string, unknown>, ctx: EntityEventContext, options?: GraphEventOptions) => Promise<void>;
+type EntityFetcher<T = Record<string, unknown>> = (organizationId?: string, workspaceId?: string) => Promise<T[]>;
+interface RelationshipExportData {
+    id: string;
+    fromId: string;
+    toId: string;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+type RelationshipFetcher = (organizationId?: string, workspaceId?: string) => Promise<RelationshipExportData[]>;
+interface EntityRbacConfig {
+    resourceTypeName: string;
+    extractName?: (data: Record<string, unknown>) => string | undefined;
+    extractIdentifier?: (data: Record<string, unknown>) => string | undefined;
+    parentResourceField?: string;
+    createResource?: boolean;
+}
+interface EntityDefinition<T = Record<string, unknown>> {
+    type: string;
+    fields?: string[];
+    collection?: string;
+    getOrgId?: (data: Record<string, unknown>) => string | undefined;
+    getWorkspaceId?: (data: Record<string, unknown>) => string | undefined;
+    onCreated?: EntityEventHook;
+    onUpdated?: EntityEventHook;
+    onDeleted?: EntityEventHook;
+    fetch?: EntityFetcher<T>;
+    rbac?: EntityRbacConfig;
+}
+interface RelationshipDefinition {
+    fromType: string;
+    toType: string;
+    edgeType: string;
+    extractMetadata?: (record: Record<string, unknown>) => Record<string, unknown>;
+    fetch?: RelationshipFetcher;
+}
+interface ModuleGraphDefinition {
+    moduleName: string;
+    productSource?: string;
+    entities: Record<string, EntityDefinition>;
+    relationships?: Record<string, RelationshipDefinition>;
+}
+interface EntityEventMethods {
+    created: (data: Record<string, unknown>, options?: GraphEventOptions) => Promise<void>;
+    updated: (data: Record<string, unknown>, options?: GraphEventOptions) => Promise<void>;
+    deleted: (data: Record<string, unknown>, options?: GraphEventOptions) => Promise<void>;
+}
+interface EntityExport {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    organizationId?: string;
+    workspaceId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RelationshipExport {
+    id: string;
+    type: string;
+    fromId: string;
+    fromType: string;
+    toId: string;
+    toType: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GraphSchema {
+    moduleName: string;
+    entities: Record<string, {
+        fields: string[];
+        collection: string;
+    }>;
+    relationships: Record<string, {
+        fromType: string;
+        toType: string;
+        edgeType: string;
+    }>;
+}
+interface ExportResponse {
+    moduleName: string;
+    productSource: string;
+    exportedAt: string;
+    schema: GraphSchema;
+    data: {
+        entities: Record<string, EntityExport[]>;
+        relationships: RelationshipExport[];
+    };
+    stats: {
+        totalEntities: number;
+        totalRelationships: number;
+        entityCounts: Record<string, number>;
+    };
+}
+interface ModuleGraph {
+    readonly moduleName: string;
+    readonly events: Record<string, EntityEventMethods>;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    getSchema(): GraphSchema;
+    exportEntities(organizationId?: string, workspaceId?: string, entityTypes?: string[]): Promise<Record<string, EntityExport[]>>;
+    exportRelationships(organizationId?: string, workspaceId?: string): Promise<RelationshipExport[]>;
+    exportAll(organizationId?: string, workspaceId?: string): Promise<ExportResponse>;
+    getPublisher(): GraphEventsPublisherInternal;
+}
+declare class GraphEventsPublisherInternal {
+    private productName;
+    private initialized;
+    private emitter;
+    constructor(productName: string);
+    initialize(): Promise<void>;
+    private ensureInitialized;
+    publishEntityCreated(entity: {
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+        organizationId?: string;
+        workspaceId?: string;
+    }, options?: GraphEventOptions, rbac?: EntityEventRbacMetadata): Promise<void>;
+    publishEntityUpdated(entity: {
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+        organizationId?: string;
+        workspaceId?: string;
+    }, options?: GraphEventOptions, rbac?: EntityEventRbacMetadata): Promise<void>;
+    publishEntityDeleted(entity: {
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+        organizationId?: string;
+        workspaceId?: string;
+    }, options?: GraphEventOptions, rbac?: EntityEventRbacMetadata): Promise<void>;
+    publishRelationshipCreated(relationship: RelationshipEventData, organizationId: string, options?: GraphEventOptions): Promise<void>;
+    publishRelationshipDeleted(relationship: RelationshipEventData, organizationId: string, options?: GraphEventOptions): Promise<void>;
+    private publishEntityEvent;
+    private publishRelationshipEvent;
+    shutdown(): Promise<void>;
+}
+declare function defineModuleGraph(definition: ModuleGraphDefinition): ModuleGraph;
+
+declare const STANDARD_FIELDS: readonly ["id", "createdAt", "updatedAt"];
+declare const SOFT_DELETE_FIELDS: readonly ["deletedAt"];
+declare const AUDIT_FIELDS: readonly ["metadata", "context"];
+declare const TENANT_FIELDS: readonly ["workspaceId", "tenantId"];
+interface DefineEntityConfigOptions extends Omit<GenericEntityConfig, 'fields'> {
+    fields?: string[];
+    model?: string;
+    exclude?: string[];
+    include?: string[];
+    softDelete?: boolean;
+    multiTenant?: boolean;
+    audit?: boolean;
+}
+interface DefineRelationshipConfigOptions extends Omit<GenericRelationshipConfig, 'label' | 'toField'> {
+    label?: string;
+    toField?: string;
+}
+interface PrismaFieldsModule {
+    getScalarFields: (modelName: string) => string[];
+    hasModel: (modelName: string) => boolean;
+    getAllModelNames: () => string[];
+}
+interface DefineGraphConfigOptions {
+    moduleName: string;
+    entities: Record<string, DefineEntityConfigOptions>;
+    relationships?: Record<string, DefineRelationshipConfigOptions>;
+    prismaFieldsModule?: PrismaFieldsModule;
+}
+declare function defineGraphConfig(options: DefineGraphConfigOptions): GenericGraphConfig;
+declare function defineEntity(config: GenericEntityConfig): GenericEntityConfig;
+declare function defineRelationship(config: GenericRelationshipConfig): GenericRelationshipConfig;
+
+interface InitializeGraphOptions {
+    productName: string;
+    eventEmitter: GraphEventEmitter;
+    monitoredEntityTypes?: string[];
+    enabled?: boolean;
+    validateRuntime?: boolean;
+}
+declare function initializeGraph<TPrisma>(prismaClient: TPrisma, config: GenericGraphConfig, options: InitializeGraphOptions): TPrisma;
+declare function isGraphInitialized(moduleName: string): boolean;
+declare function getGraphStats(): {
+    modules: number;
+    entities: number;
+    relationships: number;
+    registeredModules: string[];
+};
+
+interface GraphNode {
+    id: string;
+    type: string;
+    properties: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: string;
+    properties?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    createdAt: string;
+}
+interface CreateNodeOptions {
+    type: string;
+    properties: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+}
+interface CreateEdgeOptions {
+    from: string;
+    to: string;
+    type: string;
+    properties?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+}
+type TraverseDirection = 'outbound' | 'inbound' | 'any';
+interface TraverseOptions {
+    startNode: string;
+    direction?: TraverseDirection;
+    edgeTypes?: string[];
+    minDepth?: number;
+    maxDepth?: number;
+    limit?: number;
+}
+interface TraverseResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    paths: Array<{
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    }>;
+}
+interface QueryGraphOptions {
+    query: string;
+    bindVars?: Record<string, unknown>;
+    limit?: number;
+}
+declare class GraphModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    createNode(options: CreateNodeOptions): Promise<GraphNode>;
+    createEdge(options: CreateEdgeOptions): Promise<GraphEdge>;
+    getNode(nodeId: string): Promise<GraphNode | null>;
+    updateNode(nodeId: string, properties: Record<string, unknown>): Promise<GraphNode>;
+    deleteNode(nodeId: string): Promise<boolean>;
+    deleteEdge(edgeId: string): Promise<boolean>;
+    traverse(options: TraverseOptions): Promise<TraverseResult>;
+    findShortestPath(fromNode: string, toNode: string, options?: {
+        edgeTypes?: string[];
+        maxDepth?: number;
+    }): Promise<{
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+        distance: number;
+    } | null>;
+    query<T = unknown>(options: QueryGraphOptions): Promise<T[]>;
+    getNeighbors(nodeId: string, options?: {
+        direction?: 'outbound' | 'inbound' | 'any';
+        edgeTypes?: string[];
+        limit?: number;
+    }): Promise<{
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    }>;
+    getNodeDegree(nodeId: string, direction?: 'outbound' | 'inbound' | 'any'): Promise<{
+        inbound: number;
+        outbound: number;
+        total: number;
+    }>;
+    findNodes(type: string, filters: Record<string, unknown>, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        nodes: GraphNode[];
+        total: number;
+    }>;
+    createNodesBatch(nodes: CreateNodeOptions[]): Promise<GraphNode[]>;
+    createEdgesBatch(edges: CreateEdgeOptions[]): Promise<GraphEdge[]>;
+}
+
+declare const index_AUDIT_FIELDS: typeof AUDIT_FIELDS;
+type index_CreateEdgeOptions = CreateEdgeOptions;
+type index_CreateNodeOptions = CreateNodeOptions;
+type index_DefineEntityConfigOptions = DefineEntityConfigOptions;
+type index_DefineGraphConfigOptions = DefineGraphConfigOptions;
+type index_DefineRelationshipConfigOptions = DefineRelationshipConfigOptions;
+type index_EdgeDocument = EdgeDocument;
+type index_EntityDefinition<T = Record<string, unknown>> = EntityDefinition<T>;
+type index_EntityEventContext = EntityEventContext;
+type index_EntityEventData = EntityEventData;
+type index_EntityEventHook = EntityEventHook;
+declare const index_EntityEventType: typeof EntityEventType;
+type index_EntityGraphConfig = EntityGraphConfig;
+type index_EntityRbacConfig = EntityRbacConfig;
+type index_EntityVertex = EntityVertex;
+type index_ExtractedEntityData = ExtractedEntityData;
+type index_ExtractedRelationshipData = ExtractedRelationshipData;
+type index_FieldMapper<T = string> = FieldMapper<T>;
+type index_GenericEntityConfig = GenericEntityConfig;
+type index_GenericGraphConfig = GenericGraphConfig;
+type index_GenericRelationshipConfig = GenericRelationshipConfig;
+type index_GraphEdge = GraphEdge;
+type index_GraphEntityConfig = GraphEntityConfig;
+type index_GraphEntityExport = GraphEntityExport;
+type index_GraphEvent = GraphEvent;
+declare const index_GraphEventEmitter: typeof GraphEventEmitter;
+type index_GraphEventOptions = GraphEventOptions;
+type index_GraphEventPublishOptions = GraphEventPublishOptions;
+type index_GraphEventType = GraphEventType;
+type index_GraphEventsHelper = GraphEventsHelper;
+type index_GraphEventsHelperConfig = GraphEventsHelperConfig;
+type index_GraphEventsPublisher = GraphEventsPublisher;
+declare const index_GraphEventsPublisher: typeof GraphEventsPublisher;
+type index_GraphExportResponse = GraphExportResponse;
+type index_GraphExportService = GraphExportService;
+declare const index_GraphExportService: typeof GraphExportService;
+type index_GraphExportServiceConfig = GraphExportServiceConfig;
+declare const index_GraphMiddlewareConfig: typeof GraphMiddlewareConfig;
+type index_GraphModule = GraphModule;
+declare const index_GraphModule: typeof GraphModule;
+type index_GraphNode = GraphNode;
+type index_GraphRegistry = GraphRegistry;
+declare const index_GraphRegistry: typeof GraphRegistry;
+type index_GraphRelationshipData = GraphRelationshipData;
+type index_GraphRelationshipExport = GraphRelationshipExport;
+type index_GraphSchema = GraphSchema;
+type index_GraphValidationError = GraphValidationError;
+type index_GraphValidationResult = GraphValidationResult;
+type index_InitializeGraphOptions = InitializeGraphOptions;
+type index_ModuleGraph = ModuleGraph;
+type index_ModuleGraphConfig = ModuleGraphConfig;
+type index_ModuleGraphDefinition = ModuleGraphDefinition;
+type index_PrismaGraphIntegration<TPrismaClient extends PrismaClientBase> = PrismaGraphIntegration<TPrismaClient>;
+type index_PrismaGraphIntegrationOptions<TPrismaClient = unknown> = PrismaGraphIntegrationOptions<TPrismaClient>;
+type index_ProductFacet = ProductFacet;
+type index_QueryGraphOptions = QueryGraphOptions;
+type index_RelationshipDefinition = RelationshipDefinition;
+type index_RelationshipEventData = RelationshipEventData;
+type index_RelationshipExportData = RelationshipExportData;
+type index_RelationshipGraphConfig = RelationshipGraphConfig;
+declare const index_SOFT_DELETE_FIELDS: typeof SOFT_DELETE_FIELDS;
+declare const index_STANDARD_FIELDS: typeof STANDARD_FIELDS;
+type index_SearchFacets = SearchFacets;
+type index_SearchFilters = SearchFilters;
+type index_SearchResponse = SearchResponse;
+type index_SearchResult = SearchResult;
+declare const index_TENANT_FIELDS: typeof TENANT_FIELDS;
+type index_TraverseDirection = TraverseDirection;
+type index_TraverseOptions = TraverseOptions;
+type index_TraverseResult = TraverseResult;
+type index_TypeFacet = TypeFacet;
+type index_ValidationErrorType = ValidationErrorType;
+declare const index_addGraphExtension: typeof addGraphExtension;
+declare const index_createEntityEvent: typeof createEntityEvent;
+declare const index_createGraphEventsHelper: typeof createGraphEventsHelper;
+declare const index_createGraphExportService: typeof createGraphExportService;
+declare const index_createPrismaGraphIntegration: typeof createPrismaGraphIntegration;
+declare const index_createRelationshipEvent: typeof createRelationshipEvent;
+declare const index_createRelationshipFromEntity: typeof createRelationshipFromEntity;
+declare const index_defineEntity: typeof defineEntity;
+declare const index_defineGraphConfig: typeof defineGraphConfig;
+declare const index_defineModuleGraph: typeof defineModuleGraph;
+declare const index_defineRelationship: typeof defineRelationship;
+declare const index_extractEntityTitle: typeof extractEntityTitle;
+declare const index_extractMinimalFields: typeof extractMinimalFields;
+declare const index_getCollectionForEntity: typeof getCollectionForEntity;
+declare const index_getGraphEventsPublisher: typeof getGraphEventsPublisher;
+declare const index_getGraphStats: typeof getGraphStats;
+declare const index_initializeGraph: typeof initializeGraph;
+declare const index_isGraphInitialized: typeof isGraphInitialized;
+declare const index_parseRelationship: typeof parseRelationship;
+declare const index_shouldSyncEntity: typeof shouldSyncEntity;
+declare const index_shouldSyncRelationship: typeof shouldSyncRelationship;
+declare namespace index {
+  export { index_AUDIT_FIELDS as AUDIT_FIELDS, type index_CreateEdgeOptions as CreateEdgeOptions, type index_CreateNodeOptions as CreateNodeOptions, type index_DefineEntityConfigOptions as DefineEntityConfigOptions, type index_DefineGraphConfigOptions as DefineGraphConfigOptions, type index_DefineRelationshipConfigOptions as DefineRelationshipConfigOptions, type index_EdgeDocument as EdgeDocument, type index_EntityDefinition as EntityDefinition, type index_EntityEventContext as EntityEventContext, type index_EntityEventData as EntityEventData, type index_EntityEventHook as EntityEventHook, index_EntityEventType as EntityEventType, type EntityFetcher$1 as EntityFetcher, type index_EntityGraphConfig as EntityGraphConfig, type index_EntityRbacConfig as EntityRbacConfig, type index_EntityVertex as EntityVertex, type index_ExtractedEntityData as ExtractedEntityData, type index_ExtractedRelationshipData as ExtractedRelationshipData, type index_FieldMapper as FieldMapper, type index_GenericEntityConfig as GenericEntityConfig, type EntityRbacConfig$1 as GenericEntityRbacConfig, type index_GenericGraphConfig as GenericGraphConfig, type index_GenericRelationshipConfig as GenericRelationshipConfig, type index_GraphEdge as GraphEdge, type index_GraphEntityConfig as GraphEntityConfig, type index_GraphEntityExport as GraphEntityExport, type index_GraphEvent as GraphEvent, index_GraphEventEmitter as GraphEventEmitter, type index_GraphEventOptions as GraphEventOptions, type index_GraphEventPublishOptions as GraphEventPublishOptions, type index_GraphEventType as GraphEventType, type index_GraphEventsHelper as GraphEventsHelper, type index_GraphEventsHelperConfig as GraphEventsHelperConfig, index_GraphEventsPublisher as GraphEventsPublisher, type index_GraphExportResponse as GraphExportResponse, index_GraphExportService as GraphExportService, type index_GraphExportServiceConfig as GraphExportServiceConfig, index_GraphMiddlewareConfig as GraphMiddlewareConfig, index_GraphModule as GraphModule, type index_GraphNode as GraphNode, index_GraphRegistry as GraphRegistry, type index_GraphRelationshipData as GraphRelationshipData, type index_GraphRelationshipExport as GraphRelationshipExport, type index_GraphSchema as GraphSchema, type index_GraphValidationError as GraphValidationError, type index_GraphValidationResult as GraphValidationResult, type index_InitializeGraphOptions as InitializeGraphOptions, type index_ModuleGraph as ModuleGraph, type index_ModuleGraphConfig as ModuleGraphConfig, type index_ModuleGraphDefinition as ModuleGraphDefinition, type index_PrismaGraphIntegration as PrismaGraphIntegration, type index_PrismaGraphIntegrationOptions as PrismaGraphIntegrationOptions, type index_ProductFacet as ProductFacet, type index_QueryGraphOptions as QueryGraphOptions, type index_RelationshipDefinition as RelationshipDefinition, type index_RelationshipEventData as RelationshipEventData, type index_RelationshipExportData as RelationshipExportData, type RelationshipFetcher$1 as RelationshipFetcher, type index_RelationshipGraphConfig as RelationshipGraphConfig, index_SOFT_DELETE_FIELDS as SOFT_DELETE_FIELDS, index_STANDARD_FIELDS as STANDARD_FIELDS, type index_SearchFacets as SearchFacets, type index_SearchFilters as SearchFilters, type index_SearchResponse as SearchResponse, type index_SearchResult as SearchResult, index_TENANT_FIELDS as TENANT_FIELDS, type index_TraverseDirection as TraverseDirection, type index_TraverseOptions as TraverseOptions, type index_TraverseResult as TraverseResult, type index_TypeFacet as TypeFacet, type index_ValidationErrorType as ValidationErrorType, index_addGraphExtension as addGraphExtension, index_createEntityEvent as createEntityEvent, index_createGraphEventsHelper as createGraphEventsHelper, index_createGraphExportService as createGraphExportService, index_createPrismaGraphIntegration as createPrismaGraphIntegration, index_createRelationshipEvent as createRelationshipEvent, index_createRelationshipFromEntity as createRelationshipFromEntity, index_defineEntity as defineEntity, index_defineGraphConfig as defineGraphConfig, index_defineModuleGraph as defineModuleGraph, index_defineRelationship as defineRelationship, index_extractEntityTitle as extractEntityTitle, index_extractMinimalFields as extractMinimalFields, index_getCollectionForEntity as getCollectionForEntity, index_getGraphEventsPublisher as getGraphEventsPublisher, index_getGraphStats as getGraphStats, index_initializeGraph as initializeGraph, index_isGraphInitialized as isGraphInitialized, index_parseRelationship as parseRelationship, index_shouldSyncEntity as shouldSyncEntity, index_shouldSyncRelationship as shouldSyncRelationship };
+}
+
+export { type RelationshipEventData as $, AUDIT_FIELDS as A, type GraphEventsHelperConfig as B, type CreateEdgeOptions as C, type DefineEntityConfigOptions as D, type EdgeDocument as E, type FieldMapper as F, GraphModule as G, GraphEventsPublisher as H, type GraphExportResponse as I, GraphExportService as J, type GraphExportServiceConfig as K, type GraphNode as L, GraphRegistry as M, type GraphRelationshipData as N, type GraphRelationshipExport as O, type GraphSchema as P, type GraphValidationError as Q, type GraphValidationResult as R, type InitializeGraphOptions as S, type ModuleGraph as T, type ModuleGraphConfig as U, type ModuleGraphDefinition as V, type PrismaGraphIntegration as W, type PrismaGraphIntegrationOptions as X, type ProductFacet as Y, type QueryGraphOptions as Z, type RelationshipDefinition as _, type CreateNodeOptions as a, type RelationshipExportData as a0, type RelationshipFetcher$1 as a1, type RelationshipGraphConfig as a2, SOFT_DELETE_FIELDS as a3, STANDARD_FIELDS as a4, type SearchFacets as a5, type SearchFilters as a6, type SearchResponse as a7, type SearchResult as a8, TENANT_FIELDS as a9, type TraverseDirection as aa, type TraverseOptions as ab, type TraverseResult as ac, type TypeFacet as ad, type ValidationErrorType as ae, createEntityEvent as af, createGraphEventsHelper as ag, createGraphExportService as ah, createPrismaGraphIntegration as ai, createRelationshipEvent as aj, createRelationshipFromEntity as ak, defineEntity as al, defineGraphConfig as am, defineModuleGraph as an, defineRelationship as ao, extractEntityTitle as ap, extractMinimalFields as aq, getCollectionForEntity as ar, getGraphEventsPublisher as as, getGraphStats as at, initializeGraph as au, isGraphInitialized as av, parseRelationship as aw, shouldSyncEntity as ax, shouldSyncRelationship as ay, type DefineGraphConfigOptions as b, type DefineRelationshipConfigOptions as c, type EntityDefinition as d, type EntityEventContext as e, type EntityEventData as f, type EntityEventHook as g, type EntityFetcher$1 as h, index as i, type EntityGraphConfig as j, type EntityRbacConfig as k, type EntityVertex as l, type ExtractedEntityData as m, type ExtractedRelationshipData as n, type GenericEntityConfig as o, type EntityRbacConfig$1 as p, type GenericGraphConfig as q, type GenericRelationshipConfig as r, type GraphEdge as s, type GraphEntityConfig as t, type GraphEntityExport as u, type GraphEvent as v, type GraphEventOptions as w, type GraphEventPublishOptions as x, type GraphEventType as y, type GraphEventsHelper as z };