types

type AuthProvider struct {
	// Cluster is the cluster identifier of the context
	Config map[string]string `yaml:"config"`
	// User is the user identifier of the context
	Name string `yaml:"name"`
}

type Cache struct {
	Kind string `yaml:"kind"`
	// Config is store-specific configuration for the cache
	// Check the documentation for each cache to see configuration options
	Config interface{} `yaml:"config"`
}

type Cluster struct {
	// CertificateAuthorityData contains CA info
	CertificateAuthorityData string `yaml:"certificate-authority-data,omitempty"`
	// Server is the API server address
	Server string `yaml:"server"`
	// Insecure defines if the API server can be accessed with no CA checks
	Insecure bool `yaml:"insecure-skip-tls-verify,omitempty"`
}

type Config struct {
	// Kind is the type of the config. Expects "SwitchConfig"
	Kind string `yaml:"kind"`
	// Version is the version of the config file.
	// Possible values: "v1alpha1"
	Version string `yaml:"version"`
	// KubeconfigName is the global default for how the kubeconfig is
	// identified in the backing store.
	// Can be overridden in the individual kubeconfig store configuration
	// + optional
	KubeconfigName *string `yaml:"kubeconfigName"`
	// ShowPreview configures if the selection dialog shows a sanitized preview of the kubeconfig file.
	// Can be overridden via command line flag --show-preview true/false
	// default: true
	// + optional
	ShowPreview *bool `yaml:"showPreview"`
	// ExecShell configures the shell to be used for switch exec -- "command"
	// If a shell (bash, zsh, sh) is provided, the command is executed like so
	// --> bash -c "your_command"
	ExecShell *string `yaml:"execShell"`
	// RefreshIndexAfter is the global default for how often
	// the index for this kubeconfig store shall be refreshed.
	// Not setting this field will cause kubeswitch to not use an index
	// Can be overridden in the individual kubeconfig store configuration
	// + optional
	RefreshIndexAfter *time.Duration `yaml:"refreshIndexAfter"`
	// Hooks defines configurations for commands that shall be executed prior to the search
	Hooks []Hook `yaml:"hooks"`
	// KubeconfigStores contains the configuration for kubeconfig stores
	KubeconfigStores []KubeconfigStore `yaml:"kubeconfigStores"`
}

type ConfigOld struct {
	Kind                          string           `yaml:"kind"`
	KubeconfigName                string           `yaml:"kubeconfigName"`
	KubeconfigRediscoveryInterval *time.Duration   `yaml:"kubeconfigRediscoveryInterval"`
	VaultAPIAddress               string           `yaml:"vaultAPIAddress"`
	Hooks                         []Hook           `yaml:"hooks"`
	KubeconfigPaths               []KubeconfigPath `yaml:"kubeconfigPaths"`
}

type Context struct {
	// Cluster is the cluster identifier of the context
	Cluster string `yaml:"cluster"`
	// User is the user identifier of the context
	User string
}

type ContextAlias struct {
	// ContextToAliasMapping defines how alias names are written
	// used internally by the kubeswitch tool
	ContextToAliasMapping map[string]string `yaml:"contextToAliasMapping"`
}

type EnvMap struct {
	Name  string `yaml:"name"`
	Value string `yaml:"value"`
}

type ExecProvider struct {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values.
	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
	// +optional
	APIVersion         string   `yaml:"apiVersion,omitempty" protobuf:"bytes,2,opt,name=apiVersion"`
	Args               []string `yaml:"args"`
	Command            string   `yaml:"command"`
	Env                []EnvMap `yaml:"env"`
	InstallHint        string   `yaml:"installHint,omitempty"`
	ProvideClusterInfo bool     `yaml:"provideClusterInfo,omitempty"`
}

type GCPAuthenticationType string

type GKEAuthentication struct {
	// possible values:
	// defaults to "gcloud"
	// + optional
	AuthenticationType *GCPAuthenticationType `yaml:"authenticationType"`
	// APIKeyFilePath is the path on the local filesystem to the file that contains
	// an API key used to authenticate against the Google Kubernetes Engine API
	// + optional
	APIKeyFilePath *string `yaml:"apiKeyFilePath"`
	// ServiceAccountFilePath is the path on the local filesystem to the file that contains
	// the GCP service account used to authenticate against the Google Kubernetes Engine API
	// + optional
	ServiceAccountFilePath *string `yaml:"serviceAccountFilePath"`
}

type Hook struct {
	// Name is the name of the Hook
	Name string `yaml:"name"`
	// Type is the type of the Hook (either "Executable" or "InlineCommand")
	Type HookType `yaml:"type"`
	// Path defines the path to the executable that shall be called when the
	// Type is "Executable"
	Path *string `yaml:"path"`
	// Arguments are the arguments with which the external executable of a Hook of type
	// "Executable" will be called
	Arguments []string `yaml:"arguments"`
	// Execution contains configuration regarding the execution of the Hook
	Execution *struct {
		// Interval defines the interval how often the Hook is executed
		// if this field is not set, it can only be executed on demand with "switch hooks --hook-name <name>"
		Interval *time.Duration `yaml:"interval"`
	} `yaml:"execution"`
}

type HookState struct {
	// HookName is the name of the Hooks
	HookName string `yaml:"hookName"`
	// LastExecutionTime is the last execution time of the hook
	// used to check if the Hook has to be executed again
	LastExecutionTime time.Time `yaml:"lastExecutionTime"`
}

type HookType string

type Index struct {
	// Kind defines which store kind this Index belongs to
	Kind StoreKind `yaml:"kind"`
	// ContextToPathMapping contains the actual index, mapping the context name
	// to the kubeconfig path in the backing store
	ContextToPathMapping map[string]string `yaml:"contextToPathMapping"`
	// ContextToTags contains optional metadata ("tags") for a context name
	// For instance, the DigitalOcean store uses this as the getKubeconfigForPath() requires to know the cluster_ID of a DOKS cluster, which
	// for beauty reasons, is not stored in the visible kubeconfig_path. The cluster_ID for a context_name is stored as a tag instead.
	ContextToTags map[string]map[string]string `yaml:"contextToTags"`
}

type IndexState struct {
	// Kind defines which store kind this Index belongs to
	Kind StoreKind `yaml:"kind"`
	// LastUpdateTime is the last time the index has been updated
	LastUpdateTime time.Time `yaml:"lastExecutionTime"`
}

type KubeCluster struct {
	// Name is the name of the cluster
	Name string `yaml:"name"`
	// Cluster contains cluster configuration information
	Cluster Cluster `yaml:"cluster"`
}

type KubeConfig struct {
	// TypeMeta common k8s type meta definition
	TypeMeta TypeMeta `yaml:",inline"`
	// CurrentContext is the current context of the kubeconfig file
	CurrentContext string `yaml:"current-context"`
	// Contexts are all defined contexts of the kubeconfig file
	Contexts []KubeContext `yaml:"contexts"`
	// Clusters are the cluster configurations
	Clusters []KubeCluster `yaml:"clusters"`
	// Users are the user configurations
	Users []KubeUser `yaml:"users"`
}

type KubeContext struct {
	// Name is the name of the context
	Name string `yaml:"name"`
	// Context contains context configuration
	Context Context `yaml:"context"`
}

type KubeUser struct {
	// Name is the name of the user
	// only parse the name, not the credentials
	Name string `yaml:"name"`
	// User contains user auth information
	User User `yaml:"user"`
}

type KubeconfigPath struct {
	Path  string    `yaml:"path"`
	Store StoreKind `yaml:"store"`
}

type KubeconfigStore struct {
	// ID is the ID of the kubeconfig store.
	// Used to write distinct index files for each store
	// Not required if only one store of a store kind is configured
	// + optional
	ID *string `yaml:"id"`
	// Kind identifies a supported store kind - filesystem, vault, Gardener.
	Kind StoreKind `yaml:"kind"`
	// KubeconfigName defines how the kubeconfig is identified in the backing store
	// For the Filesystem store, this is the name of the file that contains the kubeconfig
	// For the Vault store, this is the secret key
	// For other stores this field is not used
	// + optional
	KubeconfigName *string `yaml:"kubeconfigName"`
	// Paths contains the paths to search for in the backing store
	Paths []string `yaml:"paths"`
	// RefreshIndexAfter defines how often the index for this kubeconfig store shall be refreshed.
	// Not setting this field will cause kubeswitch to not use an index
	// + optional
	RefreshIndexAfter *time.Duration `yaml:"refreshIndexAfter"`
	// Required defines if errors when initializing this store should be logged
	// defaults to true
	// useful when configuring a kubeconfig store that is not always available
	// However, when searching on an index and wanting to retrieve the kubeconfig from an unavailable store,
	// it will throw an errors nonetheless
	// + optional
	Required *bool `yaml:"required"`
	// ShowPrefix configures if the search result should include store specific prefix (e.g for the filesystem store the parent directory name)
	// default: true
	ShowPrefix *bool `yaml:"showPrefix"`
	// Config is store-specific configuration.
	// Please check the documentation for each backing provider to see what configuration is
	// possible here
	Config interface{} `yaml:"config"`
	// Cache allows to cache the kubeconfigs in the backing store
	// + optional
	Cache *Cache `yaml:"cache"`
}

type StoreConfigAzure struct {
	// SubscriptionID is the name of the Azure Subscription kubeswitch shall discover Azure clusters from
	// Please create on store per subscription
	// + optional
	SubscriptionID *string `yaml:"subscriptionID"`
	// Endpoint is the base URL for Azure.
	// Defaults to the public cloud endpoint "https://management.azure.com/"
	// Example Alternatives:
	// - Azure Germany: https://management.microsoftazure.de/
	// - Azure US Gov: https://management.usgovcloudapi.net/
	// - Azure China: https://management.chinacloudapi.cn/
	// + optional
	Endpoint *string `yaml:"endpoint"`
	// ResourceGroups limits the search to clusters within the given resource groups
	// + optional
	ResourceGroups []string `yaml:"resourceGroups"`
}

type StoreConfigEKS struct {
	// Region is the AWS region to search for clusters https://docs.aws.amazon.com/general/latest/gr/rande.html
	Region *string `yaml:"region"`
	// Profile is the named profile to authenticate with https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html
	Profile string `yaml:"profile"`
}

type StoreConfigGKE struct {
	// GKEAuthentication contains authentication configuration for GCP
	GKEAuthentication *GKEAuthentication `yaml:"Authentication"`
	// GCPAccount is the name of the gcp account kubeswitch shall discover GKE clusters from
	// Only used when relying on gcloud authentication.
	// Used to verify that gcloud currently has the correct account activated
	// However, will not actively activate another account (has to be done manually by the user).
	// If not specified, will use the currently activated account when using gcloud
	// + optional
	GCPAccount *string `yaml:"gcpAccount"`
	// ProjectID contains an optional list of projects that will be considered in the search for existing GKE clusters.
	// If no projects are given, will discover clusters from every found project.
	ProjectIDs []string `yaml:"projectIDs"`
}

type StoreConfigGardener struct {
	// GardenerAPIKubeconfigPath is the path on the local filesystem pointing to the kubeconfig
	// for the Gardener API server
	GardenerAPIKubeconfigPath string `yaml:"gardenerAPIKubeconfigPath"`
	// LandscapeName is a custom name for the Gardener landscape
	// uses this name instead of the default ID from the Gardener API ConfigMap "cluster-identity"
	// also used as the store ID if the kubeconfig store ID is not specified
	// + optional
	LandscapeName *string `yaml:"landscapeName"`
}

type StoreConfigOVH struct {
	OVHApplicationKey    string `yaml:"application_key"`
	OVHApplicationSecret string `yaml:"application_secret"`
	OVHConsumerKey       string `yaml:"consumer_key"`
	OVHEndpoint          string `yaml:"endpoint"`
}

type StoreConfigRancher struct {
	// RancherAPIAddress is the URL of the Rancher API, e.g. https://rancher.example.com/v3
	RancherAPIAddress string `yaml:"rancherAPIAddress"`
	// RancherToken is the token used to authenticate against the Rancher API, format: token-12abc:bmjlzslas......x4hv5ptc29wt4sfk
	RancherToken string `yaml:"rancherToken"`
}

type StoreConfigScaleway struct {
	ScalewayOrganizationID string `yaml:"organization_id"`
	ScalewayAccessKey      string `yaml:"access_key"`
	ScalewaySecretKey      string `yaml:"secret_key"`
	ScalewayRegion         string `yaml:"region"`
}

type StoreConfigVault struct {
	// VaultAPIAddress is the URL of the Vault API
	VaultAPIAddress    string `yaml:"vaultAPIAddress"`
	VaultEngineVersion string `yaml:"vaultEngineVersion"`
	VaultKeyKubeconfig string `yaml:"vaultKeyKubeconfig"`
}

type StoreKind string

type TypeMeta struct {
	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated.
	// In CamelCase.
	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
	// +optional
	Kind string `yaml:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`

	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values.
	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
	// +optional
	APIVersion string `yaml:"apiVersion,omitempty" protobuf:"bytes,2,opt,name=apiVersion"`
}

type User struct {
	// AuthProvider contains configuration for an external auth provider
	AuthProvider *AuthProvider `yaml:"auth-provider,omitempty"`
	// ExecProvider
	ExecProvider *ExecProvider `yaml:"exec,omitempty"`
}