types

type Action struct {
	// Selectors are used to pass parameters to the action. If the ListBuilder
	// is provided, these will be merged with the list actions, with the list
	// action selectors taking precedence.
	Selectors map[string]string `json:"selectors"`
	// If the action can have multiple targets, this should be provided to signal
	// to the ui to build a submenu for the action.
	//
	// An example of this could be executing a command on a Kubernetes pod, where
	// the action needs to know which container (target) to execute the command on.
	TargetBuilder []ActionTargetBuilder `json:"target_builders"`
	ID            string                `json:"id"`
	Icon          string                `json:"icon"`
	Label         string                `json:"label"`
	Description   string                `json:"description"`
	Variant       ActionVariant         `json:"variant"`
	Targets       []ActionTarget        `json:"targets"`
}

type ActionDescriptor struct {
	ID          string      `json:"id"`
	Label       string      `json:"label"`
	Description string      `json:"description"`
	Icon        string      `json:"icon"`
	Scope       ActionScope `json:"scope"`
	Streaming   bool        `json:"streaming"`
}

type ActionEvent struct {
	Type string                 `json:"type"` // "progress", "output", "error", "complete"
	Data map[string]interface{} `json:"data"`
}

type ActionInput struct {
	ID        string                 `json:"id"`
	Namespace string                 `json:"namespace"`
	Params    map[string]interface{} `json:"params"`
}

type ActionResourcer[ClientT any] interface {
	GetActions(ctx *pkgtypes.PluginContext, client *ClientT, meta ResourceMeta) ([]ActionDescriptor, error)
	ExecuteAction(ctx *pkgtypes.PluginContext, client *ClientT, meta ResourceMeta, actionID string, input ActionInput) (*ActionResult, error)
	StreamAction(ctx *pkgtypes.PluginContext, client *ClientT, meta ResourceMeta, actionID string, input ActionInput, stream chan ActionEvent) error
}

type ActionResult struct {
	Success bool                   `json:"success"`
	Data    map[string]interface{} `json:"data"`
	Message string                 `json:"message"`
}

type ActionScope string

type ActionTarget struct {
	// Selectors are used to pass parameters to the action.
	// +optional
	Selectors map[string]string `json:"selectors"`
	// Label is the human-readable name of the target
	Label string `json:"label"`
	// Description is a short description of the target
	// +optional
	Description string `json:"description"`
	// Icon is the icon to display for the target
	// +optional
	Icon string `json:"icon"`
}

type ActionTargetBuilder struct {
	// Selectors are json path selectors to use on each item returned by Paths
	// to get the parameters required for executing the action. Selectors
	// should return a single string value.
	//
	// The selectors will be passed to the action via the parameters map.
	Selectors map[string]string `json:"selectors"`

	// LabelSelector represents which of the selectors should be used for the label
	// displayed for the action. Overrides the static Label parameter if provided.
	LabelSelector string `json:"label_selector"`

	// Label respresents a static label for the action. If the label should be determined
	// based on information about the target, use the LabelSelector instead.
	Label string `json:"label"`

	// Paths represents a json path selector to build the list of targets.
	Paths []string `json:"paths"`
}

type ActionVariant string

type CellAccessorPriority string

type CellAlignment string

type CellComponent string

type CellComponentStatusesParams struct {
	// StatusAccessor
	StatusAccessor string `json:"statusAccessor"`
	// StatusMap
	StatusMap map[string]ColorVariant `json:"statusMap"`
	// HoverMenuComponent is an optional hover menu custom component that can be displayed
	HoverMenuComponent string `json:"hoverMenuComponent"`
}

type CellValueFormatter string

type ColorVariant string

type ColumnDef struct {
	// ID defines the ID for the column
	ID string `json:"id"`
	// Header defines the header for the column
	Header string `json:"header"`
	// Accessors defines the accessors for the column. If multiple values must be
	// displayed, they must be separated by a comma
	Accessors string `json:"accessor"`
	// AccessorPriority defines which value to return if multiple accessors are given, and there are multiple matches. If none is provided,
	// all values will be returned as an array.
	AccessorPriority CellAccessorPriority `json:"accessorPriority,omitempty"`
	// Map defines the map for the cell contents to a color variant based on a value
	ColorMap map[string]string `json:"colorMap,omitempty"`
	// Color defines the color for the cell contents
	Color ColorVariant `json:"color,omitempty"`
	// Align defines the alignment for the column
	// Default: left
	Alignment CellAlignment `json:"align,omitempty"`
	// Hidden defines whether the column is visible or not
	Hidden bool `json:"hidden,omitempty"`
	// Width defines the width for the column. If not provided, the column will
	// be auto-sized.
	Width int `json:"width,omitempty"`
	// Formatter defines an optional value formatter to use for the column
	Formatter CellValueFormatter `json:"formatter,omitempty"`
	// Component defines an optional component to use for the cell. You can use one
	// of the preset components or define your own.
	//
	// If not provided, the default 'text' component will be used.
	Component string `json:"component,omitempty"`
	// Component Params are used to pass additional parameters to the component
	ComponentParams interface{} `json:"componentParams,omitempty"`
	// ResourceLinks are used to create links to other resources.
	ResourceLink *ResourceLink `json:"resourceLink,omitempty"`
	// ValueMap is used to map a value to another value. The key should be a regular expression
	// to run against the value to check if should be replaced by a static value.
	//
	// NOTE: Use this sparingly as it can be expensive to run regular expressions on every cell.
	ValueMap map[string]string `json:"valueMap,omitempty"`
}

type ConnectionControllerEvent struct {
	PluginID    string              `json:"plugin_id"`
	Connections []plugin.Connection `json:"connections"`
}

type CreateInformerHandleFunc[ClientT any] func(
	ctx *pkgtypes.PluginContext,
	client *ClientT,
) (InformerHandle, error)

type CreateInput struct {
	// Params is used as an injectable field for any operations that require extra data
	Params interface{} `json:"params"`

	// Input is the input to the create operation.
	Input map[string]interface{} `json:"input"`

	// Namespace is an optional identifier to use when a resource backend supports
	// a concept of partitioning resources (like with corev1.Namespace in Kubernetes)
	Namespace string `json:"namespace"`
}

type CreateResult struct {
	// Result is the result of the operation.
	Result map[string]interface{} `json:"result"`

	// Success is a flag that indicates if the operation was successful.
	Success bool `json:"success"`
}

type DeleteInput struct {
	// Options is a set of arbitrary options to the delete operation that must be
	// resolved by the Resourcer.
	Input map[string]interface{} `json:"input"`

	// Params is used as an injectable field for any operations that require extra data
	Params map[string]interface{} `json:"params"`

	// ID is the unique identifier of the resource to get.
	ID string `json:"id"`

	// Namespace is an optional identifier to use when a resource backend supports
	// a concept of partitioning resources (like with corev1.Namespace in Kubernetes)
	Namespace string `json:"namespace"`
}

type DeleteResult struct {
	// Result is the result of the operation.
	Result map[string]interface{} `json:"result"`

	// Success is a flag that indicates if the operation was successful.
	Success bool `json:"success"`
}

type DiscoveryProvider interface {
	// Discover discovers the available resource types for the given connection.
	Discover(ctx *pkgtypes.PluginContext, connection *pkgtypes.Connection) ([]ResourceMeta, error)

	// RemoveConnection removes and cleans up any resources associated with the connection.
	RemoveConnection(ctx *pkgtypes.PluginContext, connection *pkgtypes.Connection) error
}

type EditorSchema struct {
	ResourceKey string `json:"resourceKey"`
	FileMatch   string `json:"fileMatch"`
	URI         string `json:"uri"`
	URL         string `json:"url,omitempty"`
	Content     []byte `json:"content,omitempty"`
	Language    string `json:"language"`
}

type FindInput struct {
	// Params is used as an injectable field for any operations that require extra data
	Params map[string]interface{} `json:"params"`

	// Conditions is a an object of conditions to filter the list of resources by, specific
	// to the resource backend.
	//
	// Implementations should support a set of common conditions, such as
	// "name", "label", etc.
	Conditions map[string]interface{} `json:"conditions"`

	// Namespaces is an optional list of namespace identifiers to use when a resource backend
	// supports a concept of partitioning resources (like with corev1.Namespace in Kubernetes).
	//
	// For consisitency, the implemented behavior when this is not specified should be to
	// list all resources in all partitions.
	Namespaces []string `json:"namespaces"`

	// Order is the order parameters for the list operation.
	Order OrderParams `json:"order"`

	// Pagination is the pagination parameters for the list operation.
	Pagination PaginationParams `json:"pagination"`
}

type FindResult struct {
	// Result is the result of the operation, as a map of resources from the
	// operation by their ID.
	//
	// Due to limitations with method bindings with Wails v2, this needs to
	// be a map of resources by their ID instead of an array.
	Result []map[string]interface{} `json:"result"`

	// Success is a flag that indicates if the operation was successful.
	Success bool `json:"success"`

	// Pagination is the pagination result of the list operation.
	Pagination PaginationResult `json:"pagination"`
}

type GetInput struct {
	// Params is used as an injectable field for any operations that require extra data
	Params map[string]interface{} `json:"params"`

	// ID is the unique identifier of the resource to get.
	ID string `json:"id"`

	// Namespace is an optional identifier to use when a resource backend supports
	// a concept of partitioning resources (like with corev1.Namespace in Kubernetes)
	Namespace string `json:"namespace"`
}

type GetResult struct {
	// Result is the result of the operation.
	Result map[string]interface{} `json:"result"`

	// Success is a flag that indicates if the operation was successful.
	Success bool `json:"success"`
}

type InformerAddPayload struct {
	Data       map[string]interface{} `json:"data"`
	PluginID   string                 `json:"pluginId"`
	Key        string                 `json:"key"`
	Connection string                 `json:"connection"`
	ID         string                 `json:"id"`
	Namespace  string                 `json:"namespace"`
}

type InformerConnectionSummary struct {
	Connection     string                           `json:"connection"`
	Resources      map[string]InformerResourceState `json:"resources"`
	ResourceCounts map[string]int                   `json:"resourceCounts"`
	TotalResources int                              `json:"totalResources"`
	SyncedCount    int                              `json:"syncedCount"`
	ErrorCount     int                              `json:"errorCount"`
}

type InformerDeletePayload struct {
	Data       map[string]interface{} `json:"data"`
	PluginID   string                 `json:"pluginId"`
	Key        string                 `json:"key"`
	Connection string                 `json:"connection"`
	ID         string                 `json:"id"`
	Namespace  string                 `json:"namespace"`
}

type InformerHandle interface {
	// RegisterResource registers a resource with the informer, setting up event handlers
	// that push events to the provided channels. syncPolicy tells the handle whether
	// this resource should start immediately on Start() or be deferred.
	RegisterResource(
		ctx *pkgtypes.PluginContext,
		resource ResourceMeta,
		syncPolicy InformerSyncPolicy,
		addChan chan InformerAddPayload,
		updateChan chan InformerUpdatePayload,
		deleteChan chan InformerDeletePayload,
	) error

	// Start starts all OnConnect informers. Reports state changes via stateChan.
	// Blocks until stopCh is closed or context is cancelled.
	Start(
		ctx context.Context,
		stopCh chan struct{},
		stateChan chan<- InformerStateEvent,
	) error

	// StartResource starts the informer for a specific resource (used for OnFirstQuery policy).
	StartResource(
		ctx context.Context,
		resource ResourceMeta,
		stateChan chan<- InformerStateEvent,
	) error

	// Stop gracefully stops all informers.
	Stop()
}

type InformerResourceState int

type InformerStateEvent struct {
	PluginID      string                  `json:"pluginId"`
	Connection    string                  `json:"connection"`
	ResourceKey   string                  `json:"resourceKey"`
	State         InformerResourceState   `json:"state"`
	ResourceCount int                     `json:"resourceCount"`
	TotalCount    int                     `json:"totalCount"` // -1 if unknown
	Error         *ResourceOperationError `json:"error,omitempty"`
}

type InformerSyncPolicy int

type InformerUpdatePayload struct {
	OldData    map[string]interface{} `json:"oldData"`
	NewData    map[string]interface{} `json:"newData"`
	PluginID   string                 `json:"pluginId"`
	Key        string                 `json:"key"`
	Connection string                 `json:"connection"`
	ID         string                 `json:"id"`
	Namespace  string                 `json:"namespace"`
}

type LayoutItem struct {
	// Unique identifier for the layout item. If this does not have children,
	// this will be the ID of the layout item.
	ID string `json:"id"`
	// Display label for the layout item
	Label string `json:"title"`
	// Optional icon for the layout item
	Icon string `json:"icon"`
	// Optional description for the layout item
	Description string `json:"description"`
	// Optional nested children for the layout items
	Items []LayoutItem `json:"items"`
}

type LayoutOpts struct {
	Layouts       map[string][]LayoutItem
	DefaultLayout string
}

type ListInput struct {
	// Params is used as an injectable field for any operations that require extra data
	Params map[string]interface{} `json:"params"`

	// Namespaces is an optional list of namespace identifiers to use when a resource backend
	// supports a concept of partitioning resources (like with corev1.Namespace in Kubernetes).
	//
	// For consisitency, the implemented behavior when this is not specified should be to
	// list all resources in all partitions.
	Namespaces []string `json:"namespaces"`

	// Order is the order parameters for the list operation.
	Order OrderParams `json:"order"`

	// Pagination is the pagination parameters for the list operation.
	Pagination PaginationParams `json:"pagination"`
}

type ListResult struct {
	// Result is the result of the operation, as a map of resources from the
	// operation by their ID.
	//
	// Due to limitations with method bindings with Wails v2, this needs to
	// be a map of resources by their ID instead of an array.
	Result []map[string]interface{} `json:"result"`

	// Success is a flag that indicates if the operation was successful.
	Success bool `json:"success"`

	// Pagination is the pagination result of the list operation.
	Pagination PaginationResult `json:"pagination"`
}

type NoOpActionProvider struct{}

type OperationInput interface {
	GetInput | ListInput | FindInput | CreateInput | UpdateInput | DeleteInput
}

type OperationResult interface {
	GetResult | ListResult | FindResult | CreateResult | UpdateResult | DeleteResult
}

type OperationType int

type OrderParams struct {
	// OrderBy is a list of fields to order the list of resources by.
	OrderBy string `json:"by"`

	// OrderDirection is the direction to order the list of resources by.
	// true for ascending, false for descending
	OrderDirection bool `json:"direction"`
}

type PaginationParams struct {
	// Page is the page of the list of resources to return.
	Page int `json:"page"`

	// PageSize is the number of resources to return per page.
	// If 0, all resources will be returned.
	PageSize int `json:"pageSize"`
}

type PaginationResult struct {
	PaginationParams

	// Total is the total number of resources in the list.
	Total int `json:"total"`

	// TotalPages is the total number of pages in the list.
	Pages int `json:"pages"`
}

type PostHook[R OperationResult] struct {
	// Execute is the function that should be run when the hook is executed. The input to the
	// function will always be an interface representing a pointer to the output of the operation.
	Execute PostHookFunc[R]

	// ID is the unique identifier of the operation.
	ID string

	// Owner represents the resource type that the hook is associated with. This will be the name
	// of the plugin that registered the hook.
	Owner string

	// Selectors is a list of resource selectors that should define for which resources a hook
	// should run. Selectors should be defined in the following format:
	// <resource-type>.<resource-name>.<resource-namespace>
	Selectors []string

	// HookType is the type of hook that this is.
	HookType PostHookType
}

type PostHookFunc[I OperationResult] func(*I) error

type PostHookType int

type PreHook[I OperationInput] struct {
	// Execute is the function that should be run when the hook is executed. The input to the
	// function will always be an interface representing a pointer to the input of the operation.
	Execute PreHookFunc[I]

	// ID is the unique identifier of the operation.
	ID string

	// Owner represents the resource type that the hook is associated with. This will be the name
	// of the plugin that registered the hook.
	Owner string

	// Selectors is a list of resource selectors that should define for which resources a hook
	// should run. Selectors should be defined in the following format:
	// <resource-type>.<resource-name>.<resource-namespace>
	//
	// While wildcard selectors were considered, they were not implemented due to the potential
	// for abuse and the requirements of needed to use reflectors
	Selectors []string

	// HookType is the type of hook that this is.
	HookType PreHookType
}

type PreHookFunc[I OperationInput] func(*I) error

type PreHookType int

type ResourceActionProvider interface {
	// GetActions returns available actions for a resource type
	GetActions(ctx *types.PluginContext, key string) ([]ActionDescriptor, error)
	// ExecuteAction executes a named action and returns result
	ExecuteAction(ctx *types.PluginContext, key string, actionID string, input ActionInput) (*ActionResult, error)
	// StreamAction executes a streaming action, sending events on the channel
	StreamAction(ctx *types.PluginContext, key string, actionID string, input ActionInput, stream chan ActionEvent) error
}

type ResourceConnectionProvider interface {
	// StartConnection starts a connection for the resource provider and begins signalling
	// the resource provider to start syncing resources
	StartConnection(ctx *types.PluginContext, connectionID string) (types.ConnectionStatus, error)
	// StopConnection stops a connection for the resource provider and stops signalling
	// the resource provider to stop syncing resources
	StopConnection(ctx *types.PluginContext, connectionID string) (types.Connection, error)
	// LoadConnections loads the connections for the resource provider
	LoadConnections(ctx *types.PluginContext) ([]types.Connection, error)
	// ListConnections lists the connections for the resource provider
	ListConnections(ctx *types.PluginContext) ([]types.Connection, error)
	// GetConnection gets a connection for the resource provider
	GetConnection(ctx *types.PluginContext, id string) (types.Connection, error)
	// GetConnectionNamespaces gets a list of namespaces within the connection (if the resource provider supports namespaces)
	GetConnectionNamespaces(ctx *types.PluginContext, id string) ([]string, error)
	// UpdateConnection updates the connection for the resource provider
	UpdateConnection(
		ctx *types.PluginContext,
		connection types.Connection,
	) (types.Connection, error)
	// DeleteConnection deletes the connection for the resource provider
	DeleteConnection(ctx *types.PluginContext, id string) error
	// WatchConnections will call the watcher function if it exists, returning the list of connections as things change
	WatchConnections(ctx *types.PluginContext, stream chan []types.Connection) error
}

type ResourceDefinition struct {
	IDAccessor          string          `json:"id_accessor"`
	NamespaceAccessor   string          `json:"namespace_accessor"`
	MemoizerAccessor    string          `json:"memoizer_accessor"`
	ColumnDefs          []ColumnDef     `json:"columnDefs"`
	SupportedOperations []OperationType `json:"supportedOperations,omitempty"`
}

type ResourceErrorClassifier interface {
	ClassifyResourceError(err error) error
}

type ResourceGroup struct {
	// ID is the unique identifier of the resource group
	ID string `json:"id"`

	// Name is the name of the resource group
	Name string `json:"name"`

	// Description is the description of the resource group
	Description string `json:"description"`

	// Icon is an optional icon for the resource group. This can be either an icon name from the react-icons package,
	// a data uri string, or a URL to the icon.
	Icon string `json:"icon"`

	// Resources is a map of resource versions to the resources in that version.
	Resources map[string][]ResourceMeta `json:"resources"`
}

type ResourceInformerProvider interface {
	// StartConnectionInformer signals the resource provider to start an informer for the given resource backend context
	StartConnectionInformer(ctx *types.PluginContext, connectionID string) error
	// StopConnectionInformer signals the resource provider to stop an informer for the given resource backend context
	StopConnectionInformer(ctx *types.PluginContext, connectionID string) error
	// ListenForEvents registers a listener for resource events including state changes
	ListenForEvents(
		ctx *types.PluginContext,
		addStream chan InformerAddPayload,
		updateStream chan InformerUpdatePayload,
		deleteStream chan InformerDeletePayload,
		stateStream chan InformerStateEvent,
	) error
	// HasInformer checks to see if the informer manager has an informer for the given connection.
	HasInformer(ctx *types.PluginContext, connectionID string) bool
	// GetInformerState returns a snapshot of all resource informer states for a connection.
	GetInformerState(ctx *types.PluginContext, connectionID string) (*InformerConnectionSummary, error)
	// EnsureInformerForResource triggers lazy start for SyncOnFirstQuery resources.
	EnsureInformerForResource(ctx *types.PluginContext, connectionID string, resourceKey string) error
}

type ResourceLayoutProvider interface {
	GetLayout(id string) ([]LayoutItem, error)
	SetLayout(id string, layout []LayoutItem) error
	GetDefaultLayout() ([]LayoutItem, error)
}

type ResourceLink struct {
	// Accessor to extract the ID of the linked resource.
	IDAccessor string `json:"idAccessor"`
	// NamespaceAccessor is the accessor for determining which resource namespace the resource is in.
	// If not specified, defaults to the same namespace (if the backend supports it)
	NamespaceAccessor string `json:"namespaceAccessor"`
	// Namespaced is used to determine if the resource is namespaced or not. If not specified, defaults to true.
	Namespaced bool `json:"namespaced"`
	// Key can be supplied if the key is already known ahead of time, and doesn't need to derived from an accessor
	Key string `json:"resourceKey"`
	// KeyAccessor is the accessor for determining the key of the resource.
	KeyAccessor string `json:"keyAccessor"`
	// KeyMap is an optional map that can be used with the key accessor to determine the resource
	// ID based on what is returned from the accessor
	KeyMap map[string]string `json:"keyMap"`
	// DetailExtractors is an optional map of accessors that can extract information about a resource link
	// into a popout modal. Each key should be a direct object accessor or a jsonpath expression.
	DetailExtractors map[string]string `json:"detailExtractors"`
	// DisplayID will display the ID instead of the kind if enabled
	DisplayID bool `json:"displayId"`
}

type ResourceMeta struct {
	// Group is the group of the resource. This is required for all resources.
	//
	// Some examples for groups include:
	// - Kubernetes Plugin: "core", "apps", "batch", "extensions"
	// - AWS Plugin: "ec2", "s3", "rds"
	// - GCP Plugin: "compute", "storage", "sql"
	// - Azure Plugin: "compute", "storage", "sql"
	Group string `json:"group"`

	// Version is the version of the resource. This is required for all resources.
	// If the resource does not have a version, use "v1".
	//
	// Some examples for versions include:
	// - Kubernetes Plugin: "v1", "v1beta1", "v1beta2"
	// - AWS Plugin: "2012-12-01", "2016-11-15"
	Version string `json:"version"`

	// Kind is the kind of the resource. This is required for all resources.
	//
	// Some examples for kinds include:
	// - Kubernetes Plugin: "Pod", "Service", "Deployment"
	// - AWS Plugin: "EC2Instance", "S3Bucket", "RDSInstance"
	// - GCP Plugin: "ComputeEngineInstance", "StorageBucket", "SQLInstance"
	// - Azure Plugin: "VirtualMachine", "StorageAccount", "SQLDatabase"
	Kind string `json:"kind"`

	// Label is a human-readable label of the resource. This is optional, and if not provided, the label will
	// be set to the kind of the resource.
	Label string `json:"label"`

	// Icon is an optional icon for the resource. This can be either an icon name from the react-icons package,
	// a data uri string, or a URL to the icon.
	Icon string `json:"icon"`

	// Description is a human-readable description of the resource. This is required for all resources.
	//
	// Some examples for descriptions include:
	// - Kubernetes Plugin: "A pod represents a set of running containers in your cluster"
	// - AWS Plugin: "An EC2 instance is a virtual server in the AWS cloud"
	// - GCP Plugin: "A Compute Engine instance is a virtual machine that runs on Google's infrastructure"
	// - Azure Plugin: "A virtual machine is a computer that runs on Microsoft's infrastructure"
	Description string `json:"description"`

	// Category is the category of the resource. This is optional, and if not provided, the category will
	// be set to "Uncategorized". It is highly recommended to provide a category for your resources, so that
	// they can be easily found by other plugin developers.
	//
	// Some examples for categories include:
	// - Kubernetes Plugin: "Workloads", "Networking", "Storage"
	// - AWS Plugin: "Compute", "Storage", "Database"
	// - GCP Plugin: "Compute", "Storage", "Database"
	// - Azure Plugin: "Compute", "Storage", "Database"
	Category string `json:"category"`
}

type ResourceOperationError struct {
	Err         error    `json:"-"`                     // underlying error (not serialized)
	Code        string   `json:"code"`                  // standard code: NOT_FOUND, FORBIDDEN, etc.
	Title       string   `json:"title"`                 // human-readable title
	Message     string   `json:"message"`               // detailed error message
	Suggestions []string `json:"suggestions,omitempty"` // user-facing suggestions
}

type ResourceOperationProvider interface {
	// Get returns a single resource in the given resource namespace.
	Get(ctx *types.PluginContext, key string, input GetInput) (*GetResult, error)
	// Get returns a single resource in the given resource namespace.
	List(ctx *types.PluginContext, key string, input ListInput) (*ListResult, error)
	// FindResources returns a list of resources in the given resource namespace that
	// match a set of given options.
	Find(ctx *types.PluginContext, key string, input FindInput) (*FindResult, error)
	// Create creates a new resource in the given resource namespace.
	Create(
		ctx *types.PluginContext,
		key string,
		input CreateInput,
	) (*CreateResult, error)
	// Update updates an existing resource in the given resource namespace.
	Update(
		ctx *types.PluginContext,
		key string,
		input UpdateInput,
	) (*UpdateResult, error)
	// Delete deletes an existing resource in the given resource namespace.
	Delete(
		ctx *types.PluginContext,
		key string,
		input DeleteInput,
	) (*DeleteResult, error)
}

type ResourceProvider interface {
	ResourceTypeProvider
	ResourceConnectionProvider
	ResourceInformerProvider
	ResourceLayoutProvider
	ResourceOperationProvider
	ResourceActionProvider
	ResourceSchemaProvider
}

type ResourceSchemaProvider interface {
	GetEditorSchemas(ctx *types.PluginContext, connectionID string) ([]EditorSchema, error)
}

type ResourceTypeProvider interface {
	// GetResourceGroups returns the available groups
	GetResourceGroups(conn string) map[string]ResourceGroup
	// GetResourceGroup returns a group by name
	GetResourceGroup(string) (ResourceGroup, error)
	// GetResourceTypes returns the all of the available resource types for the resource manager
	GetResourceTypes(conn string) map[string]ResourceMeta
	// GetResourceType returns the resource type information by it's string representation
	// For example, "core::v1::Pod" or "ec2::2012-12-01::EC2Instance"
	GetResourceType(string) (*ResourceMeta, error)
	// HasResourceType checks to see if the resource type exists
	HasResourceType(string) bool
	// GetResourceDefinition returns the resource definitions for the resource provider
	// based on the resource type
	GetResourceDefinition(string) (ResourceDefinition, error)
}

type Resourcer[ClientT any] interface {
	// Get returns a single resource in the given resource namespace.
	Get(ctx *plugin.PluginContext, client *ClientT, meta ResourceMeta, input GetInput) (*GetResult, error)

	// List returns a list of resources in the given resource namespace.
	List(ctx *plugin.PluginContext, client *ClientT, meta ResourceMeta, input ListInput) (*ListResult, error)

	// FindResources returns a list of resources in the given resource namespace that
	// match a set of given options.
	//
	// Due to the dynamic nature of the options, the options are passed as an interface
	// and the Resourcer is responsible for casting the options to the correct type.
	Find(ctx *plugin.PluginContext, client *ClientT, meta ResourceMeta, input FindInput) (*FindResult, error)

	// Create creates a new resource in the given resource namespace.
	Create(ctx *plugin.PluginContext, client *ClientT, meta ResourceMeta, input CreateInput) (*CreateResult, error)

	// Update updates an existing resource in the given resource namespace.
	Update(ctx *plugin.PluginContext, client *ClientT, meta ResourceMeta, input UpdateInput) (*UpdateResult, error)

	// Delete deletes an existing resource in the given resource namespace.
	Delete(ctx *plugin.PluginContext, client *ClientT, meta ResourceMeta, input DeleteInput) (*DeleteResult, error)
}

type SchemaResourcer[ClientT any] interface {
	GetEditorSchemas(ctx *types.PluginContext, client *ClientT, meta ResourceMeta) ([]EditorSchema, error)
}

type UpdateInput struct {
	// Options is a set of arbitrary options to the delete operation that must be
	// resolved by the Resourcer.
	Input map[string]interface{} `json:"input"`

	// Params is used as an injectable field for any operations that require extra data
	Params map[string]interface{} `json:"params"`

	// ID is the unique identifier of the resource to update.
	ID string `json:"id"`

	// Namespace is an optional identifier to use when a resource backend supports
	// a concept of partitioning resources (like with corev1.Namespace in Kubernetes)
	Namespace string `json:"namespace"`
}

type UpdateResult struct {
	// Result is the result of the operation.
	Result map[string]interface{} `json:"result"`

	// Success is a flag that indicates if the operation was successful.
	Success bool `json:"success"`
}