kukeonv1

type APIError struct {
	Kind    string
	Message string
}

type ApplyDocumentsArgs struct {
	RawYAML []byte
	Team    string
}

type ApplyDocumentsReply struct {
	Result ApplyDocumentsResult
	Err    *APIError
}

type ApplyDocumentsResult struct {
	Resources []ApplyResourceResult
}

type ApplyResourceResult struct {
	Index   int               `json:"index"             yaml:"index"`
	Kind    string            `json:"kind"              yaml:"kind"`
	Name    string            `json:"name"              yaml:"name"`
	Action  string            `json:"action"            yaml:"action"`
	Error   string            `json:"error,omitempty"   yaml:"error,omitempty"`
	Changes []string          `json:"changes,omitempty" yaml:"changes,omitempty"`
	Details map[string]string `json:"details,omitempty" yaml:"details,omitempty"`
}

type AttachContainerArgs struct {
	Doc v1beta1.ContainerDoc
}

type AttachContainerReply struct {
	Result AttachContainerResult
	Err    *APIError
}

type AttachContainerResult struct {
	// HostSocketPath is the host path of the per-container sbsh terminal
	// socket. Inside the container the same inode is reachable at
	// /run/kukeon/tty/socket via the tty directory bind mount. Returned only
	// when the target container has Attachable=true and its task is Running;
	// the daemon errors with ErrAttachNotSupported when the target is not
	// Attachable, or ErrAttachTaskNotRunning when the task is not Running.
	HostSocketPath string
}

type Client interface {
	io.Closer

	CreateRealm(ctx context.Context, doc v1beta1.RealmDoc) (CreateRealmResult, error)
	CreateSpace(ctx context.Context, doc v1beta1.SpaceDoc) (CreateSpaceResult, error)
	CreateStack(ctx context.Context, doc v1beta1.StackDoc) (CreateStackResult, error)
	CreateCell(ctx context.Context, doc v1beta1.CellDoc) (CreateCellResult, error)
	// MaterializeCell creates a cell record (or ensures an existing cell's
	// resources exist) without starting any container tasks (#818). The
	// resulting cell is left stopped; the operator runs `kuke start <name>`
	// to start it. Distinct from CreateCell (which always starts) — used by
	// `kuke create cell --from-blueprint` / `--from-config` for the
	// materialise-but-don't-start scaffolding modes. Result shape matches
	// CreateCell so the same printer renders the outcome (Started will be
	// false because the start step was skipped).
	MaterializeCell(ctx context.Context, doc v1beta1.CellDoc) (CreateCellResult, error)
	// CreateConfig atomically persists a new CellConfig document under
	// create-only semantics (issue #839): the daemon-side write fails with
	// errdefs.ErrConfigExists if a Config of the same name already lives in
	// scope. This is the create-or-fail sibling of ApplyDocuments — used by
	// `kuke create config` and any future client that needs "first writer
	// wins" rather than the write-through apply path. The same scope /
	// blueprint / slot-fill validation as ApplyDocuments runs first — the
	// only difference is the atomic gate (which ApplyDocuments doesn't need,
	// since apply is intentionally write-through).
	CreateConfig(ctx context.Context, doc v1beta1.CellConfigDoc) (CreateConfigResult, error)
	// CreateSecret persists a new Secret document to daemon storage. The
	// write is create-or-overwrite (the daemon's runner.WriteSecret is
	// write-through). The resulting SecretDoc is metadata-only (Spec.Data
	// is never echoed back).
	CreateSecret(ctx context.Context, doc v1beta1.SecretDoc) (CreateSecretResult, error)

	GetRealm(ctx context.Context, doc v1beta1.RealmDoc) (GetRealmResult, error)
	GetSpace(ctx context.Context, doc v1beta1.SpaceDoc) (GetSpaceResult, error)
	GetStack(ctx context.Context, doc v1beta1.StackDoc) (GetStackResult, error)
	GetCell(ctx context.Context, doc v1beta1.CellDoc) (GetCellResult, error)
	GetContainer(ctx context.Context, doc v1beta1.ContainerDoc) (GetContainerResult, error)
	// GetSecret reports the metadata-only view of a single named, scoped
	// `kind: Secret` (issue #622). Spec.data is never echoed — the bytes do
	// not traverse this RPC by design (#619).
	GetSecret(ctx context.Context, doc v1beta1.SecretDoc) (GetSecretResult, error)
	// GetBlueprint reads one named, scoped `kind: CellBlueprint`'s full
	// document from daemon storage (issue #620). Unlike GetSecret the whole
	// document is returned — a blueprint carries only template references —
	// so `kuke run -b` can materialize it. The input doc carries the name and
	// scope coordinates only; the spec is ignored.
	GetBlueprint(ctx context.Context, doc v1beta1.CellBlueprintDoc) (GetBlueprintResult, error)
	// GetConfig reads one named, scoped `kind: CellConfig`'s full document
	// from daemon storage (issue #644). Like GetBlueprint the whole document
	// is returned — a Config carries no credential bytes — so the blueprint
	// ref, values, and slot fills surface to `kuke get config`. The input doc
	// carries the name and scope coordinates only; the spec is ignored.
	GetConfig(ctx context.Context, doc v1beta1.CellConfigDoc) (GetConfigResult, error)

	ListRealms(ctx context.Context) ([]v1beta1.RealmDoc, error)
	ListSpaces(ctx context.Context, realmName string) ([]v1beta1.SpaceDoc, error)
	ListStacks(ctx context.Context, realmName, spaceName string) ([]v1beta1.StackDoc, error)
	ListCells(ctx context.Context, realmName, spaceName, stackName string) ([]v1beta1.CellDoc, error)
	ListContainers(
		ctx context.Context,
		realmName, spaceName, stackName, cellName string,
	) ([]v1beta1.ContainerSpec, error)
	// ListSecrets enumerates the metadata of every Secret bound to the
	// filter scope or any scope nested within it (issue #622). An empty
	// realmName lists across all realms. spec.data is never echoed.
	ListSecrets(ctx context.Context, realmName, spaceName, stackName, cellName string) ([]v1beta1.SecretDoc, error)
	// ListBlueprints enumerates the metadata of every CellBlueprint bound to
	// the filter scope or any scope nested within it (issue #643). An empty
	// realmName lists across all realms. A Blueprint is never cell-scoped, so
	// there is no cell coordinate. The spec is not populated for a list.
	ListBlueprints(ctx context.Context, realmName, spaceName, stackName string) ([]v1beta1.CellBlueprintDoc, error)
	// ListConfigs enumerates the metadata of every CellConfig bound to the
	// filter scope or any scope nested within it (issue #644). An empty
	// realmName lists across all realms. A Config is never cell-scoped, so
	// there is no cell coordinate. The spec is not populated for a list.
	ListConfigs(ctx context.Context, realmName, spaceName, stackName string) ([]v1beta1.CellConfigDoc, error)

	StartCell(ctx context.Context, doc v1beta1.CellDoc) (StartCellResult, error)
	// AttachContainer is the placeholder endpoint shipped in #57. It only
	// validates that the target container has Attachable=true; the
	// terminal-bridge client lands in #66.
	AttachContainer(ctx context.Context, doc v1beta1.ContainerDoc) (AttachContainerResult, error)
	// LogContainer validates that the target container has Attachable=true
	// and resolves the host-side path of the per-container sbsh capture
	// file. Bytes never traverse this RPC — the caller (`kuke log`) reads
	// the file directly. Same Attachable gate as AttachContainer: only
	// containers wrapped by sbsh have a capture file to surface.
	LogContainer(ctx context.Context, doc v1beta1.ContainerDoc) (LogContainerResult, error)
	StopCell(ctx context.Context, doc v1beta1.CellDoc) (StopCellResult, error)
	KillCell(ctx context.Context, doc v1beta1.CellDoc) (KillCellResult, error)

	DeleteRealm(ctx context.Context, doc v1beta1.RealmDoc, force, cascade bool) (DeleteRealmResult, error)
	DeleteSpace(ctx context.Context, doc v1beta1.SpaceDoc, force, cascade bool) (DeleteSpaceResult, error)
	DeleteStack(ctx context.Context, doc v1beta1.StackDoc, force, cascade bool) (DeleteStackResult, error)
	DeleteCell(ctx context.Context, doc v1beta1.CellDoc) (DeleteCellResult, error)
	// DeleteSecret removes a single named, scoped Secret's daemon-stored
	// file (issue #622). The live-reference safety gate ships in phase 3c.
	DeleteSecret(ctx context.Context, doc v1beta1.SecretDoc) (DeleteSecretResult, error)
	// DeleteBlueprint removes a single named, scoped CellBlueprint's
	// daemon-stored document (issue #643). No live-reference gate: cells
	// materialized from a blueprint are independent copies (#620).
	DeleteBlueprint(ctx context.Context, doc v1beta1.CellBlueprintDoc) (DeleteBlueprintResult, error)
	// DeleteConfig removes a single named, scoped CellConfig's daemon-stored
	// document (issue #644). No live-reference gate: deleting a Config never
	// deletes the cell it materialized. The result reports any live cells that
	// still carry the back-reference label so the caller can emit a notice.
	DeleteConfig(ctx context.Context, doc v1beta1.CellConfigDoc) (DeleteConfigResult, error)

	PurgeRealm(ctx context.Context, doc v1beta1.RealmDoc, force, cascade bool) (PurgeRealmResult, error)
	PurgeSpace(ctx context.Context, doc v1beta1.SpaceDoc, force, cascade bool) (PurgeSpaceResult, error)
	PurgeStack(ctx context.Context, doc v1beta1.StackDoc, force, cascade bool) (PurgeStackResult, error)
	PurgeCell(ctx context.Context, doc v1beta1.CellDoc, force, cascade bool) (PurgeCellResult, error)

	RefreshAll(ctx context.Context) (RefreshAllResult, error)
	ApplyDocuments(ctx context.Context, rawYAML []byte) (ApplyDocumentsResult, error)
	// ApplyDocumentsForTeam is the per-team prune-apply sibling of
	// ApplyDocuments (issue #1027). It stamps every applied CellBlueprint /
	// CellConfig with `kukeon.io/team=<team>` and, after the apply loop,
	// deletes daemon-stored Blueprint / Config objects carrying the same
	// team label that the applied set did not include. Used by `kuke team
	// init` (#796) to make project rosters converge: re-running on a
	// shrunken roster prunes the orphans without touching other teams or
	// running cells (deleting a Blueprint or Config never deletes the cell
	// materialized from it). Empty team is rejected — use ApplyDocuments
	// for the no-team path.
	ApplyDocumentsForTeam(ctx context.Context, rawYAML []byte, team string) (ApplyDocumentsResult, error)
	// DeleteDocuments is the file-driven counterpart to ApplyDocuments —
	// `kuke delete -f` sends the raw YAML over the wire so deletes honor
	// `--host` routing the same way applies do. Per-resource cascade/force
	// semantics match the single-kind Delete{Realm,Space,Stack} methods.
	DeleteDocuments(ctx context.Context, rawYAML []byte, cascade, force bool) (DeleteDocumentsResult, error)

	Ping(ctx context.Context) error
	// PingVersion is the Ping sibling that surfaces the daemon's reported
	// build version alongside the ack. `kuke status` uses it to render the
	// daemon row; the in-process client returns the current process's
	// version (config.Version), so the value is well-defined on both
	// transports. New callers preferring the existing ack-only contract
	// stay on Ping.
	PingVersion(ctx context.Context) (string, error)
}

type ContainerCreationOutcome struct {
	Name       string
	ExistsPre  bool
	ExistsPost bool
	Created    bool
}

type CreateCellArgs struct {
	Doc v1beta1.CellDoc
}

type CreateCellReply struct {
	Result CreateCellResult
	Err    *APIError
}

type CreateCellResult struct {
	Cell v1beta1.CellDoc

	MetadataExistsPre       bool
	MetadataExistsPost      bool
	CgroupExistsPre         bool
	CgroupExistsPost        bool
	CgroupCreated           bool
	RootContainerExistsPre  bool
	RootContainerExistsPost bool
	RootContainerCreated    bool
	StartedPre              bool
	StartedPost             bool
	Started                 bool
	Created                 bool

	Containers []ContainerCreationOutcome
}

type CreateConfigArgs struct {
	Doc v1beta1.CellConfigDoc
}

type CreateConfigReply struct {
	Result CreateConfigResult
	Err    *APIError
}

type CreateConfigResult struct {
	Config  v1beta1.CellConfigDoc
	Created bool
}

type CreateRealmArgs struct {
	Doc v1beta1.RealmDoc
}

type CreateRealmReply struct {
	Result CreateRealmResult
	Err    *APIError
}

type CreateRealmResult struct {
	Realm v1beta1.RealmDoc

	MetadataExistsPre             bool
	MetadataExistsPost            bool
	CgroupExistsPre               bool
	CgroupExistsPost              bool
	CgroupCreated                 bool
	ContainerdNamespaceExistsPre  bool
	ContainerdNamespaceExistsPost bool
	ContainerdNamespaceCreated    bool
	Created                       bool
}

type CreateSecretArgs struct {
	Doc v1beta1.SecretDoc
}

type CreateSecretReply struct {
	Result CreateSecretResult
	Err    *APIError
}

type CreateSecretResult struct {
	Secret  v1beta1.SecretDoc
	Created bool
}

type CreateSpaceArgs struct {
	Doc v1beta1.SpaceDoc
}

type CreateSpaceReply struct {
	Result CreateSpaceResult
	Err    *APIError
}

type CreateSpaceResult struct {
	Space v1beta1.SpaceDoc

	MetadataExistsPre    bool
	MetadataExistsPost   bool
	CgroupExistsPre      bool
	CgroupExistsPost     bool
	CgroupCreated        bool
	CNINetworkExistsPre  bool
	CNINetworkExistsPost bool
	CNINetworkCreated    bool
	Created              bool
}

type CreateStackArgs struct {
	Doc v1beta1.StackDoc
}

type CreateStackReply struct {
	Result CreateStackResult
	Err    *APIError
}

type CreateStackResult struct {
	Stack v1beta1.StackDoc

	MetadataExistsPre  bool
	MetadataExistsPost bool
	CgroupExistsPre    bool
	CgroupExistsPost   bool
	CgroupCreated      bool
	Created            bool
}

type DeleteBlueprintArgs struct {
	Doc v1beta1.CellBlueprintDoc
}

type DeleteBlueprintReply struct {
	Result DeleteBlueprintResult
	Err    *APIError
}

type DeleteBlueprintResult struct {
	Blueprint v1beta1.CellBlueprintDoc
	Deleted   bool
}

type DeleteCellArgs struct {
	Doc v1beta1.CellDoc
}

type DeleteCellReply struct {
	Result DeleteCellResult
	Err    *APIError
}

type DeleteCellResult struct {
	Cell              v1beta1.CellDoc
	ContainersDeleted bool
	CgroupDeleted     bool
	MetadataDeleted   bool
}

type DeleteConfigArgs struct {
	Doc v1beta1.CellConfigDoc
}

type DeleteConfigReply struct {
	Result DeleteConfigResult
	Err    *APIError
}

type DeleteConfigResult struct {
	Config       v1beta1.CellConfigDoc
	Deleted      bool
	BackRefCells []string
}

type DeleteDocumentsArgs struct {
	RawYAML []byte
	Cascade bool
	Force   bool
}

type DeleteDocumentsReply struct {
	Result DeleteDocumentsResult
	Err    *APIError
}

type DeleteDocumentsResult struct {
	Resources []DeleteResourceResult
}

type DeleteImageResult struct {
	Realm     string
	Namespace string
	Ref       string
}

type DeleteRealmArgs struct {
	Doc     v1beta1.RealmDoc
	Force   bool
	Cascade bool
}

type DeleteRealmReply struct {
	Result DeleteRealmResult
	Err    *APIError
}

type DeleteRealmResult struct {
	Realm                      v1beta1.RealmDoc
	Deleted                    []string
	MetadataDeleted            bool
	CgroupDeleted              bool
	ContainerdNamespaceDeleted bool
}

type DeleteResourceResult struct {
	Index    int               `json:"index"              yaml:"index"`
	Kind     string            `json:"kind"               yaml:"kind"`
	Name     string            `json:"name"               yaml:"name"`
	Action   string            `json:"action"             yaml:"action"`
	Error    string            `json:"error,omitempty"    yaml:"error,omitempty"`
	Cascaded []string          `json:"cascaded,omitempty" yaml:"cascaded,omitempty"`
	Details  map[string]string `json:"details,omitempty"  yaml:"details,omitempty"`
}

type DeleteSecretArgs struct {
	Doc v1beta1.SecretDoc
}

type DeleteSecretReply struct {
	Result DeleteSecretResult
	Err    *APIError
}

type DeleteSecretResult struct {
	Secret  v1beta1.SecretDoc
	Deleted bool
}

type DeleteSpaceArgs struct {
	Doc     v1beta1.SpaceDoc
	Force   bool
	Cascade bool
}

type DeleteSpaceReply struct {
	Result DeleteSpaceResult
	Err    *APIError
}

type DeleteSpaceResult struct {
	Space             v1beta1.SpaceDoc
	SpaceName         string
	RealmName         string
	MetadataDeleted   bool
	CgroupDeleted     bool
	CNINetworkDeleted bool
	Deleted           []string
}

type DeleteStackArgs struct {
	Doc     v1beta1.StackDoc
	Force   bool
	Cascade bool
}

type DeleteStackReply struct {
	Result DeleteStackResult
	Err    *APIError
}

type DeleteStackResult struct {
	Stack           v1beta1.StackDoc
	StackName       string
	RealmName       string
	SpaceName       string
	MetadataDeleted bool
	CgroupDeleted   bool
	Deleted         []string
}

type FakeClient struct{}

type GetBlueprintArgs struct {
	Doc v1beta1.CellBlueprintDoc
}

type GetBlueprintReply struct {
	Result GetBlueprintResult
	Err    *APIError
}

type GetBlueprintResult struct {
	Blueprint      v1beta1.CellBlueprintDoc
	MetadataExists bool
}

type GetCellArgs struct {
	Doc v1beta1.CellDoc
}

type GetCellReply struct {
	Result GetCellResult
	Err    *APIError
}

type GetCellResult struct {
	Cell                v1beta1.CellDoc
	MetadataExists      bool
	CgroupExists        bool
	RootContainerExists bool
	// RootContainerTaskRunning reports whether the cell's root container has a
	// live containerd task. Distinct from RootContainerExists, which keys on the
	// containerd record that survives a host/daemon restart while the task does
	// not (#654, #683). Attach gating must consult task liveness, not record
	// existence, to avoid handing back a dead socket.
	RootContainerTaskRunning bool
}

type GetConfigArgs struct {
	Doc v1beta1.CellConfigDoc
}

type GetConfigReply struct {
	Result GetConfigResult
	Err    *APIError
}

type GetConfigResult struct {
	Config         v1beta1.CellConfigDoc
	MetadataExists bool
}

type GetContainerArgs struct {
	Doc v1beta1.ContainerDoc
}

type GetContainerReply struct {
	Result GetContainerResult
	Err    *APIError
}

type GetContainerResult struct {
	Container          v1beta1.ContainerDoc
	CellMetadataExists bool
	ContainerExists    bool
}

type GetImageResult struct {
	Realm     string
	Namespace string
	Image     ImageInfo
}

type GetRealmArgs struct {
	Doc v1beta1.RealmDoc
}

type GetRealmReply struct {
	Result GetRealmResult
	Err    *APIError
}

type GetRealmResult struct {
	Realm                     v1beta1.RealmDoc
	MetadataExists            bool
	CgroupExists              bool
	ContainerdNamespaceExists bool
}

type GetSecretArgs struct {
	Doc v1beta1.SecretDoc
}

type GetSecretReply struct {
	Result GetSecretResult
	Err    *APIError
}

type GetSecretResult struct {
	Secret         v1beta1.SecretDoc
	MetadataExists bool
}

type GetSpaceArgs struct {
	Doc v1beta1.SpaceDoc
}

type GetSpaceReply struct {
	Result GetSpaceResult
	Err    *APIError
}

type GetSpaceResult struct {
	Space            v1beta1.SpaceDoc
	MetadataExists   bool
	CgroupExists     bool
	CNINetworkExists bool
}

type GetStackArgs struct {
	Doc v1beta1.StackDoc
}

type GetStackReply struct {
	Result GetStackResult
	Err    *APIError
}

type GetStackResult struct {
	Stack          v1beta1.StackDoc
	MetadataExists bool
	CgroupExists   bool
}

type ImageInfo struct {
	Name      string            `json:"name"      yaml:"name"`
	Size      int64             `json:"size"      yaml:"size"`
	CreatedAt time.Time         `json:"createdAt" yaml:"createdAt"`
	Digest    string            `json:"digest"    yaml:"digest"`
	MediaType string            `json:"mediaType" yaml:"mediaType"`
	Labels    map[string]string `json:"labels"    yaml:"labels"`
}

type KillCellArgs struct {
	Doc v1beta1.CellDoc
}

type KillCellReply struct {
	Result KillCellResult
	Err    *APIError
}

type KillCellResult struct {
	Cell   v1beta1.CellDoc
	Killed bool
}

type ListBlueprintsArgs struct {
	RealmName string
	SpaceName string
	StackName string
}

type ListBlueprintsReply struct {
	Blueprints []v1beta1.CellBlueprintDoc
	Err        *APIError
}

type ListCellsArgs struct {
	RealmName string
	SpaceName string
	StackName string
}

type ListCellsReply struct {
	Cells []v1beta1.CellDoc
	Err   *APIError
}

type ListConfigsArgs struct {
	RealmName string
	SpaceName string
	StackName string
}

type ListConfigsReply struct {
	Configs []v1beta1.CellConfigDoc
	Err     *APIError
}

type ListContainersArgs struct {
	RealmName string
	SpaceName string
	StackName string
	CellName  string
}

type ListContainersReply struct {
	Containers []v1beta1.ContainerSpec
	Err        *APIError
}

type ListImagesResult struct {
	Realm     string
	Namespace string
	Images    []ImageInfo
}

type ListRealmsArgs struct{}

type ListRealmsReply struct {
	Realms []v1beta1.RealmDoc
	Err    *APIError
}

type ListSecretsArgs struct {
	RealmName string
	SpaceName string
	StackName string
	CellName  string
}

type ListSecretsReply struct {
	Secrets []v1beta1.SecretDoc
	Err     *APIError
}

type ListSpacesArgs struct {
	RealmName string
}

type ListSpacesReply struct {
	Spaces []v1beta1.SpaceDoc
	Err    *APIError
}

type ListStacksArgs struct {
	RealmName string
	SpaceName string
}

type ListStacksReply struct {
	Stacks []v1beta1.StackDoc
	Err    *APIError
}

type LoadImageResult struct {
	Realm     string
	Namespace string
	Images    []string
}

type LogContainerArgs struct {
	Doc v1beta1.ContainerDoc
}

type LogContainerReply struct {
	Result LogContainerResult
	Err    *APIError
}

type LogContainerResult struct {
	// HostCapturePath is the host path of the per-container sbsh capture
	// file. Inside the container the same inode is reachable at
	// /run/kukeon/tty/capture via the tty directory bind mount. Set only
	// when the target container has Attachable=true.
	HostCapturePath string

	// HostLogPath is the host path of the per-container log file written
	// by the containerd runtime shim (cio.LogFile mode). Set only for
	// non-Attachable containers; the file is shim-owned, kuke only reads.
	HostLogPath string
}

type MaterializeCellArgs struct {
	Doc v1beta1.CellDoc
}

type MaterializeCellReply struct {
	Result CreateCellResult
	Err    *APIError
}

type PingArgs struct{}

type PingReply struct {
	OK      bool
	Version string
	Err     *APIError
}

type PruneImagesResult struct {
	Realm          string
	Namespace      string
	LeasesDeleted  int
	LeasesRetained int
}

type PurgeCellArgs struct {
	Doc     v1beta1.CellDoc
	Force   bool
	Cascade bool
}

type PurgeCellReply struct {
	Result PurgeCellResult
	Err    *APIError
}

type PurgeCellResult struct {
	Cell              v1beta1.CellDoc
	ContainersDeleted bool
	CgroupDeleted     bool
	MetadataDeleted   bool
	PurgeSucceeded    bool
	Force             bool
	Cascade           bool
	Deleted           []string
	Purged            []string
}

type PurgeRealmArgs struct {
	Doc     v1beta1.RealmDoc
	Force   bool
	Cascade bool
}

type PurgeRealmReply struct {
	Result PurgeRealmResult
	Err    *APIError
}

type PurgeRealmResult struct {
	Realm          v1beta1.RealmDoc
	RealmDeleted   bool
	PurgeSucceeded bool
	Force          bool
	Cascade        bool
	Deleted        []string
	Purged         []string
}

type PurgeSpaceArgs struct {
	Doc     v1beta1.SpaceDoc
	Force   bool
	Cascade bool
}

type PurgeSpaceReply struct {
	Result PurgeSpaceResult
	Err    *APIError
}

type PurgeSpaceResult struct {
	Space             v1beta1.SpaceDoc
	MetadataDeleted   bool
	CgroupDeleted     bool
	CNINetworkDeleted bool
	PurgeSucceeded    bool
	Force             bool
	Cascade           bool
	Deleted           []string
	Purged            []string
}

type PurgeStackArgs struct {
	Doc     v1beta1.StackDoc
	Force   bool
	Cascade bool
}

type PurgeStackReply struct {
	Result PurgeStackResult
	Err    *APIError
}

type PurgeStackResult struct {
	Stack   v1beta1.StackDoc
	Deleted []string
	Purged  []string
}

type RefreshAllArgs struct{}

type RefreshAllReply struct {
	Result RefreshAllResult
	Err    *APIError
}

type RefreshAllResult struct {
	RealmsFound       []string
	SpacesFound       []string
	StacksFound       []string
	CellsFound        []string
	ContainersFound   []string
	RealmsUpdated     []string
	SpacesUpdated     []string
	StacksUpdated     []string
	CellsUpdated      []string
	ContainersUpdated []string
	Errors            []string
}

type StartCellArgs struct {
	Doc v1beta1.CellDoc
}

type StartCellReply struct {
	Result StartCellResult
	Err    *APIError
}

type StartCellResult struct {
	Cell    v1beta1.CellDoc
	Started bool
}

type StopCellArgs struct {
	Doc v1beta1.CellDoc
}

type StopCellReply struct {
	Result StopCellResult
	Err    *APIError
}

type StopCellResult struct {
	Cell    v1beta1.CellDoc
	Stopped bool
}

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

type UnixOption func(*UnixClient)