graph

type Batch interface {
	// WithGraph scopes the transaction to a specific graph. If the driver for the transaction does not support
	// multiple  graphs the resulting transaction will target the default graph instead and this call becomes a no-op.
	WithGraph(graphSchema Graph) Batch

	// CreateNode creates a new Node in the database and returns the creation as a NodeResult.
	CreateNode(node *Node) error

	// DeleteNode deletes a node by the given ID.
	DeleteNode(id ID) error

	// Nodes begins a batch query that can be used to update or delete nodes.
	Nodes() NodeQuery

	// Relationships begins a batch query that can be used to update or delete relationships.
	Relationships() RelationshipQuery

	// UpdateNodeBy is a stop-gap until the query interface can better support targeted batch create-update operations.
	// Nodes identified by the NodeUpdate criteria will either be updated or in the case where the node does not yet
	// exist, created.
	UpdateNodeBy(update NodeUpdate) error

	// TODO: Existing batch logic expects this to perform an upsert on conficts with (start_id, end_id, kind). This is incorrect and should be refactored
	CreateRelationship(relationship *Relationship) error

	// Deprecated: Use CreateRelationship Instead
	//
	// CreateRelationshipByIDs creates a new Relationship from the start Node to the end Node with the given Kind and
	// Properties and returns the creation as a RelationshipResult.
	CreateRelationshipByIDs(startNodeID, endNodeID ID, kind Kind, properties *Properties) error

	// DeleteRelationship deletes a relationship by the given ID.
	DeleteRelationship(id ID) error

	// UpdateRelationshipBy is a stop-gap until the query interface can better support targeted batch create-update
	// operations. Relationships identified by the RelationshipUpdate criteria will either be updated or in the case
	// where the relationship does not yet exist, created.
	UpdateRelationshipBy(update RelationshipUpdate) error

	// Commit calls to commit this batch transaction right away.
	Commit() error
}

type BatchDelegate func(batch Batch) error

type Constraint Index

type Criteria any

type CriteriaProvider func() Criteria

type Cursor[T any] interface {
	// Error returns the error reference captured by this Result. When DAWGS database calls fail this value must be
	// populated by the underlying driver.
	Error() error

	// Close releases any active resources bound to this cursor
	Close()

	// Chan returns the type channel backed by this database cursor
	Chan() chan T
}

type Database interface {
	// SetWriteFlushSize sets a new write flush interval on the current driver
	SetWriteFlushSize(interval int)

	// SetBatchWriteSize sets a new batch write interval on the current driver
	SetBatchWriteSize(interval int)

	// ReadTransaction opens up a new read transactional context in the database and then defers the context to the
	// given logic function.
	ReadTransaction(ctx context.Context, txDelegate TransactionDelegate, options ...TransactionOption) error

	// WriteTransaction opens up a new write transactional context in the database and then defers the context to the
	// given logic function.
	WriteTransaction(ctx context.Context, txDelegate TransactionDelegate, options ...TransactionOption) error

	// BatchOperation opens up a new write transactional context in the database and then defers the context to the
	// given logic function. Batch operations are fundamentally different between databases supported by DAWGS,
	// necessitating a different interface that lacks many of the convenience features of a regular read or write
	// transaction.
	BatchOperation(ctx context.Context, batchDelegate BatchDelegate) error

	// AssertSchema will apply the given schema to the underlying database.
	AssertSchema(ctx context.Context, dbSchema Schema) error

	// SetDefaultGraph sets the default graph namespace for the connection.
	SetDefaultGraph(ctx context.Context, graphSchema Graph) error

	// Run allows a user to pass statements directly to the database. Since results may rely on a transactional context
	// only an error is returned from this function
	Run(ctx context.Context, query string, parameters map[string]any) error

	// Close closes the database context and releases any pooled resources held by the instance.
	Close(ctx context.Context) error

	// FetchKinds retrieves the complete list of kinds available to the database.
	FetchKinds(ctx context.Context) (Kinds, error)

	// RefreshKinds refreshes the in memory kinds maps
	RefreshKinds(ctx context.Context) error
}

type DatabaseSwitch struct {
	// contains filtered or unexported fields
}

type Direction int

type DirectionalResult struct {
	Direction    Direction
	Relationship *Relationship
	Node         *Node
}

type ErrorResult struct {
	// contains filtered or unexported fields
}

type Graph struct {
	Name            string
	Nodes           Kinds
	Edges           Kinds
	NodeConstraints []Constraint
	EdgeConstraints []Constraint
	NodeIndexes     []Index
	EdgeIndexes     []Index
}

type ID uint64

type Index struct {
	Name  string
	Field string
	Type  IndexType
}

type IndexType int

type IndexedSlice[K comparable, V any] struct {
	// contains filtered or unexported fields
}

type Kind interface {
	String

	// Is returns true if the other Kind matches the Kind represented by this interface.
	Is(other ...Kind) bool
}

type KindBitmaps map[string]cardinality.Duplex[uint64]

type Kinds []Kind

type KindsResult struct {
	ID    ID
	Kinds Kinds
}

type MapFunc func(rawValue, target any) bool

type Node struct {
	ID           ID          `json:"id"`
	Kinds        Kinds       `json:"kinds"`
	AddedKinds   Kinds       `json:"added_kinds"`
	DeletedKinds Kinds       `json:"deleted_kinds"`
	Properties   *Properties `json:"properties"`
}

type NodeKindSet map[string]NodeSet

type NodeQuery interface {
	// Filter applies the given criteria to this query.
	Filter(criteria Criteria) NodeQuery

	// Filterf applies the given criteria provider function to this query.
	Filterf(criteriaDelegate CriteriaProvider) NodeQuery

	// Query completes the query and hands the raw result to the given delegate for unmarshalling
	Query(delegate func(results Result) error, finalCriteria ...Criteria) error

	// Delete deletes any candidate nodes that match the query criteria
	Delete() error

	// Update updates all candidate nodes with the given properties
	Update(properties *Properties) error

	// OrderBy sets the OrderBy clause of the NodeQuery.
	OrderBy(criteria ...Criteria) NodeQuery

	// Offset sets an offset for the result set of the query. Using this function will enforce order on the result set.
	Offset(skip int) NodeQuery

	// Limit sets a maximum number of results to collect from the database.
	Limit(skip int) NodeQuery

	// Count completes the query and returns a tuple containing the count of results that were addressed by the
	// database and any error encountered during execution.
	Count() (int64, error)

	// First completes the query and returns the result and any error encountered during execution.
	First() (*Node, error)

	// Fetch completes the query and captures a cursor for iterating the result set. This cursor is passed to the given
	// delegate. Errors from the delegate are returned upwards as the error result of this call.
	Fetch(delegate func(cursor Cursor[*Node]) error, finalCriteria ...Criteria) error

	// FetchIDs completes the query and captures a cursor for iterating the result set. This cursor is passed to the given
	// delegate. Errors from the delegate are returned upwards as the error result of this call.
	FetchIDs(delegate func(cursor Cursor[ID]) error) error

	// FetchKinds returns the ID and Kinds of matched nodes and omits property fetching
	FetchKinds(func(cursor Cursor[KindsResult]) error) error
}

type NodeSet map[ID]*Node

type NodeUpdate struct {
	Node               *Node
	IdentityKind       Kind
	IdentityProperties []string
}

type Path struct {
	Nodes []*Node
	Edges []*Relationship
}

type PathSegment struct {
	Node     *Node
	Trunk    *PathSegment
	Edge     *Relationship
	Branches []*PathSegment
	Tag      any
	// contains filtered or unexported fields
}

type PathSet []Path

type Properties struct {
	Map      map[string]any      `json:"map"`
	Deleted  map[string]struct{} `json:"deleted"`
	Modified map[string]struct{} `json:"modified"`
}

type PropertyMap map[String]any

type PropertyValue interface {
	// IsNil returns true if the property value is nil.
	IsNil() bool

	// Bool returns the property value as a bool along with any type negotiation error information.
	Bool() (bool, error)

	// Int returns the property value as an int along with any type negotiation error information.
	Int() (int, error)

	// Int64 returns the property value as an int64 along with any type negotiation error information.
	Int64() (int64, error)

	// Int64Slice returns the property value as an int64 slice along with any type negotiation error information.
	Int64Slice() ([]int64, error)

	// IDSlice returns the property value as a ID slice along with any type negotiation error information.
	IDSlice() ([]ID, error)

	//StringSlice returns the property value as a string slice along with any type negotiation error information.
	StringSlice() ([]string, error)

	// Uint64 returns the property value as an uint64 along with any type negotiation error information.
	Uint64() (uint64, error)

	// Float64 returns the property value as a float64 along with any type negotiation error information.
	Float64() (float64, error)

	// String returns the property value as a string along with any type negotiation error information.
	String() (string, error)

	// Time returns the property value as time.Time along with any type negotiation error information.
	Time() (time.Time, error)

	// Any returns the property value typed as any. This function may return a null reference.
	Any() any
}

type Relationship struct {
	ID         ID
	StartID    ID
	EndID      ID
	Kind       Kind
	Properties *Properties
}

type RelationshipKindsResult struct {
	RelationshipTripleResult
	Kind Kind
}

type RelationshipQuery interface {
	// Filter applies the given criteria to this query.
	Filter(criteria Criteria) RelationshipQuery

	// Filterf applies the given criteria provider function to this query.
	Filterf(criteriaDelegate CriteriaProvider) RelationshipQuery

	// Update replaces the properties of all candidate relationships that matches the query criteria with the
	// given properties
	Update(properties *Properties) error

	// Delete deletes any candidate relationships that match the query criteria
	Delete() error

	// OrderBy sets the OrderBy clause of the RelationshipQuery.
	OrderBy(criteria ...Criteria) RelationshipQuery

	// Offset sets an offset for the result set of the query. Using this function will enforce order on the result set.
	Offset(skip int) RelationshipQuery

	// Limit sets a maximum number of results to collect from the database.
	Limit(skip int) RelationshipQuery

	// Count completes the query and returns a tuple containing the count of results that were addressed by the
	// database and any error encountered during execution.
	Count() (int64, error)

	// First completes the query and returns the result and any error encountered during execution.
	First() (*Relationship, error)

	// Query completes the query and hands the raw result to the given delegate for unmarshalling
	Query(delegate func(results Result) error, finalCriteria ...Criteria) error

	// Fetch completes the query and captures a cursor for iterating the result set. This cursor is passed to the given
	// delegate. Errors from the delegate are returned upwards as the error result of this call.
	Fetch(delegate func(cursor Cursor[*Relationship]) error) error

	// FetchDirection completes the query and captures a cursor for iterating through the relationship related nodes
	// for the given path direction
	FetchDirection(direction Direction, delegate func(cursor Cursor[DirectionalResult]) error) error

	// FetchIDs completes the query and captures a cursor for iterating the result set. This cursor is passed to the given
	// delegate. Errors from the delegate are returned upwards as the error result of this call.
	FetchIDs(delegate func(cursor Cursor[ID]) error) error

	//
	FetchTriples(delegate func(cursor Cursor[RelationshipTripleResult]) error) error

	//
	FetchAllShortestPaths(delegate func(cursor Cursor[Path]) error) error

	// FetchKinds returns the ID, Kind, Start ID and End ID of matched relationships and omits property fetching
	FetchKinds(delegate func(cursor Cursor[RelationshipKindsResult]) error) error
}

type RelationshipSet map[ID]*Relationship

type RelationshipTripleResult struct {
	ID      ID
	StartID ID
	EndID   ID
}

type RelationshipUpdate struct {
	Relationship            *Relationship
	IdentityProperties      []string
	Start                   *Node
	StartIdentityKind       Kind
	StartIdentityProperties []string
	End                     *Node
	EndIdentityKind         Kind
	EndIdentityProperties   []string
}

type Result interface {
	Next() bool
	Values() []any
	Mapper() ValueMapper

	// Scan takes a list of target any and attempts to map the next row from the result to the targets. This function
	// is semantically equivalent to calling graph.ScanNextResult(...)
	//
	// This is Deprecated. Call the graph.ScanNextResult(...) function.
	Scan(targets ...any) error
	Error() error
	Close()
}

type ResultIterator[T any] struct {
	// contains filtered or unexported fields
}

type ResultMarshaller[T any] func(scanner Result) (T, error)

type Schema struct {
	Graphs       []Graph
	DefaultGraph Graph
}

type String interface {
	String() string
}

type ThreadSafeKindBitmap struct {
	// contains filtered or unexported fields
}

type ThreadSafeNodeSet struct {
	// contains filtered or unexported fields
}

type Transaction interface {
	// WithGraph scopes the transaction to a specific graph. If the driver for the transaction does not support
	// multiple  graphs the resulting transaction will target the default graph instead and this call becomes a no-op.
	WithGraph(graphSchema Graph) Transaction

	// CreateNode creates a new Node in the database and returns the creation as a NodeResult.
	CreateNode(properties *Properties, kinds ...Kind) (*Node, error)

	// UpdateNode updates a Node in the database with the given Node by ID. UpdateNode will not create missing Node
	// entries in the database. Use CreateNode first to create a new Node.
	UpdateNode(node *Node) error

	// Nodes creates a new NodeQuery and returns it.
	Nodes() NodeQuery

	// CreateRelationshipByIDs creates a new Relationship from the start Node to the end Node with the given Kind and
	// Properties and returns the creation as a RelationshipResult.
	CreateRelationshipByIDs(startNodeID, endNodeID ID, kind Kind, properties *Properties) (*Relationship, error)

	// UpdateRelationship updates a Relationship in the database with the given Relationship by ID. UpdateRelationship
	// will not create missing Relationship entries in the database. Use CreateRelationship first to create a new
	// Relationship.
	UpdateRelationship(relationship *Relationship) error

	// Relationships creates a new RelationshipQuery and returns it.
	Relationships() RelationshipQuery

	// Raw allows a user to pass raw queries directly to the database without translation.
	Raw(query string, parameters map[string]any) Result

	// Query allows a user to execute a given cypher query that will be translated to the target database.
	Query(query string, parameters map[string]any) Result

	// Commit calls to commit this transaction right away.
	Commit() error

	// GraphQueryMemoryLimit returns the graph query memory limit of
	GraphQueryMemoryLimit() size.Size
}

type TransactionConfig struct {
	Timeout      time.Duration
	DriverConfig any
}

type TransactionDelegate func(tx Transaction) error

type TransactionOption func(config *TransactionConfig)

type Tree struct {
	Root *PathSegment
}

type ValueMapper struct {
	// contains filtered or unexported fields
}