Enum EdgeKind 

pub enum EdgeKind {
    Call {
        argument_count: usize,
        is_async: bool,
    },
    Import {
        alias: Option<String>,
        is_wildcard: bool,
    },
    Inherits,
    Implements,
    HTTPRequest {
        method: String,
        endpoint: String,
    },
    FFICall {
        ffi_type: FFIType,
    },
    FieldAccess {
        field_name: String,
    },
    TableRead {
        table_name: String,
        schema: Option<String>,
    },
    TableWrite {
        table_name: String,
        schema: Option<String>,
        operation: TableWriteOp,
    },
    TriggeredBy {
        trigger_name: String,
        schema: Option<String>,
    },
    ChannelInvoke {
        channel_name: String,
        method: String,
    },
    WidgetChild {
        widget_type: String,
    },
    Export {
        kind: ExportKind,
        symbol: Option<String>,
        alias: Option<String>,
        from_module: Option<String>,
    },
}

Type of relationship between nodes

Variants

Call

Function call

Fields

argument_count: usize

Number of arguments passed

is_async: bool

Whether the call is async/await

Import

Module import

Fields

alias: Option<String>

Import alias (e.g., “import foo as bar”)

is_wildcard: bool

Whether this is a wildcard import (e.g., “import *”)

Inherits

Class inheritance

Implements

Interface implementation

HTTPRequest

HTTP request (cross-language)

Fields

method: String

HTTP method (GET, POST, etc.)

endpoint: String

HTTP endpoint path

FFICall

Foreign Function Interface call (cross-language)

Fields

ffi_type: FFIType

Type of FFI mechanism used

FieldAccess

Field access

Fields

field_name: String

Name of the accessed field

TableRead

Database table read operation (SQL)

Fields

table_name: String

Name of the table being read

schema: Option<String>

Optional schema/database name

TableWrite

Database table write operation (SQL)

Fields

table_name: String

Name of the table being written

schema: Option<String>

Optional schema/database name

operation: TableWriteOp

Type of write operation (INSERT, UPDATE, DELETE)

TriggeredBy

Database trigger relationship (SQL)

Fields

trigger_name: String

Name of the trigger

schema: Option<String>

Optional schema/database name

ChannelInvoke

Flutter MethodChannel invocation (Dart)

Fields

channel_name: String

Name of the platform channel

method: String

Method being invoked on the channel

WidgetChild

Flutter widget parent-child relationship (Dart)

Fields

widget_type: String

Type of the child widget

Export

Module export

Represents an export statement that makes symbols available to other modules. Supports all major export patterns including named, default, namespace, and wildcard re-exports.

Per-Kind Field Semantics

ExportKind	symbol	alias	from_module	Example
Named	Some(“foo”)	None	None	export { foo }
Named	Some(“foo”)	Some(“bar”)	None	export { foo as bar }
Named	Some(“foo”)	None	Some(“./mod”)	export { foo } from './mod'
NamedTypeOnly	Some(“Foo”)	None	None	export type { Foo }
Default	Some(“MyClass”)	None	None	export default MyClass
Default	Some(“default”)	None	None	export default function() {}
Namespace	Some(“ns”)	None	Some(“./mod”)	export * as ns from './mod'
NamespaceTypeOnly	Some(“Types”)	None	Some(“./types”)	export type * as Types from './types'
AllFromModule	None	None	Some(“./mod”)	export * from './mod'
AllFromModuleTypeOnly	None	None	Some(“./types”)	export type * from './types'
Assignment	Some(“Foo”)	None	None	export = Foo
GlobalNamespace	Some(“MyLib”)	None	None	export as namespace MyLib

Fields

kind: ExportKind

Export kind discriminator (determines how other fields are interpreted)

symbol: Option<String>

Node being exported (optional - None for AllFromModule/AllFromModuleTypeOnly)

• Named/NamedTypeOnly: the exported symbol name (required)
• Default: name of exported item, or “default” for anonymous (required)
• Namespace/NamespaceTypeOnly: the namespace binding name (required)
• AllFromModule/AllFromModuleTypeOnly: None (wildcard, no specific symbol)
• Assignment/GlobalNamespace: the exported binding name (required)

alias: Option<String>

Optional alias for re-exports (export { foo as bar })

First-class field (not metadata) for type safety.

from_module: Option<String>

Optional source module for re-exports (export { foo } from './bar')

First-class field (not metadata) for type safety.

Trait Implementations

impl Clone for EdgeKind

fn clone(&self) -> EdgeKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EdgeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for EdgeKind

fn eq(&self, other: &EdgeKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for EdgeKind