component

type AuthResult struct {
	// Authenticated when true means that the plugin should now be authenticated
	// (given the other fields in this struct). If ValidateAuth is called,
	// it should succeed. If this is false, the auth method may have printed
	// help text or some other information, but it didn't authenticate. However,
	// this is not an error.
	Authenticated bool
}

type Authenticator interface {
	// AuthFunc should return the method for getting credentials for a
	// plugin. This should return AuthResult.
	AuthFunc() interface{}

	// ValidateAuthFunc should return the method for validating authentication
	// credentials for the plugin
	ValidateAuthFunc() interface{}
}

type CapabilityPlatform interface {
	// Test if capability is available
	HasCapabilityFunc() interface{}
	// Run a capability
	CapabilityFunc(capName string) interface{}
}

type Command interface {
	// Execute a command
	ExecuteFunc([]string) interface{}
	// Retruns command info
	CommandInfoFunc() interface{}
}

type CommandFlag struct {
	LongName     string
	ShortName    string
	Description  string
	DefaultValue string
	Type         FlagType
	Aliases      []string
}

type CommandFlags []*CommandFlag

type CommandInfo struct {
	Name        string
	Help        string
	Synopsis    string
	Flags       []*CommandFlag
	Subcommands []*CommandInfo
	Primary     bool
}

type CommandOptions struct {
	// Primary indicates that a command should show up in the main help output.
	Primary bool
}

type CommandParams struct {
	Flags     map[string]interface{}
	Arguments []string
}

type Communicator interface {
	// Checks if machine can be used with communicator
	MatchFunc() interface{}
	// Initialize communicator with machine
	InitFunc() interface{}
	// Check if communicator is ready
	ReadyFunc() interface{}
	// Wait for communicator to become ready for given seconds
	WaitForReadyFunc() interface{}
	// Download file from guest path to local path
	DownloadFunc() interface{}
	// Upload file from local path to guest path
	UploadFunc() interface{}
	// Run command
	ExecuteFunc() interface{}
	// Run privileged command
	PrivilegedExecuteFunc() interface{}
	// Run a test command on the guest
	TestFunc() interface{}
	// Reset the communicator. Close and re-establish connection where required.
	ResetFunc() interface{}
}

type ComponentWithOptions struct {
	Component interface{}
	Options   interface{}
}

type Config interface {
	// Register a configuration namespace
	Register() (*ConfigRegistration, error)
	// Defines the structure of the supported configuration
	StructFunc() interface{}
	// Initialization of configuration data
	InitFunc() interface{}
	// Merge configuration
	MergeFunc() interface{}
	// Return finalized configuration data
	FinalizeFunc() interface{}
}

type ConfigData struct {
	Source string                 // Root type name
	Data   map[string]interface{} // Configuration data
}

type ConfigFinalize struct {
	Config *ConfigData
}

type ConfigMerge struct {
	Base    *ConfigData
	Overlay *ConfigData
}

type ConfigRegistration struct {
	Identifier string // Identifier used within Vagrantfile
	Scope      string // Optional scope (provider, provisioner, etc)
}

type Configurable interface {
	// Config should return a pointer to an allocated configuration
	// structure. This structure will be written to directly with the
	// decoded configuration. If this returns nil, then it is as if
	// Configurable was not implemented.
	Config() (interface{}, error)
}

type ConfigurableNotify interface {
	Configurable

	// ConfigSet is called with the value of the configuration after
	// decoding is complete successfully.
	ConfigSet(interface{}) error
}

type Direct struct {
	Arguments []interface{}
}

type Documented interface {
	// Documentation() returns a completed docs.Documentation struct
	// describing the components configuration.
	Documentation() (*docs.Documentation, error)
}

type Downloader interface {
	DownloadFunc() interface{}
}

type FlagType uint

type Guest interface {
	CapabilityPlatform

	// Detect if machine is supported guest
	GuestDetectFunc() interface{}
	// List of parent host names
	ParentFunc() interface{}
}

type Host interface {
	CapabilityPlatform

	// Detect if machine is supported host
	HostDetectFunc() interface{}
	// List of parent host names
	ParentFunc() interface{}
}

type JobInfo struct {
	// Id is the ID of the job that is executing this plugin operation.
	// If this is empty then it means that the execution is happening
	// outside of a job.
	Id string

	// Local is true if the operation is running locally on a machine
	// alongside the invocation. This can be used to determine if you can
	// do things such as open browser windows, read user files, etc.
	Local bool

	// Workspace is the workspace that this job is executing in. This should
	// be used by plugins to properly isolate resources from each other.
	// TODO(spox): this needs to be removed
	Workspace string
}

type LogEvent struct {
	Partition string
	Timestamp time.Time
	Message   string
}

type LogPlatform interface {
	// LogsFunc should return an implementation of LogViewer.
	LogsFunc() interface{}
}

type LogViewer interface {
	// NextBatch is called to return the next batch of logs. This is expected
	// to block if there are no logs available. The context passed in will be
	// cancelled if the logs viewer is interrupted.
	NextLogBatch(ctx context.Context) ([]LogEvent, error)
}

type MetadataSet struct {
	Metadata map[string]string
}

type NamedCapability struct {
	Capability string
}

type PluginInfo interface {
	ComponentOptions() map[Type]interface{}
	ComponentTypes() []Type
	Name() string
}

type ProtoMarshaler interface {
	// Proto returns a proto.Message of this structure. This may also return
	// a proto Any value and it will not be re-wrapped with Any.
	Proto() proto.Message
}

type Provider interface {
	CapabilityPlatform

	// Check if provider is usable
	UsableFunc() interface{}
	// Check if the provider is installed
	InstalledFunc() interface{}
	// Run an action by name
	ActionFunc(actionName string) interface{}
	// Called when the machine id is changed
	MachineIdChangedFunc() interface{}
	// Get SSH info
	SshInfoFunc() interface{}
	// Get target state
	StateFunc() interface{}
}

type ProviderOptions struct {
	// Priority indicates the precedence of provider plugin selection (higher overrides lower)
	Priority int

	// Parallel indicates whether or not the provider supports parallel operations
	Parallel bool

	// BoxOptional indicates if the provider can function without a box
	BoxOptional bool

	// Defaultable can be set to false to omit the provider from consideration as a default
	Defaultable bool
}

type Provisioner interface {
	ConfigureFunc() interface{}
	ProvisionFunc() interface{}
	CleanupFunc() interface{}
}

type Push interface {
	// Executes a named push strategy
	PushFunc() interface{}
}

type SyncedFolder interface {
	CapabilityPlatform

	// Determines if an implementation is usable
	UsableFunc() interface{}
	// Called before the machine is booted and networks are setup
	PrepareFunc() interface{}
	// Called after the machine is booted and networks are setup
	// Adds folders without removing any existing ones
	EnableFunc() interface{}
	// Removes folders from a running machine
	DisableFunc() interface{}
	// Called after destroying a machine
	CleanupFunc() interface{}
}

type SyncedFolderOptions struct {
	// Priority determines the weight used to select a synced folder plugin
	// when one is not specified explicitly. A higher number is more likely to
	// be selected.
	Priority int
}

type Type uint