const (
	NetModeSandbox = pb.NetMode_UNSET
	NetModeHost    = pb.NetMode_HOST
	NetModeNone    = pb.NetMode_NONE
)

const (
	SecurityModeInsecure = pb.SecurityMode_INSECURE
	SecurityModeSandbox  = pb.SecurityMode_SANDBOX
)

var (
	LinuxAmd64   = Platform(ocispecs.Platform{OS: "linux", Architecture: "amd64"})
	LinuxArmhf   = Platform(ocispecs.Platform{OS: "linux", Architecture: "arm", Variant: "v7"})
	LinuxArm     = LinuxArmhf
	LinuxArmel   = Platform(ocispecs.Platform{OS: "linux", Architecture: "arm", Variant: "v6"})
	LinuxArm64   = Platform(ocispecs.Platform{OS: "linux", Architecture: "arm64"})
	LinuxS390x   = Platform(ocispecs.Platform{OS: "linux", Architecture: "s390x"})
	LinuxPpc64le = Platform(ocispecs.Platform{OS: "linux", Architecture: "ppc64le"})
	Darwin       = Platform(ocispecs.Platform{OS: "darwin", Architecture: "amd64"})
	Windows      = Platform(ocispecs.Platform{OS: "windows", Architecture: "amd64"})
)

var IgnoreCache = constraintsOptFunc(func(c *Constraints) {
	c.Metadata.IgnoreCache = true
})

var MarkImageInternal = imageOptionFunc(func(ii *ImageInfo) {
	ii.RecordType = "internal"
})

var SSHOptional = sshOptionFunc(func(si *SSHInfo) {
	si.Optional = true
})

var SecretOptional = secretOptionFunc(func(si *SecretInfo) {
	si.Optional = true
})

type CacheMountSharingMode int

const (
	CacheMountShared CacheMountSharingMode = iota
	CacheMountPrivate
	CacheMountLocked
)

type ChownOpt struct {
	User  *UserOpt
	Group *UserOpt
}

type ChownOption interface {
	MkdirOption
	MkfileOption
	CopyOption
}

type Constraints struct {
	Platform          *ocispecs.Platform
	WorkerConstraints []string
	Metadata          pb.OpMetadata
	LocalUniqueID     string
	Caps              *apicaps.CapSet
	SourceLocations   []*SourceLocation
}

type ConstraintsOpt interface {
	SetConstraintsOption(*Constraints)
	RunOption
	LocalOption
	HTTPOption
	ImageOption
	GitOption
}

type CopyInfo struct {
	Mode                *os.FileMode
	FollowSymlinks      bool
	CopyDirContentsOnly bool
	IncludePatterns     []string
	ExcludePatterns     []string
	AttemptUnpack       bool
	CreateDestPath      bool
	AllowWildcard       bool
	AllowEmptyWildcard  bool
	ChownOpt            *ChownOpt
	CreatedTime         *time.Time
}

type CopyInput interface {
	// contains filtered or unexported methods
}

type CopyOption interface {
	SetCopyOption(*CopyInfo)
}

type CreatedTime time.Time

type Definition struct {
	Def         [][]byte
	Metadata    map[digest.Digest]pb.OpMetadata
	Source      *pb.Source
	Constraints *Constraints
}

type DefinitionOp struct {
	MarshalCache
	// contains filtered or unexported fields
}

type DiffOp struct {
	MarshalCache
	// contains filtered or unexported fields
}

type DiffType string

const (
	// DiffNone will do no file comparisons, all files in the Local source will
	// be retransmitted.
	DiffNone DiffType = pb.AttrLocalDifferNone
	// DiffMetadata will compare file metadata (size, modified time, mode, owner,
	// group, device and link name) to determine if the files in the Local source need
	// to be retransmitted.  This is the default behavior.
	DiffMetadata DiffType = pb.AttrLocalDifferMetadata
)

type DifferInfo struct {
	Type     DiffType
	Required bool
}

type EnvList []KeyValue

type ExecInfo struct {
	State          State
	Mounts         []MountInfo
	ReadonlyRootFS bool
	ProxyEnv       *ProxyEnv
	Secrets        []SecretInfo
	SSH            []SSHInfo
	// contains filtered or unexported fields
}

type ExecOp struct {
	MarshalCache
	// contains filtered or unexported fields
}

type ExecState struct {
	State
	// contains filtered or unexported fields
}

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

type FileOp struct {
	MarshalCache
	// contains filtered or unexported fields
}

type GitInfo struct {
	KeepGitDir       bool
	AuthTokenSecret  string
	AuthHeaderSecret string

	KnownSSHHosts string
	MountSSHSock  string
	// contains filtered or unexported fields
}

type GitOption interface {
	SetGitOption(*GitInfo)
}

type HTTPInfo struct {
	Checksum digest.Digest
	Filename string
	Perm     int
	UID      int
	GID      int
	// contains filtered or unexported fields
}

type HTTPOption interface {
	SetHTTPOption(*HTTPInfo)
}

type HostIP struct {
	Host string
	IP   net.IP
}

type ImageInfo struct {
	RecordType string
	// contains filtered or unexported fields
}

type ImageMetaResolver interface {
	ResolveImageConfig(ctx context.Context, ref string, opt ResolveImageConfigOpt) (digest.Digest, []byte, error)
}

type ImageOption interface {
	SetImageOption(*ImageInfo)
}

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

type LocalInfo struct {
	SessionID       string
	IncludePatterns string
	ExcludePatterns string
	FollowPaths     string
	SharedKeyHint   string
	Differ          DifferInfo
	// contains filtered or unexported fields
}

type LocalOption interface {
	SetLocalOption(*LocalInfo)
}

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

type MergeOp struct {
	MarshalCache
	// contains filtered or unexported fields
}

type MkdirInfo struct {
	MakeParents bool
	ChownOpt    *ChownOpt
	CreatedTime *time.Time
}

type MkdirOption interface {
	SetMkdirOption(*MkdirInfo)
}

type MkfileInfo struct {
	ChownOpt    *ChownOpt
	CreatedTime *time.Time
}

type MkfileOption interface {
	SetMkfileOption(*MkfileInfo)
}

type MountInfo struct {
	Target string
	Source Output
	Opts   []MountOption
}

type MountOption func(*mount)

type Output interface {
	ToInput(context.Context, *Constraints) (*pb.Input, error)
	Vertex(context.Context, *Constraints) Vertex
}

type ProxyEnv struct {
	HTTPProxy  string
	HTTPSProxy string
	FTPProxy   string
	NoProxy    string
	AllProxy   string
}

type ResolveImageConfigOpt struct {
	Platform    *ocispecs.Platform
	ResolveMode string
	LogName     string
}

type ResolveMode int

const (
	ResolveModeDefault ResolveMode = iota
	ResolveModeForcePull
	ResolveModePreferLocal
)

type RmInfo struct {
	AllowNotFound bool
	AllowWildcard bool
}

type RmOption interface {
	SetRmOption(*RmInfo)
}

type RunOption interface {
	SetRunOption(es *ExecInfo)
}

type SSHInfo struct {
	ID       string
	Target   string
	Mode     int
	UID      int
	GID      int
	Optional bool
}

type SSHOption interface {
	SetSSHOption(*SSHInfo)
}

type SecretInfo struct {
	ID       string
	Target   string
	Mode     int
	UID      int
	GID      int
	Optional bool
	IsEnv    bool
}

type SecretOption interface {
	SetSecretOption(*SecretInfo)
}

type SourceLocation struct {
	SourceMap *SourceMap
	Ranges    []*pb.Range
}

type SourceMap struct {
	State      *State
	Definition *Definition
	Filename   string
	Data       []byte
}

type SourceOp struct {
	MarshalCache
	// contains filtered or unexported fields
}

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

type StateOption func(State) State

type TmpfsInfo struct {
	Size int64
}

type TmpfsOption interface {
	SetTmpfsOption(*TmpfsInfo)
}

type UlimitName string

const (
	UlimitCore       UlimitName = "core"
	UlimitCPU        UlimitName = "cpu"
	UlimitData       UlimitName = "data"
	UlimitFsize      UlimitName = "fsize"
	UlimitLocks      UlimitName = "locks"
	UlimitMemlock    UlimitName = "memlock"
	UlimitMsgqueue   UlimitName = "msgqueue"
	UlimitNice       UlimitName = "nice"
	UlimitNofile     UlimitName = "nofile"
	UlimitNproc      UlimitName = "nproc"
	UlimitRss        UlimitName = "rss"
	UlimitRtprio     UlimitName = "rtprio"
	UlimitRttime     UlimitName = "rttime"
	UlimitSigpending UlimitName = "sigpending"
	UlimitStack      UlimitName = "stack"
)

type UserOpt struct {
	UID  int
	Name string
}

type Vertex interface {
	Validate(context.Context, *Constraints) error
	Marshal(context.Context, *Constraints) (digest.Digest, []byte, *pb.OpMetadata, []*SourceLocation, error)
	Output() Output
	Inputs() []Output
}