deploy

type BackendClient interface {
	// GetStackOutputs returns the outputs (if any) for the named stack or an error if the stack cannot be found.
	GetStackOutputs(ctx context.Context, name string) (resource.PropertyMap, error)

	// GetStackResourceOutputs returns the resource outputs for a stack, or an error if the stack
	// cannot be found. Resources are retrieved from the latest stack snapshot, which may include
	// ongoing updates. They are returned in a `PropertyMap` mapping resource URN to another
	// `Propertymap` with members `type` (containing the Pulumi type ID for the resource) and
	// `outputs` (containing the resource outputs themselves).
	GetStackResourceOutputs(ctx context.Context, stackName string) (resource.PropertyMap, error)
}

type CallbacksClient struct {
	pulumirpc.CallbacksClient
	// contains filtered or unexported fields
}

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

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

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

type EvalRunInfo struct {
	// the package metadata.
	Proj *workspace.Project `json:"proj" yaml:"proj"`
	// the package's working directory.
	Pwd string `json:"pwd" yaml:"pwd"`
	// the path to the program.
	Program string `json:"program" yaml:"program"`
	// the path to the project's directory.
	ProjectRoot string `json:"projectRoot,omitempty" yaml:"projectRoot,omitempty"`
	// any arguments to pass to the package.
	Args []string `json:"args,omitempty" yaml:"args,omitempty"`
	// the target being deployed into.
	Target *Target `json:"target,omitempty" yaml:"target,omitempty"`
}

type Events interface {
	StepExecutorEvents
	PolicyEvents
}

type GoalPlan struct {
	// the type of resource.
	Type tokens.Type
	// the name for the resource's URN.
	Name string
	// true if this resource is custom, managed by a plugin.
	Custom bool
	// the resource's checked input properties we expect to change.
	InputDiff PlanDiff
	// the resource's output properties we expect to change (only set for RegisterResourceOutputs)
	OutputDiff PlanDiff
	// an optional parent URN for this resource.
	Parent resource.URN
	// true to protect this resource from deletion.
	Protect bool
	// dependencies of this resource object.
	Dependencies []resource.URN
	// the provider to use for this resource.
	Provider string
	// the set of dependencies that affect each property.
	PropertyDependencies map[resource.PropertyKey][]resource.URN
	// true if this resource should be deleted prior to replacement.
	DeleteBeforeReplace *bool
	// a list of property names to ignore during changes.
	IgnoreChanges []string
	// outputs that should always be treated as secrets.
	AdditionalSecretOutputs []resource.PropertyKey
	// Structured Alias objects to be assigned to this resource
	Aliases []resource.Alias
	// the expected ID of the resource, if any.
	ID resource.ID
	// an optional config object for resource options
	CustomTimeouts resource.CustomTimeouts
}

type Import struct {
	Type              tokens.Type       // The type token for the resource. Required.
	Name              string            // The name of the resource. Required.
	ID                resource.ID       // The ID of the resource. Required.
	Parent            resource.URN      // The parent of the resource, if any.
	Provider          resource.URN      // The specific provider to use for the resource, if any.
	Version           *semver.Version   // The provider version to use for the resource, if any.
	PluginDownloadURL string            // The provider PluginDownloadURL to use for the resource, if any.
	PluginChecksums   map[string][]byte // The provider checksums to use for the resource, if any.
	Protect           bool              // Whether to mark the resource as protected after import
	Properties        []string          // Which properties to include (Defaults to required properties)

	// True if this import should create an empty component resource. ID must not be set if this is used.
	Component bool
	// True if this is a remote component resource. Component must be true if this is true.
	Remote bool
}

type ImportOptions struct {
	Events   Events // an optional events callback interface.
	Parallel int    // the degree of parallelism for resource operations (<=1 for serial).
}

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

type Manifest struct {
	Time    time.Time              // the time this snapshot was taken.
	Magic   string                 // a magic cookie.
	Version string                 // the pulumi command version.
	Plugins []workspace.PluginInfo // the plugin versions also loaded.
}

type Options struct {
	Events                    Events     // an optional events callback interface.
	Parallel                  int        // the degree of parallelism for resource operations (<=1 for serial).
	Refresh                   bool       // whether or not to refresh before executing the deployment.
	RefreshOnly               bool       // whether or not to exit after refreshing.
	Targets                   UrnTargets // If specified, only operate on specified resources.
	ReplaceTargets            UrnTargets // If specified, mark the specified resources for replacement.
	TargetDependents          bool       // true if we're allowing things to proceed, even with unspecified targets
	UseLegacyDiff             bool       // whether or not to use legacy diffing behavior.
	DisableResourceReferences bool       // true to disable resource reference support.
	DisableOutputValues       bool       // true to disable output value support.
	GeneratePlan              bool       // true to enable plan generation.
	// true if we should continue with the deployment even if a resource operation fails.
	ContinueOnError bool
}

type Plan struct {
	ResourcePlans map[resource.URN]*ResourcePlan
	Manifest      Manifest
	// The configuration in use during the plan.
	Config config.Map
}

type PlanDiff struct {
	Adds    resource.PropertyMap   // the resource's properties we expect to add.
	Deletes []resource.PropertyKey // the resource's properties we expect to delete.
	Updates resource.PropertyMap   // the resource's properties we expect to update.
}

type PolicyEvents interface {
	OnPolicyViolation(resource.URN, plugin.AnalyzeDiagnostic)
	OnPolicyRemediation(resource.URN, plugin.Remediation, resource.PropertyMap, resource.PropertyMap)
}

type ProviderSource interface {
	// GetProvider fetches the provider plugin for the given reference.
	GetProvider(ref providers.Reference) (plugin.Provider, bool)
}

type QuerySource interface {
	Wait() error
}

type ReadResourceEvent interface {
	SourceEvent

	// ID is the requested ID of this read.
	ID() resource.ID
	// Name is the requested name of this read.
	Name() string
	// Type is type of the resource being read.
	Type() tokens.Type
	// Provider is a reference to the provider instance to use for this read.
	Provider() string
	// Parent is the parent resource of the resource being read.
	Parent() resource.URN
	// Properties is the property bag that will be passed to Read as search parameters.
	Properties() resource.PropertyMap
	// Dependencies returns the list of URNs upon which this read depends.
	Dependencies() []resource.URN
	// Done indicates that we are done with this event.
	Done(result *ReadResult)
	// The names of any additional outputs that should be treated as secrets.
	AdditionalSecretOutputs() []resource.PropertyKey
	// The source position of the resource read
	SourcePosition() string
}

type ReadResult struct {
	State  *resource.State
	Result ResultState
}

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

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

type RegisterResourceEvent interface {
	SourceEvent
	// Goal returns the goal state for the resource object that was allocated by the program.
	Goal() *resource.Goal
	// Done indicates that we are done with this step.  It must be called to perform cleanup associated with the step.
	Done(result *RegisterResult)
}

type RegisterResourceOutputsEvent interface {
	SourceEvent
	// URN is the resource URN that this completion applies to.
	URN() resource.URN
	// Outputs returns a property map of output properties to add to a resource before completing.
	Outputs() resource.PropertyMap
	// Done indicates that we are done with this step.  It must be called to perform cleanup associated with the step.
	Done()
}

type RegisterResult struct {
	State  *resource.State // the resource state.
	Result ResultState     // the result of the registration.
}

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

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

type ResourcePlan struct {
	Goal    *GoalPlan
	Ops     []display.StepOp
	Outputs resource.PropertyMap
	// The random byte seed used for resource goal.
	Seed []byte
}

type ResultState int

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

type Snapshot struct {
	Manifest          Manifest             // a deployment manifest of versions, checksums, and so on.
	SecretsManager    secrets.Manager      // the manager to use use when serializing this snapshot.
	Resources         []*resource.State    // fetches all resources and their associated states.
	PendingOperations []resource.Operation // all currently pending resource operations.
}

type Source interface {
	io.Closer

	// Project returns the package name of the Pulumi project we are obtaining resources from.
	Project() tokens.PackageName
	// Info returns a serializable payload that can be used to stamp snapshots for future reconciliation.
	Info() interface{}

	// Iterate begins iterating the source. Error is non-nil upon failure; otherwise, a valid iterator is returned.
	Iterate(ctx context.Context, opts Options, providers ProviderSource) (SourceIterator, error)
}

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

type SourceIterator interface {
	io.Closer

	// Next returns the next event from the source.
	Next() (SourceEvent, error)
}

type SourceResourceMonitor interface {
	Address() string
	Cancel() error
	Invoke(ctx context.Context, req *pulumirpc.ResourceInvokeRequest) (*pulumirpc.InvokeResponse, error)
	Call(ctx context.Context, req *pulumirpc.ResourceCallRequest) (*pulumirpc.CallResponse, error)
	ReadResource(ctx context.Context,
		req *pulumirpc.ReadResourceRequest) (*pulumirpc.ReadResourceResponse, error)
	RegisterResource(ctx context.Context,
		req *pulumirpc.RegisterResourceRequest) (*pulumirpc.RegisterResourceResponse, error)
	RegisterResourceOutputs(ctx context.Context,
		req *pulumirpc.RegisterResourceOutputsRequest) (*emptypb.Empty, error)
}

type Step interface {
	// Apply applies or previews this step. It returns the status of the resource after the step application,
	// a function to call to signal that this step has fully completed, and an error, if one occurred while applying
	// the step.
	//
	// The returned StepCompleteFunc, if not nil, must be called after committing the results of this step into
	// the state of the deployment.
	Apply(preview bool) (resource.Status, StepCompleteFunc, error) // applies or previews this step.

	Op() display.StepOp      // the operation performed by this step.
	URN() resource.URN       // the resource URN (for before and after).
	Type() tokens.Type       // the type affected by this step.
	Provider() string        // the provider reference for this step.
	Old() *resource.State    // the state of the resource before performing this step.
	New() *resource.State    // the state of the resource after performing this step.
	Res() *resource.State    // the latest state for the resource that is known (worst case, old).
	Logical() bool           // true if this step represents a logical operation in the program.
	Deployment() *Deployment // the owning deployment.
	Fail()                   // mark a step as failed.
	Skip()                   // mark a step as skipped
}

type StepApplyFailed struct {
	Err error
}

type StepCompleteFunc func()

type StepExecutorEvents interface {
	OnResourceStepPre(step Step) (interface{}, error)
	OnResourceStepPost(ctx interface{}, step Step, status resource.Status, err error) error
	OnResourceOutputs(step Step) error
}

type Target struct {
	Name         tokens.StackName // the target stack name.
	Organization tokens.Name      // the target organization name (if any).
	Config       config.Map       // optional configuration key/value pairs.
	Decrypter    config.Decrypter // decrypter for secret configuration values.
	Snapshot     *Snapshot        // the last snapshot deployed to the target.
}

type TransformFunction func(
	ctx context.Context,
	name, typ string, custom bool, parent resource.URN,
	props resource.PropertyMap,
	opts *pulumirpc.TransformResourceOptions,
) (resource.PropertyMap, *pulumirpc.TransformResourceOptions, error)

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

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