provider

type CallRequest struct {
	// the function token to invoke.
	Tok tokens.ModuleMember
	// the arguments for the function invocation.
	Args property.Map
	// the project name.
	Project string
	// the name of the stack being deployed into.
	Stack string
	// the configuration variables to apply before running.
	Config map[pconfig.Key]string
	// the configuration keys that have secret values.
	ConfigSecretKeys []pconfig.Key
	// true if we're only doing a dryrun (preview).
	DryRun bool
	// the degree of parallelism for resource operations (<=1 for serial).
	Parallel int32
	// the address for communicating back to the resource monitor.
	MonitorEndpoint string
	// the organization of the stack being deployed into.
	Organization string
}

type CallResponse struct {
	// The returned values, if the call was successful.
	Return property.Map
	// The failures if any arguments didn't pass verification.
	Failures []CheckFailure
}

type CheckFailure struct {
	Property string
	Reason   string
}

type CheckRequest struct {
	Urn        presource.URN
	State      property.Map
	Inputs     property.Map
	RandomSeed []byte
}

type CheckResponse struct {
	Inputs   property.Map
	Failures []CheckFailure
}

type ConfigureRequest struct {
	Variables map[string]string
	Args      property.Map
}

type ConstructRequest struct {
	// URN is the Pulumi URN for this resource.
	Urn presource.URN

	// Configuration for the specified project and stack.
	Config map[pconfig.Key]string

	// A set of configuration keys whose values are secrets.
	ConfigSecretKeys []pconfig.Key

	// True if and only if the request is being made as part of a preview/dry run, in which case the provider should not
	// actually construct the component.
	DryRun bool

	// The degree of parallelism that may be used for resource operations. A value less than or equal to 1 indicates
	// that operations should be performed serially.
	Parallel int32

	// The address of the [](pulumirpc.ResourceMonitor) that the provider should connect to in order to send [resource
	// registrations](resource-registration) for its nested resources.
	MonitorEndpoint string // the RPC address to the host resource monitor.

	// Parent is the URN of the parent resource.
	Parent presource.URN

	// Inputs is the set of inputs for the component.
	Inputs property.Map

	// Aliases is the set of aliases for the component.
	Aliases []presource.URN

	// Dependencies is the list of resources this component depends on, i.e. the DependsOn resource option.
	Dependencies []presource.URN

	// Protect is true if the component is protected.
	Protect *bool

	// Providers is a map from package name to provider reference.
	Providers map[tokens.Package]ProviderReference

	// AdditionalSecretOutputs lists extra output properties
	// that should be treated as secrets.
	AdditionalSecretOutputs []string

	// CustomTimeouts overrides default timeouts for resource operations.
	CustomTimeouts *presource.CustomTimeouts

	// DeletedWith specifies that if the given resource is deleted,
	// it will also delete this resource.
	DeletedWith presource.URN

	// DeleteBeforeReplace specifies that replacements of this resource
	// should delete the old resource before creating the new resource.
	DeleteBeforeReplace *bool

	// IgnoreChanges lists properties that should be ignored
	// when determining whether the resource should has changed.
	IgnoreChanges []string

	// ReplaceOnChanges lists properties changing which should cause
	// the resource to be replaced.
	ReplaceOnChanges []string

	// RetainOnDelete is true if deletion of the resource should not
	// delete the resource in the provider.
	RetainOnDelete *bool
}

type ConstructResponse struct {
	// the Pulumi URN for this resource.
	Urn presource.URN
	// the state of this resource.
	State property.Map
}

type CreateRequest struct {
	Urn        presource.URN // the Pulumi URN for this resource.
	Properties property.Map  // the provider inputs to set during creation.
	Timeout    float64       // the create request timeout represented in seconds.
	DryRun     bool          // true if this is a preview and the provider should not actually create the resource.
}

type CreateResponse struct {
	ID         string       // the ID of the created resource.
	Properties property.Map // any properties that were computed during creation.

	// non-nil to indicate that the create failed and left the resource in a partial
	// state.
	//
	// If PartialState is non-nil, then an error will be returned, annotated with
	// [pulumirpc.ErrorResourceInitFailed].
	PartialState *InitializationFailed
}

type DeleteRequest struct {
	ID         string        // the ID of the resource to delete.
	Urn        presource.URN // the Pulumi URN for this resource.
	Properties property.Map  // the current properties on the resource.
	Timeout    float64       // the delete request timeout represented in seconds.
}

type DiffKind string

type DiffRequest struct {
	ID            string
	Urn           presource.URN
	State         property.Map
	Inputs        property.Map
	IgnoreChanges []string
}

type DiffResponse struct {
	DeleteBeforeReplace bool // if true, this resource must be deleted before replacing it.
	HasChanges          bool // if true, this diff represents an actual difference and thus requires an update.
	// detailedDiff is an optional field that contains map from each changed property to the type of the change.
	//
	// The keys of this map are property paths. These paths are essentially Javascript property access expressions
	// in which all elements are literals, and obey the following EBNF-ish grammar:
	//
	//   propertyName := [a-zA-Z_$] { [a-zA-Z0-9_$] }
	//   quotedPropertyName := '"' ( '\' '"' | [^"] ) { ( '\' '"' | [^"] ) } '"'
	//   arrayIndex := { [0-9] }
	//
	//   propertyIndex := '[' ( quotedPropertyName | arrayIndex ) ']'
	//   rootProperty := ( propertyName | propertyIndex )
	//   propertyAccessor := ( ( '.' propertyName ) |  propertyIndex )
	//   path := rootProperty { propertyAccessor }
	//
	// Examples of valid keys:
	// - root
	// - root.nested
	// - root["nested"]
	// - root.double.nest
	// - root["double"].nest
	// - root["double"]["nest"]
	// - root.array[0]
	// - root.array[100]
	// - root.array[0].nested
	// - root.array[0][1].nested
	// - root.nested.array[0].double[1]
	// - root["key with \"escaped\" quotes"]
	// - root["key with a ."]
	// - ["root key with \"escaped\" quotes"].nested
	// - ["root key with a ."][100]
	DetailedDiff map[string]PropertyDiff
}

type GetSchemaRequest struct {
	Version int
}

type GetSchemaResponse struct {
	Schema string
}

type Host interface {
	// Construct constructs a new resource using the provided [comProvider.ConstructFunc].
	Construct(context.Context, ConstructRequest, comProvider.ConstructFunc) (ConstructResponse, error)

	// Call calls a method using the provided [comProvider.CallFunc].
	Call(context.Context, CallRequest, comProvider.CallFunc) (CallResponse, error)
}

type InitializationFailed struct {
	// Reasons why the resource did not fully initialize.
	Reasons []string
}

type InvokeRequest struct {
	Token tokens.Type  // the function token to invoke.
	Args  property.Map // the arguments for the function invocation.
}

type InvokeResponse struct {
	Return   property.Map   // the returned values, if invoke was successful.
	Failures []CheckFailure // the failures if any arguments didn't pass verification.
}

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

type ParameterizeRequest struct {
	// Args indicates that the provider has been configured from the CLI.
	Args *ParameterizeRequestArgs
	// Value re-parameterizes an existing provider.
	Value *ParameterizeRequestValue
}

type ParameterizeRequestArgs struct {
	// Args is the un-processed CLI args for the parameterization.
	//
	// For example:
	//
	//	pulumi package add my-provider arg1 arg2
	//	                               ^^^^ ^^^^
	//
	// Then ParameterizeRequestArgs{Args:[]string{"arg1", "arg2"}} will be sent.
	Args []string
}

type ParameterizeRequestValue struct {
	Name    string
	Version semver.Version
	Value   []byte
}

type ParameterizeResponse struct {
	Name    string
	Version semver.Version
}

type PropertyDiff struct {
	Kind      DiffKind // The kind of diff asdsociated with this property.
	InputDiff bool     // The difference is between old and new inputs, not old and new state.
}

type Provider struct {

	// GetSchema fetches the schema for this resource provider.
	GetSchema func(context.Context, GetSchemaRequest) (GetSchemaResponse, error)

	// Parameterize sets up the provider as a replacement parameterized provider.
	//
	// If a SDK was generated with parameters, then Parameterize should be called once before
	// [Provider.CheckConfig], [Provider.DiffConfig] or [Provider.Configure].
	//
	// Parameterize can be called in 2 configurations: with [ParameterizeRequest.Args] specified or with
	// [ParameterizeRequest.Value] specified. Parameterize should leave the provider in the same state
	// regardless of which variant was used.
	//
	// For more through documentation on Parameterize, see
	// https://pulumi-developer-docs.readthedocs.io/latest/docs/architecture/providers.html#parameterized-providers.
	Parameterize func(context.Context, ParameterizeRequest) (ParameterizeResponse, error)

	// Cancel signals the provider to gracefully shut down and abort any ongoing resource operations.
	// Operations aborted in this way will return an error (e.g., `Update` and `Create` will either return a
	// creation error or an initialization error). Since Cancel is advisory and non-blocking, it is up
	// to the host to decide how long to wait after Cancel is called before (e.g.)
	// hard-closing any gRPC connection.
	Cancel func(context.Context) error

	// Provider Config
	CheckConfig func(context.Context, CheckRequest) (CheckResponse, error)
	DiffConfig  func(context.Context, DiffRequest) (DiffResponse, error)
	// NOTE: We opt into all options.
	Configure func(context.Context, ConfigureRequest) error

	// Invokes
	Invoke func(context.Context, InvokeRequest) (InvokeResponse, error)

	// Check validates that the given property bag is valid for a resource of the given type and returns the inputs
	// that should be passed to successive calls to Diff, Create, or Update for this resource. As a rule, the provider
	// inputs returned by a call to Check should preserve the original representation of the properties as present in
	// the program inputs. Though this rule is not required for correctness, violations thereof can negatively impact
	// the end-user experience, as the provider inputs are using for detecting and rendering diffs.
	Check  func(context.Context, CheckRequest) (CheckResponse, error)
	Diff   func(context.Context, DiffRequest) (DiffResponse, error)
	Create func(context.Context, CreateRequest) (CreateResponse, error)
	Read   func(context.Context, ReadRequest) (ReadResponse, error)
	Update func(context.Context, UpdateRequest) (UpdateResponse, error)
	Delete func(context.Context, DeleteRequest) error

	// Call allows methods to be attached to resources.
	//
	// Right now, Call is restricted to methods on component resources.[^1][^2]
	//
	// [^1]: On the provider resource: https://github.com/pulumi/pulumi/issues/17025
	// [^2]: On custom resources: https://github.com/pulumi/pulumi/issues/16257
	Call func(context.Context, CallRequest) (CallResponse, error)

	// Components Resources
	Construct func(context.Context, ConstructRequest) (ConstructResponse, error)
}

type ProviderReference struct {
	Urn presource.URN
	ID  presource.ID
}

type ReadRequest struct {
	ID         string        // the ID of the resource to read.
	Urn        presource.URN // the Pulumi URN for this resource.
	Properties property.Map  // the current state (sufficiently complete to identify the resource).
	Inputs     property.Map  // the current inputs, if any (only populated during refresh).
}

type ReadResponse struct {
	ID         string       // the ID of the resource read back (or empty if missing).
	Properties property.Map // the state of the resource read from the live environment.
	Inputs     property.Map // the inputs for this resource that would be returned from Check.

	// non-nil to indicate that the read failed and left the resource in a partial
	// state.
	//
	// If PartialState is non-nil, then an error will be returned, annotated with
	// [pulumirpc.ErrorResourceInitFailed].
	PartialState *InitializationFailed
}

type RunInfo struct {
	PackageName string
	Version     string
}

type UpdateRequest struct {
	ID            string        // the ID of the resource to update.
	Urn           presource.URN // the Pulumi URN for this resource.
	State         property.Map  // the old state of the resource to update.
	Inputs        property.Map  // the new values of provider inputs for the resource to update.
	Timeout       float64       // the update request timeout represented in seconds.
	IgnoreChanges []string      // a set of property paths that should be treated as unchanged.
	DryRun        bool          // true if the provider should not actually create the resource.
}

type UpdateResponse struct {
	// any properties that were computed during updating.
	Properties property.Map
	// non-nil to indicate that the update failed and left the resource in a partial
	// state.
	//
	// If PartialState is non-nil, then an error will be returned, annotated with
	// [pulumirpc.ErrorResourceInitFailed].
	PartialState *InitializationFailed
}