sst

type Boolean bool

type Byte int8

type CommitDetails struct {
	Commit              Hash
	Author              string
	AuthorDate          time.Time
	Message             string
	ParentCommits       map[IRI][]Hash
	DatasetRevisions    map[IRI]Hash
	NamedGraphRevisions map[IRI]Hash
}

type Dataset interface {
	// IRI returns the IRI of the default NamedGraph of this [Dataset].
	IRI() IRI

	// Branches returns all available branch Names and corresponding commitHashes.
	// A SST Repository that does not support history returns an empty map.
	// This method can also be used to check if this Dataset is deleted or not.
	// If a Dataset is deleted, all branches are removed and thus an empty map is returned.
	Branches(ctx context.Context) (map[string]Hash, error)

	// LeafCommits returns all leaf commits of this Dataset that are not identified by a branch Name.
	// A SST Repository that does not support history returns an empty slice.
	LeafCommits(ctx context.Context) ([]Hash, error)

	// CommitDetailsByHash provides detail information about a commit identified by
	// commitID in scope of a Dataset. If the commitID is not know for the
	// Dataset an error ErrCommitNotFound is returned.
	CommitDetailsByHash(ctx context.Context, commit Hash) (*CommitDetails, error)

	// CommitDetailsByBranch provides detail information about a commit identified by
	// branch in scope of a Dataset. If the branch is not know for the
	// Dataset an error errBranchNotFound is returned.
	CommitDetailsByBranch(ctx context.Context, branch string) (*CommitDetails, error)

	// SetBranch moves or sets a branch Name to the revision of this Dataset that was created in the specified commit.
	// If this branch Name was set before to another revision of this Dataset, it is removed from that revision.
	SetBranch(ctx context.Context, commit Hash, branch string) error

	// RemoveBranch deletes a dataset branch from the repository.
	RemoveBranch(ctx context.Context, branch string) error

	// Repository returns [Repository] to which the [Dataset] belongs.
	Repository() Repository

	// CheckoutCommit returns a new Stage that is based on the given commit but is not
	// related to any branch optionally using provided options.
	CheckoutCommit(ctx context.Context, commitID Hash, mode TriplexMode) (Stage, error)

	// CheckoutBranch returns a Stage that operates on the receiver Dataset for the commit that is
	// specified by the tip of the given branch and optionally using provided options.
	CheckoutBranch(ctx context.Context, branchName string, mode TriplexMode) (Stage, error)

	// CheckoutRevision returns a new Stage that is based on the given DatasetRevision.
	// This is useful when a DatasetRevision exists that is not associated with a branch name.
	CheckoutRevision(ctx context.Context, datasetRevision Hash, mode TriplexMode) (Stage, error)

	// FindCommonParentRevision searches for a common ancestor of commit revision1 and commit revision2
	// of this Dataset and returns its common parent commit revision Hash.
	// For this, the two revisions must belong to the same Dataset and exist in the the same Repository.
	// Only then, it is possible to compare the two revisions of the same Dataset.
	// This method traverses the commit revision history of both revisions in the Repository
	// by following the commit tree that contain information about the parents.
	// This method returns either revision1 or revision2 or another revision of this Dataset in the same Repository.
	// This method returns Hash of empty string and nil if there is no common parent revision.
	// Note: This method is used for three-way diff and merge.
	FindCommonParentRevision(context context.Context, revision1, revision2 Hash) (parent Hash, err error)
}

type Dictionary interface {
	Stage
	// Vocabulary returns a NamedGraph for the given Vocabulary
	// that belongs to the read-only dictionary stage.
	Vocabulary(v Vocabulary) (NamedGraph, error)
	// Element returns an IBNode for the given VocabularyElement
	// that is located in a NamedGraph that belongs to the
	// read-only dictionary stage.
	Element(e Element) (IBNode, error)
}

type DiffTriple struct {
	Flag DiffTripleFlag
	Sub  string
	Pred string
	Obj  string
}

type DiffTripleFlag int8

type DocumentInfo struct {
	Hash      Hash      `json:"id"`
	MIMEType  string    `json:"mime_type"`
	Author    string    `json:"author"`
	Timestamp time.Time `json:"timestamp"`
	Size      int64     `json:"size"`
}

type Double float64

type Element struct {
	Vocabulary Vocabulary
	Name       string
}

type ElementInfo struct {
	Element
	AClass            bool // true if the element is an owl:Class.
	AnOptionClass     bool // true is the element is a ssmeta:OptionClass.
	AnAbstractClass   bool // true if the element is a ssmeta:AbstractClass.
	ARootClass        bool // true if the element is a ssmeta:RootClass.
	AProperty         bool // true if the element is an rdf:Property.
	ADatatypeProperty bool // true if the element is an owl:DatatypeProperty.
	AnObjectProperty  bool // true if the element is an owl:ObjectProperty.
	ADatatype         bool // true if the element is an rdfs:Datatype.
	AnIndividual      bool // true if the property is neither a class nor a property nor a datatype.

	// AMainClassSupersedure provides the main classes this element supersedes.
	// AMainClassSupersedure is set to empty map[Element]struct{} in case the
	// element denotes a main class but does not supersedes any other element.
	// AMainClassSupersedure is set to nil if this element is not a main class.
	AMainClassSupersedure map[Element]struct{}

	ADomain               ElementInformer   // The rdfs:domain of a property.
	ARange                ElementInformer   // The rdfs:range of a property.
	ACollectionMemberType ElementInformer   // represent collection member type
	ASubtypeOf            []ElementInformer // Superclasses from zero or more rdfs:subClassOf statements.

	ASubPropertyOf ElementInformer // Super-property from rdfs:subPropertyOf statement or nil.
	AnInverseOf    ElementInformer // The owl:inverseOf of a property if available.
}

type ElementInformer interface {
	Node
	Elementer
	IsClass() bool            // true if the element is an owl:Class
	IsProperty() bool         // true if the element is an rdf:Property or owl:DatatypeProperty or owl:ObjectProperty.
	IsDatatypeProperty() bool // true if the element is an owl:DatatypeProperty.
	IsObjectProperty() bool   // true if the element is an owl:ObjectProperty.
	IsDatatype() bool         // true if the element is an rdfs:Datatype.
	IsIndividual() bool       // true if the target is neither a class nor a property nor a datatype.

	// IsMainClass returns true if the target is directly or indirectly of the mainClass type.
	IsMainClass(mainClass Element) bool
	// Domain returns the rdfs:domain of a property.
	Domain() ElementInformer
	// Range returns the rdfs:range of a property.
	Range() ElementInformer
	// SubtypeOf returns superclasses from zero or more rdfs:subClassOf statements.
	SubtypeOf() []ElementInformer
	// SubPropertyOf returns super-property from rdfs:subPropertyOf statement or nil.
	SubPropertyOf() ElementInformer
	// InverseOf returns the owl:inverseOf of a property if available.
	InverseOf() ElementInformer
	// CollectionMember() returns the collection member type.
	CollectionMember() ElementInformer
}

type Elementer interface {
	VocabularyElement() Element
}

type Float float32

type ForEachNode func(d IBNode) error

type Hash [sha256.Size]byte

type IBNode interface {
	Node
	// TypeOf returns the IBNode that represents the main type this IBNode is an rdf:type of.
	// An IBNode might be a type of several classes.
	// The main class is indicated in the SST Vocabularies by rdf:type ssmeta:MainClass.
	// Applications should ensure that only one main class is used for an IBNode.
	TypeOf() IBNode

	// IRI() returns the IRI (Internationalized Resource Identifier) of the IBNode.
	// If the IBNode is of type IRI Node, it will return its IRI.
	// If the IBNode is of type blank Node, it will panic.
	IRI() IRI

	// Fragment returns the fragment part of the RDF resource identifier of the IBNode.
	// if the IBNode is of type IRI Node, it will return its fragment.
	// if the IBNode is of type blank Node, it will panic.
	Fragment() string

	// ID returns the UUID of the ibNode. It checks the type of the ibNode
	// and retrieves the UUID accordingly.
	// If the ibNode is of type blank Node, it returns the fragment UUID if it is not nil.
	// If the ibNode is of type IRI Node, it will panic.
	ID() uuid.UUID

	// PrefixedFragment returns the IRI of the IBNode in shorthand notation as
	// it is used in Turtle syntax (https://www.w3.org/TR/turtle/).
	// It is legal to invoke this method for the zero valued IBNode as well.
	// In such case the predefined string "(nil)" is returned.
	//
	// Example:
	//
	// fmt.Print(ib.PrefixedFragment()) // prints "sso:Part"
	PrefixedFragment() string

	// TripleCount returns the number of triples this IBNode is used as either subject, predicate or object.
	// This TripleCount may used in combination with GetTriple method.
	TripleCount() int

	// OwningGraph returns the owning NamedGraph of the IBNode.
	OwningGraph() NamedGraph

	// ForAll iterates over all triples (subject, predicate or object triplex) of this IBNode.
	//
	// The triples of the owning graph that have receiver node as its subject are called forward triples.
	// The triples of the owning graph that have receiver node as its object are called inverse triples.
	// The triples of the owning graph that have receiver node as its predicate are called middle triples.
	// The triples of the owning graph that have receiver node both as its subject and object are called
	// self referenced triple.
	//
	// For each forward triple the given callback function c is invoked with s set to the receiver node and
	// p, o set to the triple's predicate and object accordingly.
	// For each inverse triple the given callback function c is invoked with s, p set to triple's subject
	// and object accordingly and o set to the receiver node.
	// For the self referenced triple the given callback function invoked with s and o set to
	// receiver node and p to the triple's predicate.
	// When the callback function returns an error, the ForAll loop is ended immediately and this error is returned.
	ForAll(c func(a int, subject IBNode, predicate IBNode, object Term) error) error

	// GetObjects returns all Objects for the given Subject(IBNode) with specified Node.
	// later on: support also subProperty of predicate
	// return values: a slice of objects which length may be 0 or 1 or more
	GetObjects(predicate Node) []Term

	// GetTriple returns particular triple that identified by index related to the IBNode.
	// The triple is returned as subject(s), predicate(p), and object(o).
	// The IBNode is used either as subject, predicate, or object.
	// The number of triples that are associated to an IBNode is available by TripleCount().
	// The order of triples is managed internally by SST and can not be influenced by the API.
	// The possible error codes are: ErrIndexOutOfRange, ErrNodeDeletedOrInvalid
	GetTriple(index int) (IBNode, IBNode, Term)

	// AddStatement() method adds a triple to the target IBNode that is used as subject with p for the predicate and o for the object.
	// User has to ensure that the triple to be added does not already exist; otherwise this method will panic.
	AddStatement(predicate Node, object Term)

	// AddStatementAlt() method adds a triple to the target IBNode that is used as subject with p for the predicate and o for the object.
	// This method is an alternative to AddStatement() with the difference that it is tolerant in case that the triple to be added already exist.
	// An error will be returned if the triple to be added already exist.
	AddStatementAlt(predicate Node, object Term) error

	// CheckTriple() checks is a triple with the given subject, predicate and object exist and returns TRUE in this case; otherwise FALSE is returned.
	CheckTriple(predicate Node, object Term) bool

	// Delete deletes the target IBNode and all triples
	// where the target is used as either subject, predicate or object.
	// After deletion this IBNode is no longer valid and IBNode.IsValid() will return false.
	Delete()

	// ForDelete iterates over all forward triples of this IBNode and invokes the fallback function c
	// for each triple with it's subject, predicate and object.
	// If the invoked callback function c returns true for one or several triples, then these triples are removed.
	ForDelete(c func(int, IBNode, IBNode, Term) bool)

	// DeleteTriples deletes all subject triples of this IBNode
	DeleteTriples()

	// InVocabulary returns a corresponding ElementInformer for the IBNode.
	// It is legal to invoke this method for the zero valued IBNode as well.
	// This method is in most cases invoked for IBNodes from ReferencedGraphs.
	//
	// This method often used to determine the actual ElementInformer interface
	// which can be done by using "Type Switch" or "Type Assertion" from the Golang specification.
	//
	// Example of using Type Switch:
	//
	//	var d sst.IBNode
	//	switch d.TypeOf().InVocabulary().(type) {
	//	case sso.KindPart:
	//		// d is sso:Part or any of its subtypes
	//		// ...
	//	}
	//
	// Example of using Type Assertion:
	//
	//	 if _, ok := p.InVocabulary().(lci.KindHasArrangedPart); ok {
	//		    // do something
	//
	//     }
	InVocabulary() ElementInformer

	// Is checks if the IBNode is the same as a given vocabulary element.
	// It is legal to invoke this method for the zero valued IBNode as well.
	// It is legal to invoke this method for the nil valued IBNode as well.
	// This method is in most cases invoked for IBNodes from ReferencedGraphs.
	// This method is in most cases invoked for IBNodes from ReferencedGraphs
	// for which a corresponding dictionary or vocabulary included in the SST ontologies.
	Is(e Elementer) bool

	// IsKind checks if the IBNode is of given vocabulary element type.
	IsKind(e ElementInformer) bool

	// IsValid return true if the IBNode represents a non-zero value of the IBNode type
	// that belongs to a valid NamedGraph.
	IsValid() bool

	// IsUuidFragment checks on whether the ibNode has a uuid fragment.
	// If it has, true is returned. Otherwise, false is returned.
	IsUuidFragment() bool

	// IsReferenced returns whether the NamedGraph of this IBNode is Referenced,
	// and as a consequences, it does not contain any subject triples.
	// It is not possible to modify an IBNode that is in a referenced state.
	IsReferenced() bool

	// IsIRINode returns true if the IBNode is an IRI node.
	IsIRINode() bool

	// IsBlankNode returns true if the IBNode is a blank node.
	IsBlankNode() bool

	// AsCollection() checks if an IBNode is in fact a TermCollections and returns it if successful.
	AsCollection() (TermCollection, bool)

	// DumpTriples returns a slice of all subject triples of this IBNode
	// consisting of [3]string for the subject, predicate and object of the triple.
	// All IRIs are given with the default or automatically assigned prefixes, similar to standard Turtle format.
	DumpTriples() [][3]string

	// Equal compares this IBNode with another IBNode in another NamedGraph and another Stage.
	// Equal compares the IRI of IRI Nodes and all subject triples of all IRI and BlankNodes.
	// Returns true if the two IBNodes are considered equal, false otherwise.
	// Note: In the case that the predicate or object of a triple exists in another NamedGraph, these must be IRI Nodes not BlankNodes;
	//       Equal only compares the IRIs of such IRI Nodes.
	// Typical use case:
	//   Use this method to determine if two IBNode instances represent the same logical node in the graph,
	//   regardless of their memory address or instantiation.
	// TBD: blankNode comparison
	Equal(ib IBNode) bool

	// implements sort.Interface method.
	// Len() returns the number of triples of this IBNode.
	Len() int
	// Less() compares the order of two triples of this IBNode.
	Less(i int, j int) bool
	// Swap() changes the position of two triples of this IBNode.
	Swap(i int, j int)
	// contains filtered or unexported methods
}

type IRI string

type Int int32

type Integer int64

type LangString struct {
	Val     string
	LangTag string
}

type Literal interface {
	Term

	// DataType returns the DataType of this Literal as an IBNode.
	DataType() IBNode
	// contains filtered or unexported methods
}

type LiteralCollection interface {
	// TermKind() returns TermKindLiteralCollection
	Term

	// ForMembers invokes callback function e for each member in the collection.
	ForMembers(e func(int, Literal))

	// MemberCount returns the number of members in this ObjectionCollection.
	MemberCount() int

	// Member returns the member as the indicated position starting with 0 for the first position.
	// It will panic if the index is negative or if it is equal or greater than MemberCount().
	Member(index int) Literal

	// Values returns a slice of interface{} containing the values of the LiteralCollection.
	Values() []interface{}

	// DataType returns the DataType of this LiteralCollection as an IBNode.
	DataType() IBNode
}

type Long int64

type MergeAction struct {
	Type        MergeActionType `json:"type"`
	GraphID     string          `json:"graph_id,omitempty"`
	BaseIRI     string          `json:"base_iri,omitempty"`
	Description string          `json:"description,omitempty"`
	Result      string          `json:"result,omitempty"` // success / skipped / failed
	Timestamp   time.Time       `json:"timestamp"`
}

type MergeActionType string

type MoveAndMergeReport struct {
	Actions      []MergeAction  `json:"actions"`
	BetweenRepos bool           `json:"between_repos"`
	StageFrom    string         `json:"stage_from,omitempty"`
	StageTo      string         `json:"stage_to,omitempty"`
	StartTime    time.Time      `json:"start_time"`
	EndTime      time.Time      `json:"end_time"`
	Duration     time.Duration  `json:"duration"`
	Stats        map[string]int `json:"stats"`              // count of each kind of action
	Warnings     []string       `json:"warnings,omitempty"` // collect warnings
}

type NamedGraph interface {
	// Base returns the base IRI by which the NamedGraph is identified.
	// The IRIs of the IBNodes of the NamedGraph are constructed by concatenation the base IRI with IBNode.Fragment(), i.e. "urn:uuid:" + ID().
	IRI() IRI

	// ID returns named graph identifier as uuid.UUID.
	// If the IRI of this NamedGraph is of type a urn:uuid, the returned value is that uuid; typically a random uuid (version 4).
	// Otherwise, if the IRI is of any other type, the returned value is a NameSpaceURL hash uuid of that IRI (version 5).
	//
	// Deprecated: Use IRI() instead. NamedGraph is identified by its IRI.
	ID() uuid.UUID

	// IsValid indicates that this NamedGraph and its Stage are valid; so this NamedGraph is neither deleted nor its Stage is closed.
	IsValid() bool

	// A NamedGraph in a Stage, so one that is contained in Stage.NamedGraphs() is either in a referenced or a local state.
	// This state is indicated by IsReferenced(). If the returned value is false, this NamedGraph is in a local state.
	// IsReferenced returns true if this NamedGraph contains only IBNodes without any subject triple.
	// This happens when these IBNodes are only referenced by triples in other NamedGraphs within the same Stage,
	// and the owning NamedGraph is not imported.
	// As a consequence, a NamedGraph in referenced state is not written in to SST Repository during commit.
	IsReferenced() bool

	// IsEmpty() returns true if this NamedGraph does not contain any triples.
	// Note: Each NamedGraph has an implicit IBNode with empty fragment, representing the whole NamedGraph.
	IsEmpty() bool

	// IsModified() returns the modified state of this NamedGraph.
	IsModified() bool

	// BlankNodeCount returns the number of blank nodes in this graph
	// or error if blank nodes are not accessible by this graph.
	BlankNodeCount() int

	// IRINodeCount returns the number of IRI nodes in this graph.
	IRINodeCount() int

	// IRINodeCount returns the number of TermCollection in this graph.
	TermCollectionCount() int

	// ForAllIBNodes invokes callback function c for each of its IBNode for a given named graph.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForAllIBNodes(c ForEachNode) error

	// ForIRINodes calls given callback function c for reach IRI node.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForIRINodes(c ForEachNode) error

	// ForBlankNodes calls given callback function c for each blank node.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForBlankNodes(c ForEachNode) error

	// ForTermCollection calls given callback function c for each TermCollection.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForTermCollection(c func(TermCollection) error) error

	// ForUndefinedIBNodes is checking for IBNodes in this NamedGraph that do not have
	// any subject triple and therefore we do not know their rdf:type and invoke the callback function for them.
	// Note 1: The NG Node has a default rdf:type owl:Ontology and therefore is not considered undefined.
	// Note 2: Every IBNode must be involve in at least one triple to exist; otherwise it can't be
	//         represent in a rdf file. SST allows the existence of IBNodes that do not show up in any triple within that NamedGraph.
	//         This is not possible in any standard RDF formats e.g. Turtle.
	ForUndefinedIBNodes(c func(IBNode) error) error

	// GetSortedIBNodes returns all sorted IBNodes for this NamedGraph.
	// The result contains first all IRI Nodes sorted by their fragments and then all
	// blank Nodes sorted by their usages of IRI Nodes either directly or indirectly.
	// TBD: what will happen if the blank Nodes are not referenced by any IRI Nodes?
	GetSortedIBNodes() []IBNode

	// RdfWrite writes given NamedGraph to an rdf file with given name and of given format.
	// Currently, only the RDF format Turtle is supported.
	// The resulting file will contain a special NamedGraph-Node with empty fragment that represents the whole NamedGraph and that is of type owl:Ontology.
	// In addition, the NamedGraph-Node might have further owl:imports triples for the imported NamedGraphs.
	RdfWrite(w io.Writer, format RdfFormat) error

	// Stage returns the stage this named graph belongs to.
	Stage() Stage

	// CreateIRINode creates a new IRI IBNode with optional triples of rdf:type for the indicated types.
	// The parameter fragment indicates the fragment of the IRI Node to create.
	// If this value is an empty string, a new random UUID for the fragment is created.
	// Note: The special Node that represents the complete the NamedGraph also has an empty fragment, but it is created only implicitly and always
	// available when needed. This special NamedGraph-Node can be accessed by GetIRINodeByFragment() with empty string for the fragment parameter.
	CreateIRINode(fragment string, types ...Term) IBNode

	// CreateBlankNode creates a new blank node within the NamedGraph.
	// The returned blank node is not (yet) associated with any triple.
	CreateBlankNode(types ...Term) IBNode

	// CreateCollection returns a TermCollection, which is created by given members in the namedGraph.
	// A TermCollection with no member is treated in SST by rdf:nil.
	// a TermCollection is (at least in Turtle) treated as a BlankNode
	CreateCollection(members1 ...Term) TermCollection

	// GetIRINodeByFragment returns IBNode which is an IRI node with given fragment.
	GetIRINodeByFragment(fragment string) IBNode

	// GetBlankNodeByID returns IBNode which is a blank node with given id.
	GetBlankNodeByID(id uuid.UUID) IBNode

	// AddImport adds the NamedGraph ng to this NamedGraph.
	// When exporting to rdf/ttl, this is indicated by owl:imports.
	// Panic will be called if ng is already imported by this NamedGraph.
	AddImport(ng NamedGraph) error

	// RemoveImport removes the NamedGraph ng from this NamedGraph.
	// Panic will be called if ng is not imported by this NamedGraph.
	RemoveImport(ng NamedGraph) error

	// DirectImports returns directly imported NamedGraphs.
	DirectImports() []NamedGraph

	// FindCommonParentRevision searches for a common ancestor of this and the other NamedGraph and returns this.
	// For this, the two NamedGraphs must have the same IRI and needs to be opened in different Stages
	// that are both linked to the same Repository. Only then, it is possible to compare the two revisions of the
	// same NamedGraph.
	// This method traverses the revision history of both NamedGraphs in the Repository
	// by following the commit tree that contain information about the parents.
	// This method returns either this NamedGraph or the other NamedGraph or a 3rd NamedGraph
	// with the same IRI in a new 3rd Stage of the same Repository.
	// This method returns nil if there is no common parent revision.
	// Note: This method is used for three-way diff and merge.
	FindCommonParentRevision(ctx context.Context, other NamedGraph) NamedGraph

	// MoveIBNode moves the specified IBNode `s` from its owning NamedGraph to the receiver NamedGraph.
	// If an IBNode with the same fragment already exists in the target graph, it will result in panic.
	// If fragment is non-empty, it will be used for the new IRI of Node.
	// TODO: The NG Node (fragment="") cannot be moved, it will result in panic.
	// The function checks access permissions and ensures both graphs belong to the same stage before moving.
	// Returns an error if access is denied or the graphs are not in the same stage.
	// Note: MoveIBNode can also be used to renamed the fragment of an IRI Node within the same NamedGraph.
	MoveIBNode(s IBNode, fragment string) error

	// SstWrite writes NamedGraph into given writer using SST file format.
	SstWrite(w io.Writer) error

	// Empty() removes all IBNodes that are not referenced from other NamedGraphs in the same Stage.
	// Unlike the Delete() method, Empty() keeps the NamedGraph valid.
	Empty()

	// Delete() tries to remove a NamedGraph if it is not imported by any other NamedGraphs in the same Stage.
	// If the NamedGraph is imported by any other NamedGraphs in the same Stage, the error ErrNamedGraphIsImported is returned.
	// Otherwise, all IBNodes in this NamedGraph that are not referenced by IBNodes of other NamedGraphs are deleted.
	// If this NamedGraph still contains IBNodes that are referenced by IBNodes of other NamedGraphs, in the same Stage,
	// then this NamedGraph is turned into a referenced one. Otherwise, this NamedGraph is completely removed from the
	// Stage and NamedGraph.IsValid() will return false.
	// Note: If only the content of the NamedGraph to be removed, use Empty() method.
	//       When committing this Stage, a new DatasetRevision of this deleted NamedGraph is created, and the corresponding NamedGraphRevision
	//       filed is set to HashNil(). There is no new entry created in NamedGraphRevision bucket.
	//       Then, when this Dataset is accessed in future, Repository.Dataset() method could got this Dataset.
	//       But if Dataset.CheckoutCommit() or Dataset.CheckoutBranch() is called to load the commit that deleting this NamedGraph,
	//       error ErrDatasetHasBeenDeleted is returned.
	//       The history of this deleted NamedGraph is still kept and could be accessed by CheckoutCommit/CheckoutBranch its previous commits.
	Delete() error

	// Equal compares this NamedGraph with another NamedGraph for structural and content equality.
	// It compares the NamedGraph IRIs, all IRIs and blankNodes with all their subject triples.
	// Returns true if the graphs are equal, false otherwise.
	// Note: The two NamedGraphs need to be in different Stages to be identical.
	//       The memory addresses of IBNodes in the two NamedGraphs are different; different Stages don't share memory.
	// TBD: add blankNodes comparison
	Equal(ng NamedGraph) bool

	// Info returns a NamedGraphInfo struct containing statistics about this NamedGraph.
	// The info includes the number of direct imported graphs, the number of indirect imported graphs,
	// and the number of triples in the named graph.
	//
	// Returns:
	// - NamedGraphInfo: A struct containing the following fields:
	//   - NumberOfDirectImportedGraphs: The number of directly imported named graphs.
	//   - NumberOfIndirectImportedGraphs: The number of indirectly imported named graphs.
	//   - NumberOfTriples: The total number of triples in the named graph.
	//
	// The function performs the following steps:
	// 1. Initializes counters for direct imported graphs, indirect imported graphs, and triples.
	// 2. Counts the number of direct imported graphs by getting the length of the directImports map.
	// 3. Defines a recursive function to count the number of indirect imported graphs.
	// 4. Iterates over the directImports map and applies the recursive function to count indirect imports.
	// 5. Iterates over the triplexStorage slice and counts the number of triples.
	Info() NamedGraphInfo

	// SetCommits sets 0, 1, or many CheckoutCommit values that are to be used for further Commit operations
	// on the owning Stage resulting in new parent commits.
	// Note: This method is only to be used for NamedGraph in the fromStage in MoveAndMerge method or when manually merging is performed.
	//       In all other cases, SST takes care of all the correct parent commits when making a new commit.
	SetCommits(Commits ...Hash)

	// method for debugging purpose that prints out the content of this NamedGraph into os.Stderr.
	// Dump() will print all triples in a list format.
	// Example:
	// TTL format:
	// :b750eaf5-55ff-4679-bb82-2cb01c22d1b2	a	lci:Individual ;
	// 	    rdfs:label	"HelloWorld" .
	// Output:
	// 	2025/10/21 13:35:41 NamedGraph ID: eedb4dec-f20c-4a44-aeb4-57bc3f684798
	// 	2025/10/21 13:35:41 graph BaseURI: urn:uuid:eedb4dec-f20c-4a44-aeb4-57bc3f684798
	// 	2025/10/21 13:35:41 graph flags:  isReferenced: false
	// 	2025/10/21 13:35:41              trackPredicates: true    modified: true
	// 	2025/10/21 13:35:41 directImports ( 0 ) :
	// 	2025/10/21 13:35:41 stringNodes ( 1 ) :
	// 	2025/10/21 13:35:41 0
	// 	2025/10/21 13:35:41 ib: &{{<nil>} 0xc000b1e000 0 0 0}
	// 	2025/10/21 13:35:41 typedResource.typeOf: <nil>
	// 	2025/10/21 13:35:41 ib.triplexStart: 0 ib.triplexEnd: 0
	// 	2025/10/21 13:35:41 ib.flags: 0
	// 	2025/10/21 13:35:41 ib frag:
	// 	2025/10/21 13:35:41
	// 	2025/10/21 13:35:41 uuidNodes ( 1 ) :
	// 	2025/10/21 13:35:41 0
	// 	2025/10/21 13:35:41 ib: &{{0xc000bf3aa0} 0xc000b1e000 0 6 1}
	// 	2025/10/21 13:35:41 typedResource.typeOf: &{{<nil>} 0xc000b1e380 0 6 0}
	// 	2025/10/21 13:35:41 ib.triplexStart: 0 ib.triplexEnd: 6
	// 	2025/10/21 13:35:41 ib.flags: 1
	// 	2025/10/21 13:35:41 ib id: b750eaf5-55ff-4679-bb82-2cb01c22d1b2
	// 	2025/10/21 13:35:41
	// 	2025/10/21 13:35:41 graph triplexStorage ( 6 ):
	// 	2025/10/21 13:35:41 0
	// 	2025/10/21 13:35:41  subjectTriplex
	// 	2025/10/21 13:35:41  http://www.w3.org/1999/02/22-rdf-syntax-ns#type http://ontology.semanticstep.net/lci#Individual
	// 	2025/10/21 13:35:41 1
	// 	2025/10/21 13:35:41  subjectTriplex
	// 	2025/10/21 13:35:41  http://www.w3.org/2000/01/rdf-schema#label HelloWorld^^http://www.w3.org/2001/XMLSchema#string
	Dump()

	// method for debugging purpose that prints out all IBNodes with their triples into standard output.
	// PrintTriples() will print all triples in Subject-Predicate-Object format.
	// Example:
	// TTL format:
	// :b750eaf5-55ff-4679-bb82-2cb01c22d1b2	a	lci:Individual ;
	// 	    rdfs:label	"HelloWorld" .
	// Output:
	// 	IBNode: urn:uuid:eedb4dec-f20c-4a44-aeb4-57bc3f684798#b750eaf5-55ff-4679-bb82-2cb01c22d1b2
	// 	http://www.w3.org/1999/02/22-rdf-syntax-ns#type http://ontology.semanticstep.net/lci#Individual
	// 	IBNode: urn:uuid:eedb4dec-f20c-4a44-aeb4-57bc3f684798#b750eaf5-55ff-4679-bb82-2cb01c22d1b2
	// 	http://www.w3.org/2000/01/rdf-schema#label "HelloWorld"
	PrintTriples()
	// contains filtered or unexported methods
}

type NamedGraphInfo struct {
	// same as NamedGraph method IRI()
	Iri IRI
	// same as NamedGraph method ID()
	Id uuid.UUID
	// same as NamedGraph method IsReferenced()
	IsReferenced bool
	// same as NamedGraph method IsEmpty()
	IsEmpty bool
	// same as NamedGraph method IsModified()
	IsModified bool
	// same as NamedGraph method IRINodeCount()
	NumberOfIRINodes int
	// same as NamedGraph method BlankNodeCount()
	NumberOfBlankNodes int
	// same as NamedGraph method TermCollectionCount()
	NumberOfTermCollections int
	// the number of direct imported NamedGraphs by this NamedGraph
	NumberOfDirectImportedGraphs int
	// the number of direct and indirect imported NamedGraphs by this NamedGraph
	NumberOfAllImportedGraphs int

	// the number of subject triples in current Triplex structure in memory for this NamedGraph
	NumberOfSubjectTriples int

	// the number of predicate triples in current Triplex structure in memory for this NamedGraph
	NumberOfPredicateTriples int

	// the number of object triples in current Triplex structure in memory for this NamedGraph
	NumberOfObjectTriples int

	// the number of term collection triples in current Triplex structure in memory for this NamedGraph
	NumberOfTermCollectionTriples int

	// the commits of this NamedGraph
	// If the NamedGraph is a new one, then there is no Commit (yet).
	// If the NamedGraph was checked out from an SST Repository with history then there is exactly one NamedGraph.
	// After one or several MoveAndMerge invocations there might be several Commit entries.
	// After a successful invocation of the Stage method Commit() on a repository with history support; there will be exactly one entry.
	Commits []Hash

	// the NamedGraph Revision Hash of this NamedGraph
	// If this is a new NamedGraph, NamedGraphRevision and DatasetRevision will be HashNil() value.
	// Otherwise if the NamedGraph is loaded from a Repository with history,
	// then the NamedGraphRevision and DatasetRevision reflect the revision stored in the Repository.
	NamedGraphRevision Hash

	// the Dataset Revision Hash of this NamedGraph's corresponding Dataset
	DatasetRevision Hash
}

type Node interface {
	Term
	// IsTermCollection returns true if the IBNode is a term collection.
	// In this case, the IBNode can be converted into a TermCollection.
	// e.g.
	// var ib IBNode
	// if ib.IsTermCollection() {
	//    col := ib.(TermCollection)
	// }
	IsTermCollection() bool

	// IRI returns the IRI of this [Node].
	IRI() IRI
}

type RdfFormat int

type Repository interface {
	// URL returns the specific location where this repository is stored.
	// For a remote main repository (not an item in a SuperRepository) the returned URL has NO FRAGMENT.
	// For a remote repository that is an item in a SuperRepository the returned URL has a Fragment that is the name/id of the repository.
	// For a local repository the returned URL is URL for the local path (normal/default or item in a super repository).
	URL() string

	// SuperRepository() either returns the SuperRepository this Repository belongs to or otherwise return a nil value.
	SuperRepository() SuperRepository

	// OpenStage(DefaultTriplexMode) will create an empty stage to work on persistent data in this SST Repository to which it is linked to.
	// Linking means that data can be loaded from the SST Repository to the Stage and written back to it.
	// As a result, Datasets from this Repository can be loaded, modified, committed or created anew to this SST Repository.
	// TODO: Several Stages for the same Repository can be opened.
	OpenStage(mode TriplexMode) Stage

	// ForDatasets calls given callback function c for each Dataset in the Repository.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForDatasets(ctx context.Context, c func(ds Dataset) error) error

	// ForDocuments calls given callback function c for each DocumentInfo in the Repository.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForDocuments(ctx context.Context, c func(d DocumentInfo) error) error

	// Datasets retrieves all dataset IRIs from the SST Repository.
	// If there is no Dataset stored in the Repository, an empty slice will be returned.
	Datasets(ctx context.Context) ([]IRI, error)

	// Dataset returns the existing Dataset from the Repository.
	Dataset(ctx context.Context, iri IRI) (Dataset, error)

	// CommitDetails returns commit metadata for the given list of commit hashes.
	CommitDetails(ctx context.Context, hashes []Hash) ([]*CommitDetails, error)

	// A new created sst.Repository has initially no indexMapping, meaning there is no query functionality.
	// RegisterIndexHandler checks if the provided DerivePackageVersion is same with the DerivePackageVersion in the Repository.
	// If they are different,  the complete recreation of the bleve index will be performed.
	// Application might use the default index mapping provided by defaultderive.DeriveInfo()
	// or create their own specific index mapping.
	// IndexMapping can be empty SSTDeriveInfo struct to remove an existing bleve index.
	// RegisterIndexHandler is only available for local Repositories.
	// Remote repository has predefined index handler which can modified/recreated only on the installation/deployment level.
	// When the Repository is a member of a SuperRepository, this will return ErrNotAvailable.
	RegisterIndexHandler(*SSTDeriveInfo) error

	// Bleve() returns the bleve index if one is registered.
	// A nil value is returned if no one is registered.
	// For Remote Repository, it returns the bleve client. So there is no need to add context parameter.
	Bleve() bleve.Index

	// Close closes the Repository
	Close() error

	// Info returns basic information about the repository content and history.
	// If the the branchName is an empty string, then NumberOfDatasetsInBranch contains those Datasets that are in any branch.
	// Otherwise, NumberOfDatasetsInBranch lists only those Datasets that are in the specified branch.
	Info(ctx context.Context, branchName string) (RepositoryInfo, error)

	// Log returns a list of log entries.
	//
	// Parameters:
	// - `start`: the starting logKey (inclusive). If nil or 0, starts from the latest logKey.
	// - `end`:
	//     - If negative, returns at most `-end` entries.
	//     - If positive, defines the exclusive lower bound (entries with logKey > end will be returned).
	//       That is, entries with logKey ≤ end will be excluded.
	//
	// Behavior Examples:
	//   start=nil, end=-100      → return the latest 100 entries
	//   start=123456, end=-50    → return 50 entries from logKey 123456 down to 123407 (inclusive)
	//   start=123, end=100       → return entries from 123 down to 101 (inclusive); excludes 100
	//   start=nil, end=nil       → return all entries from latest to earliest
	Log(ctx context.Context, start, end *int) ([]RepositoryLogEntry, error)

	// ExtractSstFile extracts a particular revision of a NamedGraph into a io.Writer that will create a SST-file.
	ExtractSstFile(ctx context.Context, namedGraphRevision Hash, w io.Writer) error

	// Only used in remoteRepository and LocalFullRepository.
	// For RemoteRepository, it can sync from a LocalFullRepository to the method receiver.
	// For LocalFullRepository, it can sync from a RemoteRepository to the method receiver.
	// Options can be used to specify which datasets and branches to sync:
	// - If no options are provided, syncs all datasets and all branches.
	// - Use WithDatasetIRIs() to specify which datasets to sync (including their imported dependencies).
	// - Use WithBranch() to specify which branch to sync (use "*" or empty string for all branches).
	SyncFrom(ctx context.Context, from Repository, options ...SyncOption) error

	// DocumentSet stores the given document in the repository and returns its hash.
	// The document is read from source and associated with the provided MIME type.
	DocumentSet(ctx context.Context, MIMEType string, source *bufio.Reader) (Hash, error)

	// Document retrieves the document with the given hash and writes it to target.
	// It returns the associated document info.
	// If target is nil, then only the DocumentInfo is returned
	Document(ctx context.Context, hash Hash, target io.Writer) (*DocumentInfo, error)

	// Documents returns a list of all document metadata stored in the repository.
	Documents(ctx context.Context) ([]DocumentInfo, error)

	// DocumentDelete removes the document content and its DocumentInfo from the repository using the given hash.
	DocumentDelete(ctx context.Context, hash Hash) error
	// contains filtered or unexported methods
}

type RepositoryInfo struct {
	URL                         string `json:"url"`
	AccessRight                 string `json:"AccessRight"`
	MasterDBSize                int    `json:"masterDBSize"`  // BboltSize
	DerivedDBSize               int    `json:"derivedDBSize"` // BleveSize
	DocumentDBSize              int    `json:"documentDBSize"`
	NumberOfDatasets            int    `json:"numberOfDatasets"`
	NumberOfDatasetsInBranch    int    `json:"numberOfDatasetsInBranch"`
	NumberOfDatasetRevisions    int    `json:"numberOfDatasetRevisions"`
	NumberOfNamedGraphRevisions int    `json:"numberOfNamedGraphRevisions"`
	NumberOfCommits             int    `json:"numberOfCommits"`
	NumberOfRepositoryLogs      int    `json:"NumberOfRepositoryLogs"`
	NumberOfDocuments           int    `json:"NumberOfDocuments"`
	IsRemote                    bool   `json:"isRemote"`
	SupportRevisionHistory      bool   `json:"supportRevisionHistory"`
	BleveName                   string `json:"bleveName"`
	BleveVersion                string `json:"bleveVersion"`
	VersionHash                 string `json:"versionHash"`
}

type RepositoryLogEntry struct {
	LogKey uint64
	Fields map[string]string // timestamp, type, commit_id, message, ...
}

type RepositoryServer struct {
	*grpc.Server
	// contains filtered or unexported fields
}

type RepositoryServerConfig struct {
	RepoDir    string           // repository folder
	Issuer     string           // OIDC issuer URL
	ClientID   string           // OIDC client ID
	ServerCert *tls.Certificate // tls.Certificate
	Verbose    bool             // verbose log output, the value is a bool value, default false
	DeriveInfo *SSTDeriveInfo   `json:"-"` //the bleve configuration(mapping)
}

type SSTDeriveInfo struct {
	DerivePackageName    string                                                                                                                      `json:"DerivePackageName"`
	DerivePackageVersion string                                                                                                                      `json:"DerivePackageVersion"`
	DefaultIndexMapping  func() *mapping.IndexMappingImpl                                                                                            `json:"-"`
	DeriveDocuments      func(r Repository, g NamedGraph) (id string, document map[string]interface{}, preConditionQueries []query.Query, err error) `json:"-"`
}

type Short int16

type Stage interface {
	// Creates a NamedGraph in this Stage whose name is the provided IRI.
	// Note that the NamedGraph IRI must be unique within the Stage and also unique within the linked Repository.
	// The ID of the created NamedGraph will be a hash UUID (version 5) of the IRI of this NamedGraph.
	// A created NamedGraph is in local state(NamedGraph.IsReferenced() will return false).
	// e.g.
	// ng := stage.CreateNamedGraph(sst.IRI("http://example.com/test1"))
	CreateNamedGraph(iri IRI) NamedGraph

	// NamedGraph returns the local NamedGraph for the specified IRI.
	// If the NamedGraph with the IRI is not used in the Stage then the nil value is returned.
	NamedGraph(iri IRI) NamedGraph

	// NamedGraphs returns a slice of all local NamedGraphs in this Stage.
	// The returned slice does not contain Referenced NamedGraphs.
	// The returned slice might be empty.
	NamedGraphs() []NamedGraph

	// ReferencedGraph returns the Referenced NamedGraph for the specified base URI.
	// If the NamedGraph with the baseIRI is not used in the Stage then the nil value is returned.
	ReferencedGraph(iri IRI) NamedGraph

	// ReferencedGraphs returns a slice of all referenced NamedGraph in this Stage.
	// The returned slice does not contain loaded NamedGraphs.
	// The returned slice might be empty.
	ReferencedGraphs() []NamedGraph

	// ForNamedGraphs loops through all NamedGraphs in this Stage that are not in Referenced state
	// and invokes the callback function c for each of them.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForNamedGraphs(c func(ng NamedGraph) error) error

	// ForReferencedNamedGraphs loops through all referenced NamedGraphs in this Stage
	// and invokes the callback function c for each of them.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	ForReferencedNamedGraphs(c func(ng NamedGraph) error) error

	// IsValid returns true if the Stage is valid and represents the non-zero value of Stage type.
	// Methods such as MoveAndMerge() results in invalid Stages.
	// References to invalid Stages should be removed so that they can be taken care by garbage collector.
	IsValid() bool

	// Repository returns the SST [Repository] this Stage is linked to.
	Repository() Repository

	// Commit is saving all changes of the [NamedGraph]s and [IBNode]s in this Stage into the linked repository.
	// For each modified NamedGraph a new NamedGraphRevision is created.
	// Corresponding DatasetRevisions are created for each new NamedGraphRevisions or if one of the imported NamedGraphs has changed.
	// if branchName is an empty string, then the branchNames for each modified Dataset in the target repository is not changed.
	// if branchName is not an empty string, then for each modified Dataset with a branchName is set respectively moved
	// to the new Dataset Revision. Note: The specified branchName might be a new one.
	// If the stage is ephemeral (not linked to a repository), error sst.ErrStageNotLinkToRepository is returned.
	// Other errors may be returned from the underlying file system or connection to a remote repository.
	// If this method is successful, a Hash value is returned that identifies the commit together with the new DatasetRevisions.
	Commit(ctx context.Context, message string, branchName string) (Hash, []uuid.UUID, error)

	// MoveAndMerge tries to automatically move and merges all NamedGraphs and referenced graphs from the source Stage (`from`) into the target Stage (`to`).
	// After merging, the source Stage is cleared of all local and referenced graphs.
	// If a source NamedGraph does not exist in the target Stage, it is taken as it is.
	// If a source NamedGraph does exist in the target Stage, this method tries to merge these two NamedGraphs.
	// For merging two NamedGraph revisions, this method tries to find a common ancestor in the revision history in the Repository of the target Stage.
	// If a common ancestor is found:
	// 	1. if fromNG is a xxx-parent of the toNG, keep te toNG, and skip the fromNG
	// 	2. if the toNG is a xxx-parent of the fromNG, replace the toNG by the the fromNG
	// 	3. TBD: otherwise, use a common parent to perform a 3-diff merge
	// If no common ancestor is found, the fromNG is merged into the toNG by adding all IBNodes and triples from the fromNG into the toNG.
	// Returns:
	//   *MoveAndMergeReport - A report with detailed statistics about moved, merged, and deleted graphs/nodes.
	//   error               - An error if the operation fails.
	//
	// Typical usage:
	//   report, err := stage.MoveAndMerge(ctx, fromStage)
	//   if err != nil {
	//       // handle error
	//   }
	//   fmt.Println(report)
	MoveAndMerge(ctx context.Context, from Stage) (*MoveAndMergeReport, error)

	// ForUndefinedIBNodes is looping through all local NamedGraphs for IBNodes that do not have any subject triple
	// and invoke callback function for them. The undefined IBNodes might be referenced as predicate or object in the same NamedGraph or not.
	// In case the callback function c returns an error, the loop terminates and this method
	// is returning this error.
	// Note: SST allows the existence of IBNodes that do not show up in any triple within that NamedGraph.
	//       This is not possible in any standard RDF formats e.g. Turtle.
	ForUndefinedIBNodes(c func(IBNode) error) error

	// IBNodeByVocabulary locates the IBNode with the IRI for the specified vocabulary element.
	IBNodeByVocabulary(t Elementer) (IBNode, error)

	// Close() ensures that all memory allocated by the stage is released and can be taken away by garbage collection.
	// After calling this method, the stage can no longer be used and it is invalid.
	// TODO: ensure all underlying objects become invalid
	Close()

	// WriteToSstFiles writes this Stage data to the specified directory.
	//
	// Parameters:
	//   - stageDir: The filesystem directory where the stage data will be written.
	//
	// Returns:
	//   - err: An error if the write operation fails, otherwise nil.
	WriteToSstFiles(stageDir fs.FS) (err error)

	// WriteToSstFilesWithBaseURL writes this Stage data to the specified directory using the graph's base URL as filename.
	// Unlike WriteToSstFiles which uses UUIDs as filenames, this function uses a base64-encoded version of the base URL
	// portion of each graph's IRI. This ensures the filename is filesystem-safe while being reversible.
	//
	// Parameters:
	//   - stageDir: The filesystem directory where the stage data will be written.
	//
	// Returns:
	//   - err: An error if the write operation fails, otherwise nil.
	WriteToSstFilesWithBaseURL(stageDir fs.FS) (err error)

	// Info returns a StageInfo struct containing information about the Stage.
	// The information include the number of local graphs, the number of referenced graphs,
	// and the total number of triples across all local graphs.
	//
	// Returns:
	// - StageInfo: A struct containing the following fields:
	//   - NumberOfLocalGraphs: The number of local named graphs in the stage.
	//   - NumberOfReferencedGraphs: The number of referenced named graphs in the stage.
	//   - TotalNumberOfTriples: The total number of triples across all local named graphs.
	//
	// The function performs the following steps:
	// 1. Initializes counters for local graphs, referenced graphs, and total triples.
	// 2. Counts the number of local graphs by getting the length of the localGraphs map.
	// 3. Counts the number of referenced graphs by getting the length of the referencedGraphs map.
	// 4. Iterates over the localGraphs map and sums the number of triples from each graph's Info method.
	Info() StageInfo

	// Dump prints the repository information and dumps all localGraphs to the standard error output.
	// It logs the index of each graph before dumping it.
	Dump()

	// RdfWrite writes all NamedGraphs in this Stage to the given writer in the specified RDF format.
	// Currently supports RdfFormatTriG which allows exporting multiple named graphs in a single file.
	// For RdfFormatTurtle, only the first NamedGraph will be written (use NamedGraph.RdfWrite instead).
	RdfWrite(w io.Writer, format RdfFormat) error
	// contains filtered or unexported methods
}

type StageInfo struct {
	NumberOfLocalGraphs      int
	NumberOfReferencedGraphs int
	// total count of all three kinds of triples of local NamedGraphs?
	// or separated count?
	TotalNumberOfTriples int
}

type String string

type SuperRepository interface {
	// URL returns the specific location where this SuperRepository is stored.
	// For a remote SuperRepository the returned URL uses grpc:// scheme.
	// For a local SuperRepository the returned URL uses file:// scheme.
	URL() string

	// Get retrieves an existing repository by name from the SuperRepository.
	// If name is empty, it returns the "default" repository.
	// Returns an error if the repository does not exist.
	Get(ctx context.Context, name string) (Repository, error)

	// Create creates a new repository with the given name in the SuperRepository.
	// Returns an error if a repository with the same name already exists.
	// The created repository is automatically opened and ready for use.
	Create(ctx context.Context, name string) (Repository, error)

	// Delete removes a repository by name from the SuperRepository.
	// If name is empty, it deletes the "default" repository.
	// This operation permanently removes all data in the repository.
	Delete(ctx context.Context, name string) error

	// List returns the names of all repositories in the SuperRepository.
	// The returned slice is sorted alphabetically.
	List(ctx context.Context) ([]string, error)

	// RegisterIndexHandler registers a Bleve index handler for all sub-repositories
	// in this SuperRepository. Similar to Repository.RegisterIndexHandler but applies
	// to all repositories managed by this SuperRepository.
	// Returns an error if index registration fails.
	RegisterIndexHandler(*SSTDeriveInfo) error

	// Close releases all resources, including closing all opened sub-Repositories.
	// Any error encountered while closing individual repositories is returned.
	Close() error
}

type SuperRepositoryServer struct {
	*grpc.Server
	// contains filtered or unexported fields
}

type SyncOption func(*SyncOptions)

type SyncOptions struct {
	// DatasetIDs is a list of dataset UUIDs to sync.
	// If nil or empty, all datasets will be synced.
	DatasetIDs []uuid.UUID

	// BranchName specifies the branch to sync.
	// Empty string "" or "*" means sync all branches.
	// Otherwise, it specifies a particular branch name (e.g., "master").
	BranchName string
}

type Term interface {
	// Method [Term.TermKind] returns the kind of this Term which is one of
	//   - [TermKindIBNode]
	//   - [TermKindLiteral]
	//   - [TermKindTermCollection]
	//   - [TermKindLiteralCollection]
	TermKind() TermKind
}

type TermCollection interface {
	Node

	// ForMembers invokes callback function e for each member in the collection.
	ForMembers(e func(int, Term))

	// Members returns the members of this ObjectionCollection as a slice.
	Members() []Term

	// MemberCount returns the number of members in this ObjectionCollection.
	MemberCount() int

	// Member returns the member as the indicated position starting with 0 for the first position.
	// It will panic if the index is negative or if it is equal or greater than MemberCount().
	Member(index int) Term

	// SetMembers removes the current members of this TermCollection and set all members anew.
	SetMembers(members ...Term)

	// ID returns the UUID value of this TermCollection, which is a Random (Version 4) UUID .
	ID() uuid.UUID
}

type TermKind = int

type TriplexMode int

type TypedString struct {
	Val  string
	Type Node
}

type UnsignedByte uint8

type UnsignedInt uint32

type UnsignedLong uint64

type UnsignedShort uint16

type Vocabulary struct {
	BaseIRI string // the unique base URI of the externally defined ontology
}