infrahub

README

Infrahub Go SDK

An idiomatic Go client and command-line tool for Infrahub, inspired by the official Python SDK.

This project is an early port. It currently provides the transport foundation, arbitrary GraphQL execution, branch management, schema APIs, and dynamic node mutations. Specialized Python SDK features are tracked in the roadmap below.

Install

go get github.com/Helvethink/infrahub-go-sdk

Client

client, err := infrahub.NewClient(
    "https://infrahub.example.com",
    infrahub.WithAPIToken(os.Getenv("INFRAHUB_API_TOKEN")),
    infrahub.WithDefaultBranch("main"),
)
if err != nil {
    log.Fatal(err)
}

branches, err := client.Branches.List(context.Background())

All network operations accept context.Context. A client is safe for concurrent use, and branch selection is request-scoped.

Packages

• infrahub: client facade and configuration
• pkg/batch: generic bounded concurrent execution
• pkg/api: low-level HTTP and GraphQL protocol
• pkg/automation: Go-native transforms, generators and checks
• pkg/branch: branch lifecycle and types
• pkg/diff: branch diff summaries and complete trees
• pkg/schema: schema discovery, validation, and loading
• pkg/task: background-task filtering and polling
• pkg/traversal: graph paths and reachable nodes
• pkg/config: strict TOML and environment configuration
• pkg/node: generic operations for schema-defined objects
• pkg/objectstore: stored objects and text-file retrieval
• pkg/repository: repository discovery and commit tracking
• pkg/resourcepool: IP address/prefix allocation and utilization
• pkg/tracking: request trackers and group collection
• cmd/infrahubctl: executable entry point
• internal/cli: testable, non-public CLI implementation

Most applications should import only the root package. Packages under pkg/ are available for deliberate advanced use; implementation details remain under internal/.

See the Python SDK porting map for implemented and planned capabilities.

Development

Community contributions are welcome. See CONTRIBUTING.md for the development workflow, coding guidelines, test requirements, and pull request checklist.

make check
make race
make build

make check verifies formatting, runs go vet, runs golangci-lint, and executes all unit and facade tests. This check is mandatory after adding a feature.

CLI

Build the command with make build, or install it directly:

go install github.com/Helvethink/infrahub-go-sdk/cmd/infrahubctl@latest

Configuration uses flags or environment variables:

export INFRAHUB_ADDRESS=https://infrahub.example.com
export INFRAHUB_API_TOKEN=...

infrahubctl branch list
infrahubctl branch create --description "SDK work" sdk-work
infrahubctl object validate objects/
infrahubctl object load objects/ --branch sdk-work
infrahubctl task list --state running --limit 10
infrahubctl repository list
infrahubctl schema graphql > schema.graphql
printf 'query { Branch { name } }' | infrahubctl graphql

Run infrahubctl help for the complete command list.

Structured zap logs are written to stderr and never mixed with JSON results on stdout. Set --log-level info or INFRAHUB_LOG_LEVEL=info to log command lifecycle events; the default level is error.

TOML configuration is also supported from the platform user configuration directory, INFRAHUB_CONFIG, INFRAHUBCTL_CONFIG, or -config. See the configuration guide for the file format and precedence rules.

Dynamic GraphQL

Infrahub generates a GraphQL schema for each data schema and branch. Use Execute for arbitrary queries:

var result struct {
    Tags []struct {
        ID string `json:"id"`
    } `json:"BuiltinTag"`
}

err := client.Execute(ctx, infrahub.GraphQLRequest{
    Query: `query Tags { BuiltinTag { id } }`,
    OperationName: "Tags",
    Branch: "main",
}, &result)

If a GraphQL response contains both data and errors, data is decoded and the returned error can be inspected with errors.As as *infrahub.GraphQLError.

Dynamic nodes

tag, err := client.Nodes.Create(ctx, "BuiltinTag", map[string]any{
    "name":        map[string]any{"value": "staging"},
    "description": map[string]any{"value": "Staging resources"},
}, "main")

Dynamic filters and nested selections are available through client.Nodes.Query. See the dynamic query guide.

Repositories

repositories, err := client.Repositories.List(ctx, infrahub.RepositoryListOptions{
    Branches: []string{"main", "staging"},
})

Repository discovery aggregates commits and internal status across branches. Commit updates are also supported. See the repository guide.

Tracking

group, err := tracking.NewGroup(tracking.GroupOptions{Identifier: "inventory-import"})
ctx = group.Context(tracking.WithTracker(ctx, "inventory-import"))

_, err = client.Nodes.List(ctx, "BuiltinTag", 0, 100, "main")
result, err := group.Save(ctx, client)

Tracking is request-scoped and safe for concurrent workflows. See the tracking and group-context guide.

Object and file storage

uploaded, err := client.ObjectStore.Upload(ctx, "generated configuration")
content, err := client.ObjectStore.Get(ctx, uploaded.Identifier)
file, err := client.ObjectStore.GetFileByID(ctx, nodeID)

Stored objects and text-file endpoints preserve base paths, escape identifiers, and honor response-size limits. See the object-store guide.

Tasks

tasks, err := client.Tasks.All(ctx, infrahub.TaskListOptions{
    Filter: infrahub.TaskFilter{States: []infrahub.TaskState{
        infrahub.TaskStateRunning,
    }},
})

task, err := client.Tasks.Wait(ctx, taskID, time.Second)

Task filters, logs, related nodes, pagination and cancellation-aware polling are supported. See the tasks guide.

Batches

results, err := batch.Map(ctx, nodeIDs, func(ctx context.Context, id string) (*infrahub.Node, error) {
    return client.Nodes.GetByID(ctx, "BuiltinDevice", id, "main")
}, batch.Options{Concurrency: 5})

Batch results retain input indexes and support fail-fast or per-result error collection. See the batches guide.

IP address and prefix pools

prefixLength := 32
address, err := client.ResourcePools.AllocateAddress(ctx, infrahub.ResourcePoolAddressOptions{
    PoolID:       poolID,
    Identifier:   "loopback-edge-01",
    PrefixLength: &prefixLength,
    AddressKind:  "IpamIPAddress",
    Branch:       "main",
})

Prefix allocation, allocation history and utilization are also supported. See the resource-pool guide.

Diffs

tree, err := client.Diffs.Tree(ctx, infrahub.DiffOptions{
    Branch: "feature/inventory",
})

Node summaries, complete metadata, time ranges, attributes, relationships and peer changes are supported. See the diff guide.

Graph traversal

paths, err := client.Traversal.Paths(ctx, infrahub.TraversalPathsOptions{
    SourceID:      sourceID,
    DestinationID: destinationID,
    Branch:        "main",
})

Path existence, filters, point-in-time traversal and reachable-node discovery are supported on Infrahub 1.10+. See the graph traversal guide.

Automation extensions

result, err := client.Automation.RunCheck(ctx, infrahub.AutomationRunOptions{
    Query: infrahub.AutomationQueryOptions{Name: "check_input", Branch: "main"},
}, func(ctx context.Context, data map[string]any, report *infrahub.AutomationReporter) error {
    report.Error("management address is missing", nodeID, "DcimDevice")
    return nil
})

Transforms, idempotent generators and structured checks are implemented as compiled Go extension points. See the automation guide.

Current scope

• GraphQL transport, authentication, trackers, branch/time routing, and partial errors
• Branch list/get/create/delete/rebase/validate/merge and diff data
• Schema fetch, SDL export, validation, and loading
• Generic node create/update/delete
• Generic node list/get-by-ID/get-by-HFID with offset pagination
• Repository discovery across branches and protected commit updates
• Request-scoped tracker overrides and concurrent tracking groups
• Stored object upload/download and text-file retrieval by storage ID, node ID, or HFID
• Background-task filtering, pagination, lookup, counts, logs and polling
• Generic bounded batches with cancellation and configurable error collection
• IP address/prefix allocation, allocation history and pool utilization
• Branch diff summaries and complete diff trees
• Graph path traversal, connectivity checks and reachable-node discovery
• Go-native transforms, tracked generators and structured checks

Planned ports include schema-aware custom-field query construction, graph traversal, diffs, IP resource allocation, object/file storage, tasks, batches, and tracking. Python-only runtime features such as Jinja transforms and pytest plugins will not be copied into the core Go library.

Documentation

Overview

Package infrahub provides an idiomatic Go client for the Infrahub API.

Infrahub schemas are dynamic and branch-specific. The Client therefore exposes both typed services for stable Infrahub operations and Execute for arbitrary GraphQL operations against user-defined schemas.

Index

• Constants
• func WithTracker(ctx context.Context, tracker string) context.Context
• type AutomationCheck
• type AutomationCheckResult
• type AutomationFinding
• type AutomationGenerator
• type AutomationQueryOptions
• type AutomationReporter
• type AutomationRunOptions
• type AutomationService
• type AutomationSeverity
• type AutomationTransform
• type Branch
• type BranchCreateOptions
• type BranchService
• type BranchStatus
• type Client
  • func NewClient(address string, options ...Option) (*Client, error)
  • func (c *Client) DefaultBranch() string
  • func (c *Client) Execute(ctx context.Context, request GraphQLRequest, dst any) error
• type DiffAction
• type DiffCounts
• type DiffElement
• type DiffElementType
• type DiffNode
• type DiffOptions
• type DiffPeer
• type DiffService
• type DiffTree
• type GraphQLError
• type GraphQLErrorItem
• type GraphQLErrorLocation
• type GraphQLRequest
• type HTTPError
• type Node
• type NodeMutationResult
• type NodePage
• type NodeService
• type NotFoundError
• type ObjectStoreService
• type ObjectStoreUnsupportedContentTypeError
• type ObjectStoreUploadResult
• type OperationError
• type Option
  • func WithAPIToken(token string) Option
  • func WithDefaultBranch(branch string) Option
  • func WithHTTPClient(hc *http.Client) Option
  • func WithHeader(name, value string) Option
  • func WithMaxResponseBytes(n int64) Option
  • func WithUserAgent(userAgent string) Option
• type Repository
• type RepositoryBranchState
• type RepositoryListOptions
• type RepositoryService
• type RepositoryUpdateCommitOptions
• type ResourcePoolAddressOptions
• type ResourcePoolAllocatedOptions
• type ResourcePoolAllocation
• type ResourcePoolAllocationPage
• type ResourcePoolMemberType
• type ResourcePoolPrefixOptions
• type ResourcePoolService
• type ResourcePoolUtilization
• type ResourcePoolUtilizationResult
• type SchemaService
• type Task
• type TaskAmbiguousError
• type TaskFilter
• type TaskListOptions
• type TaskLog
• type TaskPage
• type TaskRelatedNode
• type TaskService
• type TaskState
• type TrackingGroup
  • func NewTrackingGroup(options TrackingGroupOptions) (*TrackingGroup, error)
• type TrackingGroupOptions
• type TrackingGroupResult
• type TraversalHop
• type TraversalNode
• type TraversalPath
• type TraversalPathsOptions
• type TraversalPathsResult
• type TraversalReachableNode
• type TraversalReachableOptions
• type TraversalReachableResult
• type TraversalRelationship
• type TraversalService
• type TraversalUnsupportedError

Constants

const (
	AutomationSeverityInfo    = automation.SeverityInfo
	AutomationSeverityWarning = automation.SeverityWarning
	AutomationSeverityError   = automation.SeverityError
)

const (
	DiffActionAdded     = diffservice.ActionAdded
	DiffActionUpdated   = diffservice.ActionUpdated
	DiffActionRemoved   = diffservice.ActionRemoved
	DiffActionUnchanged = diffservice.ActionUnchanged
	DiffActionConflict  = diffservice.ActionConflict
)

const (
	DiffElementTypeAttribute        = diffservice.ElementTypeAttribute
	DiffElementTypeRelationshipOne  = diffservice.ElementTypeRelationshipOne
	DiffElementTypeRelationshipMany = diffservice.ElementTypeRelationshipMany
)

const (
	ResourcePoolMemberTypePrefix  = resourcepool.MemberTypePrefix
	ResourcePoolMemberTypeAddress = resourcepool.MemberTypeAddress
)

const (
	TaskStateScheduled  = task.StateScheduled
	TaskStatePending    = task.StatePending
	TaskStateRunning    = task.StateRunning
	TaskStateCompleted  = task.StateCompleted
	TaskStateFailed     = task.StateFailed
	TaskStateCancelled  = task.StateCancelled
	TaskStateCrashed    = task.StateCrashed
	TaskStatePaused     = task.StatePaused
	TaskStateCancelling = task.StateCancelling
)

const (
	BranchStatusOpen              = branch.StatusOpen
	BranchStatusNeedRebase        = branch.StatusNeedRebase
	BranchStatusNeedUpgradeRebase = branch.StatusNeedUpgradeRebase
	BranchStatusDeleting          = branch.StatusDeleting
	BranchStatusMerging           = branch.StatusMerging
	BranchStatusMerged            = branch.StatusMerged
)

Functions

func WithTracker

func WithTracker(ctx context.Context, tracker string) context.Context

WithTracker returns a child context carrying a request tracker override.

Types

type AutomationCheck

type AutomationCheck = automation.Check

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationCheckResult

type AutomationCheckResult = automation.CheckResult

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationFinding

type AutomationFinding = automation.Finding

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationGenerator

type AutomationGenerator = automation.Generator

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationQueryOptions

type AutomationQueryOptions = automation.QueryOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationReporter

type AutomationReporter = automation.Reporter

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationRunOptions

type AutomationRunOptions = automation.RunOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationService

type AutomationService = automation.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationSeverity

type AutomationSeverity = automation.Severity

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type AutomationTransform

type AutomationTransform = automation.Transform

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type Branch

type Branch = branch.Branch

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type BranchCreateOptions

type BranchCreateOptions = branch.CreateOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type BranchService

type BranchService = branch.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type BranchStatus

type BranchStatus = branch.Status

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type Client

type Client struct {
	Branches      *branch.Service
	Automation    *automation.Service
	Diffs         *diffservice.Service
	Schema        *schema.Service
	Nodes         *node.Service
	Repositories  *repository.Service
	ResourcePools *resourcepool.Service
	ObjectStore   *objectstore.Service
	Tasks         *task.Service
	Telemetry     *telemetry.Service
	Traversal     *traversal.Service
	// contains filtered or unexported fields
}

Client is the high-level Infrahub client. It is safe for concurrent use. Its services share immutable configuration and one HTTP connection pool.

func NewClient

func NewClient(address string, options ...Option) (*Client, error)

NewClient creates an Infrahub client for address.

func (*Client) DefaultBranch

func (c *Client) DefaultBranch() string

DefaultBranch returns the client's default branch.

func (*Client) Execute

func (c *Client) Execute(ctx context.Context, request GraphQLRequest, dst any) error

Execute runs an arbitrary GraphQL operation. If GraphQL returns both data and errors, Execute decodes data into dst and returns *api.GraphQLError.

type DiffAction

type DiffAction = diffservice.Action

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffCounts

type DiffCounts = diffservice.Counts

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffElement

type DiffElement = diffservice.Element

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffElementType

type DiffElementType = diffservice.ElementType

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffNode

type DiffNode = diffservice.Node

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffOptions

type DiffOptions = diffservice.Options

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffPeer

type DiffPeer = diffservice.Peer

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffService

type DiffService = diffservice.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type DiffTree

type DiffTree = diffservice.Tree

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type GraphQLError

type GraphQLError = api.GraphQLError

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type GraphQLErrorItem

type GraphQLErrorItem = api.GraphQLErrorItem

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type GraphQLErrorLocation

type GraphQLErrorLocation = api.GraphQLErrorLocation

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type GraphQLRequest

type GraphQLRequest = api.GraphQLRequest

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type HTTPError

type HTTPError = api.HTTPError

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type Node

type Node = node.Node

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type NodeMutationResult

type NodeMutationResult = node.MutationResult

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type NodePage

type NodePage = node.Page

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type NodeService

type NodeService = node.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type NotFoundError

type NotFoundError = api.NotFoundError

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ObjectStoreService

type ObjectStoreService = objectstore.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ObjectStoreUnsupportedContentTypeError

type ObjectStoreUnsupportedContentTypeError = objectstore.UnsupportedContentTypeError

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ObjectStoreUploadResult

type ObjectStoreUploadResult = objectstore.UploadResult

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type OperationError

type OperationError = api.OperationError

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type Option

type Option func(*config) error

Option configures a Client.

func WithAPIToken

func WithAPIToken(token string) Option

WithAPIToken configures authentication through X-INFRAHUB-KEY.

func WithDefaultBranch

func WithDefaultBranch(branch string) Option

WithDefaultBranch sets the branch used when an operation does not specify one.

func WithHTTPClient

func WithHTTPClient(hc *http.Client) Option

WithHTTPClient makes the client use hc. The SDK does not mutate hc.

func WithHeader

func WithHeader(name, value string) Option

WithHeader adds a header to every request. Authentication headers cannot be set through this option; use WithAPIToken instead.

func WithMaxResponseBytes

func WithMaxResponseBytes(n int64) Option

WithMaxResponseBytes limits response bodies read by the SDK.

func WithUserAgent

func WithUserAgent(userAgent string) Option

WithUserAgent changes the User-Agent sent by the SDK.

type Repository

type Repository = repository.Repository

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type RepositoryBranchState

type RepositoryBranchState = repository.BranchState

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type RepositoryListOptions

type RepositoryListOptions = repository.ListOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type RepositoryService

type RepositoryService = repository.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type RepositoryUpdateCommitOptions

type RepositoryUpdateCommitOptions = repository.UpdateCommitOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolAddressOptions

type ResourcePoolAddressOptions = resourcepool.AddressOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolAllocatedOptions

type ResourcePoolAllocatedOptions = resourcepool.AllocatedOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolAllocation

type ResourcePoolAllocation = resourcepool.Allocation

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolAllocationPage

type ResourcePoolAllocationPage = resourcepool.AllocationPage

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolMemberType

type ResourcePoolMemberType = resourcepool.MemberType

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolPrefixOptions

type ResourcePoolPrefixOptions = resourcepool.PrefixOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolService

type ResourcePoolService = resourcepool.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolUtilization

type ResourcePoolUtilization = resourcepool.Utilization

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type ResourcePoolUtilizationResult

type ResourcePoolUtilizationResult = resourcepool.UtilizationResult

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type SchemaService

type SchemaService = schema.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type Task

type Task = task.Task

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskAmbiguousError

type TaskAmbiguousError = task.AmbiguousError

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskFilter

type TaskFilter = task.Filter

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskListOptions

type TaskListOptions = task.ListOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskLog

type TaskLog = task.Log

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskPage

type TaskPage = task.Page

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskRelatedNode

type TaskRelatedNode = task.RelatedNode

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskService

type TaskService = task.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TaskState

type TaskState = task.State

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TrackingGroup

type TrackingGroup = tracking.Group

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

func NewTrackingGroup

func NewTrackingGroup(options TrackingGroupOptions) (*TrackingGroup, error)

NewTrackingGroup creates a request-scoped group collector.

type TrackingGroupOptions

type TrackingGroupOptions = tracking.GroupOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TrackingGroupResult

type TrackingGroupResult = tracking.GroupResult

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalHop

type TraversalHop = traversal.Hop

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalNode

type TraversalNode = traversal.Node

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalPath

type TraversalPath = traversal.Path

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalPathsOptions

type TraversalPathsOptions = traversal.PathsOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalPathsResult

type TraversalPathsResult = traversal.PathsResult

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalReachableNode

type TraversalReachableNode = traversal.ReachableNode

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalReachableOptions

type TraversalReachableOptions = traversal.ReachableOptions

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalReachableResult

type TraversalReachableResult = traversal.ReachableResult

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalRelationship

type TraversalRelationship = traversal.Relationship

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalService

type TraversalService = traversal.Service

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.

type TraversalUnsupportedError

type TraversalUnsupportedError = traversal.UnsupportedError

Root-package aliases keep common SDK types discoverable and preserve the API that predates the domain package split.