daggerkit

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

type DaggerCacheVolume interface {
}

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

type DaggerClient interface {
	Container() DaggerContainer
	Host() DaggerHost
	CacheVolume(string) DaggerCacheVolume
}

type DaggerContainer interface {
	From(string) DaggerContainer
	WithMountedDirectory(string, DaggerDirectory) DaggerContainer
	WithMountedCache(string, DaggerCacheVolume) DaggerContainer
	WithWorkdir(string) DaggerContainer
	WithExec([]string) DaggerContainer
	WithNewFile(string, string) DaggerContainer
	WithDirectory(string, DaggerDirectory) DaggerContainer
	WithEntrypoint([]string) DaggerContainer
	// WithRegistryAuth and WithUnixSocket take *dagger.Secret/*dagger.Socket
	// directly rather than a wrapping interface, same rationale as
	// DaggerHost.UnixSocket above.
	WithRegistryAuth(string, string, *dagger.Secret) DaggerContainer
	WithUnixSocket(string, *dagger.Socket) DaggerContainer
	WithEnvVariable(string, string) DaggerContainer
	// WithExposedPort, AsService and WithServiceBinding exist for the
	// Docker-in-Docker sidecar pattern (see providers/rust/dockerdaemon.go):
	// a privileged dockerd container is exposed as a DaggerService and bound
	// into the caller's container under a network alias, giving
	// testcontainers-rs a real, routable Docker daemon instead of a mounted
	// host socket (which Dagger's own container sandboxing model makes
	// unreachable for sibling-container networking — see dockerdaemon.go's
	// doc comment for the full root cause).
	WithExposedPort(int) DaggerContainer
	// AsService runs args as the service's live process, with Dagger's
	// InsecureRootCapabilities (needed to start dockerd itself). Args must
	// be passed here rather than via a prior WithExec: WithExec's semantics
	// are "run to completion and snapshot the result," which a daemon that
	// runs forever never does — see dockerdaemon.go's dockerdCommand comment.
	AsService([]string) DaggerService
	WithServiceBinding(string, DaggerService) DaggerContainer
	File(string) DaggerFile
	Directory(string) DaggerDirectory
	Sync(context.Context) (DaggerContainer, error)
	Stdout(context.Context) (string, error)
	Stderr(context.Context) (string, error)
	Publish(context.Context, string) (string, error)
}

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

type DaggerDirectory interface {
	File(string) DaggerFile
	// GetRealDirectory returns the underlying real Dagger directory (only
	// for adapters) — needed to unwrap RustBuilder.Build's returned
	// Directory back to the concrete *dagger.Directory its public signature
	// promises.
	GetRealDirectory() *dagger.Directory
}

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

type DaggerFile interface {
	Contents(context.Context) (string, error)
	// GetRealFile returns the underlying real Dagger file (only for
	// adapters) — needed by every Tester in this module, each of which
	// returns its report as a *dagger.File.
	GetRealFile() *dagger.File
}

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

type DaggerHost interface {
	// UnixSocket returns *dagger.Socket directly rather than a wrapping
	// interface: callers only ever pass it through opaquely to
	// DaggerContainer.WithUnixSocket, never call a method on it.
	UnixSocket(string) *dagger.Socket
}

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

type DaggerService interface {
}

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

type MockDaggerCacheVolume struct {
	mock.Mock
}

type MockDaggerClient struct {
	mock.Mock
}

type MockDaggerContainer struct {
	mock.Mock
}

type MockDaggerDirectory struct {
	mock.Mock
}

type MockDaggerFile struct {
	mock.Mock
}

type MockDaggerHost struct {
	mock.Mock
}

type MockDaggerService struct {
	mock.Mock
}