v1

type Abort struct {
	HTTPStatus  int    `json:"httpStatus,omitempty"`
	HTTP2Status string `json:"http2Status,omitempty"`
	GRPCStatus  string `json:"grpcStatus,omitempty"`
}

type AutoscaleConfig struct {
	EnableAutoScale      bool `json:"enableAutoScale,omitempty"`
	ContainerConcurrency int  `json:"containerConcurrency,omitempty"`
	MinScale             int  `json:"minScale,omitempty"`
	MaxScale             int  `json:"maxScale,omitempty"`
}

type BindOptions struct {
	Propagation Propagation `json:"propagation,omitempty"`
}

type Client struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type Clients struct {
	Interface Interface

	Stack           StackClient
	ExternalService ExternalServiceClient
	Service         ServiceClient
	Config          ConfigClient
	Volume          VolumeClient
	RouteSet        RouteSetClient
}

type Condition struct {
	// Type of cluster condition.
	Type string `json:"type"`
	// Status of the condition, one of True, False, Unknown.
	Status v1.ConditionStatus `json:"status"`
	// The last time this condition was updated.
	LastUpdateTime string `json:"lastUpdateTime,omitempty"`
	// Last time the condition transitioned from one status to another.
	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
	// The reason for the condition's last transition.
	Reason string `json:"reason,omitempty"`
	// Human-readable message indicating details about last transition
	Message string `json:"message,omitempty"`
}

type Config struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ConfigSpec   `json:"spec,omitempty"`
	Status ConfigStatus `json:"status,omitempty"`
}

type ConfigChangeHandlerFunc func(obj *Config) (runtime.Object, error)

type ConfigClient interface {
	Create(*Config) (*Config, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Config, error)
	Update(*Config) (*Config, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ConfigClientCache

	OnCreate(ctx context.Context, name string, sync ConfigChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ConfigChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ConfigChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ConfigInterface
}

type ConfigClientCache interface {
	Get(namespace, name string) (*Config, error)
	List(namespace string, selector labels.Selector) ([]*Config, error)

	Index(name string, indexer ConfigIndexer)
	GetIndexed(name, key string) ([]*Config, error)
}

type ConfigController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ConfigLister
	AddHandler(ctx context.Context, name string, handler ConfigHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ConfigHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ConfigHandlerFunc func(key string, obj *Config) (runtime.Object, error)

type ConfigIndexer func(obj *Config) ([]string, error)

type ConfigInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Config) (*Config, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Config, error)
	Get(name string, opts metav1.GetOptions) (*Config, error)
	Update(*Config) (*Config, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ConfigList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ConfigController
	AddHandler(ctx context.Context, name string, sync ConfigHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ConfigLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ConfigHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ConfigLifecycle)
}

type ConfigLifecycle interface {
	Create(obj *Config) (runtime.Object, error)
	Remove(obj *Config) (runtime.Object, error)
	Updated(obj *Config) (runtime.Object, error)
}

type ConfigList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Config
}

type ConfigLister interface {
	List(namespace string, selector labels.Selector) (ret []*Config, err error)
	Get(namespace, name string) (*Config, error)
}

type ConfigMapping struct {
	Source string `json:"source,omitempty" norman:"required"`
	Target string `json:"target,omitempty"`
	UID    int    `json:"uid,omitempty"`
	GID    int    `json:"gid,omitempty"`
	Mode   string `json:"mode,omitempty"`
}

type ConfigSpec struct {
	Description string `json:"description,omitempty"`
	Content     string `json:"content,omitempty"`
	Encoded     bool   `json:"encoded,omitempty"`
	StackScoped
}

type ConfigStatus struct {
	Conditions []condition.GenericCondition `json:"conditions,omitempty"`
}

type ConfigsGetter interface {
	Configs(namespace string) ConfigInterface
}

type ContainerConfig struct {
	ContainerPrivilegedConfig

	CPUs                   string        `json:"nanoCpus,omitempty"`
	CapAdd                 []string      `json:"capAdd,omitempty"`  // support string
	CapDrop                []string      `json:"capDrop,omitempty"` // support string
	Command                []string      `json:"command,omitempty"` // support string
	DefaultVolumeDriver    string        `json:"defaultVolumeDriver,omitempty"`
	Entrypoint             []string      `json:"entrypoint,omitempty"`
	Environment            []string      `json:"environment,omitempty"` // alias env, support map
	ExposedPorts           []ExposedPort `json:"expose,omitempty"`      // support []string, map
	Group                  string        `json:"group,omitempty"`
	Healthcheck            *HealthConfig `json:"healthcheck,omitempty"`
	Readycheck             *HealthConfig `json:"readycheck,omitempty"`
	Image                  string        `json:"image,omitempty"`
	ImagePullPolicy        string        `json:"imagePullPolicy,omitempty" norman:"type=enum,options=always|never|not-present,default=not-present"`
	Init                   bool          `json:"init,omitempty"`
	MemoryLimitBytes       int64         `json:"memoryLimitBytes,omitempty"`
	MemoryReservationBytes int64         `json:"memoryReservationBytes,omitempty"`
	OpenStdin              bool          `json:"stdinOpen,omitempty"` // alias interactive
	PortBindings           []PortBinding `json:"ports,omitempty"`     // support []string
	ReadonlyRootfs         bool          `json:"readOnly,omitempty"`
	Tmpfs                  []Tmpfs       `json:"tmpfs,omitempty"` // support []string too
	Tty                    bool          `json:"tty,omitempty"`
	User                   string        `json:"user,omitempty"`
	Volumes                []Mount       `json:"volumes,omitempty"`     // support []string too
	VolumesFrom            []string      `json:"volumesFrom,omitempty"` // support []string too
	WorkingDir             string        `json:"workingDir,omitempty"`

	Devices []DeviceMapping `json:"devices,omitempty"` // support []string and map[string]string
	Configs []ConfigMapping `json:"configs,omitempty"`
	Secrets []SecretMapping `json:"secrets,omitempty"`
}

type ContainerPrivilegedConfig struct {
	Privileged bool `json:"privileged,omitempty"`
}

type CustomResourceDefinition struct {
	Kind    string `json:"kind,omitempty"`
	Group   string `json:"group,omitempty"`
	Version string `json:"version,omitempty"`
}

type Destination struct {
	Service  string  `json:"service,omitempty"`
	Stack    string  `json:"stack,omitempty"`
	Revision string  `json:"revision,omitempty"`
	Port     *uint32 `json:"port,omitempty"`
}

type DeviceMapping struct {
	OnHost      string `json:"onHost,omitempty"`
	InContainer string `json:"inContainer,omitempty"`
	Permissions string `json:"permissions,omitempty"`
}

type Endpoint struct {
	URL string `json:"url,omitempty"`
}

type ExposedPort struct {
	Name string `json:"name,omitempty"`
	PortBinding
}

type ExternalService struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              ExternalServiceSpec   `json:"spec,omitempty"`
	Status            ExternalServiceStatus `json:"status,omitempty"`
}

type ExternalServiceChangeHandlerFunc func(obj *ExternalService) (runtime.Object, error)

type ExternalServiceClient interface {
	Create(*ExternalService) (*ExternalService, error)
	Get(namespace, name string, opts metav1.GetOptions) (*ExternalService, error)
	Update(*ExternalService) (*ExternalService, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ExternalServiceList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ExternalServiceClientCache

	OnCreate(ctx context.Context, name string, sync ExternalServiceChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ExternalServiceChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ExternalServiceChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ExternalServiceInterface
}

type ExternalServiceClientCache interface {
	Get(namespace, name string) (*ExternalService, error)
	List(namespace string, selector labels.Selector) ([]*ExternalService, error)

	Index(name string, indexer ExternalServiceIndexer)
	GetIndexed(name, key string) ([]*ExternalService, error)
}

type ExternalServiceController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ExternalServiceLister
	AddHandler(ctx context.Context, name string, handler ExternalServiceHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ExternalServiceHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ExternalServiceHandlerFunc func(key string, obj *ExternalService) (runtime.Object, error)

type ExternalServiceIndexer func(obj *ExternalService) ([]string, error)

type ExternalServiceInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*ExternalService) (*ExternalService, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ExternalService, error)
	Get(name string, opts metav1.GetOptions) (*ExternalService, error)
	Update(*ExternalService) (*ExternalService, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ExternalServiceList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ExternalServiceController
	AddHandler(ctx context.Context, name string, sync ExternalServiceHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ExternalServiceLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ExternalServiceHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ExternalServiceLifecycle)
}

type ExternalServiceLifecycle interface {
	Create(obj *ExternalService) (runtime.Object, error)
	Remove(obj *ExternalService) (runtime.Object, error)
	Updated(obj *ExternalService) (runtime.Object, error)
}

type ExternalServiceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ExternalService
}

type ExternalServiceLister interface {
	List(namespace string, selector labels.Selector) (ret []*ExternalService, err error)
	Get(namespace, name string) (*ExternalService, error)
}

type ExternalServiceSpec struct {
	Target string `json:"target,omitempty"`
	StackScoped
}

type ExternalServiceStatus struct {
	Conditions []condition.GenericCondition `json:"conditions,omitempty"`
}

type ExternalServicesGetter interface {
	ExternalServices(namespace string) ExternalServiceInterface
}

type Fault struct {
	Percentage  int   `json:"percentage,omitempty" norman:"min=0,max=100"`
	DelayMillis int   `json:"delayMillis,omitempty"`
	Abort       Abort `json:"abort,omitempty"`
}

type HealthConfig struct {
	// Test is the test to perform to check that the container is healthy.
	// An empty slice means to inherit the default.
	// The options are:
	// {} : inherit healthcheck
	// {"NONE"} : disable healthcheck
	// {"CMD", args...} : exec arguments directly
	// {"CMD-SHELL", command} : run command with system's default shell
	Test []string `json:"test,omitempty"` //alias string, deal with CMD, CMD-SHELL, NONE

	IntervalSeconds     int `json:"intervalSeconds,omitempty" norman:"default=10"`   // support friendly numbers, alias periodSeconds, period
	TimeoutSeconds      int `json:"timeoutSeconds,omitempty" norman:"default=5"`     // support friendly numbers
	InitialDelaySeconds int `json:"initialDelaySeconds,omitempty"`                   //alias start_period
	HealthyThreshold    int `json:"healthyThreshold,omitempty" norman:"default=1"`   //alias retries, successThreshold
	UnhealthyThreshold  int `json:"unhealthyThreshold,omitempty" norman:"default=3"` //alias failureThreshold, set to retries if unset
}

type Interface interface {
	RESTClient() rest.Interface
	controller.Starter

	StacksGetter
	ExternalServicesGetter
	ServicesGetter
	ConfigsGetter
	VolumesGetter
	RouteSetsGetter
}

type InternalStack struct {
	Services         map[string]Service         `json:"services,omitempty"`
	Configs          map[string]Config          `json:"configs,omitempty"`
	Volumes          map[string]Volume          `json:"volumes,omitempty"`
	Routes           map[string]RouteSet        `json:"routes,omitempty"`
	ExternalServices map[string]ExternalService `json:"externalservices,omitempty"`
	Kubernetes       Kubernetes                 `json:"kubernetes,omitempty"`
}

type Kubernetes struct {
	CustomResourceDefinitions           []CustomResourceDefinition `json:"customResourceDefinitions,omitempty"`
	NamespacedCustomResourceDefinitions []CustomResourceDefinition `json:"namespacedCustomResourceDefinitions,omitempty"`
	Manifest                            string                     `json:"manifest,omitempty"`
	NamespacedManifest                  string                     `json:"namespacedManifest,omitempty"`
}

type Match struct {
	Path    *StringMatch           `json:"path,omitempty"`
	Scheme  *StringMatch           `json:"scheme,omitempty"`
	Method  *StringMatch           `json:"method,omitempty"`
	Headers map[string]StringMatch `json:"headers,omitempty"`
	Cookies map[string]StringMatch `json:"cookies,omitempty"`
	Port    *int                   `json:"port,omitempty"`
	From    *ServiceSource         `json:"from,omitempty"`
}

type Mount struct {
	Kind string `json:"kind,omitempty" norman:"type=enum,options=bind|volume"`
	// Source specifies the name of the mount. Depending on mount type, this
	// may be a volume name or a host path, or even ignored.
	Source   string `json:"source,omitempty"`
	Target   string `json:"target,omitempty"`
	ReadOnly bool   `json:"readonly,omitempty"`

	BindOptions   *BindOptions   `json:"bind,omitempty"`
	VolumeOptions *VolumeOptions `json:"volume,omitempty"`
}

type NodeScheduling struct {
	NodeName   string   `json:"nodeName,omitempty" norman:"type=reference[/v1/schemas/node]"`
	RequireAll []string `json:"requireAll,omitempty"`
	RequireAny []string `json:"requireAny,omitempty"`
	Preferred  []string `json:"preferred,omitempty"`
}

type Permission struct {
	Role     string   `json:"role,omitempty"`
	Verbs    []string `json:"verbs,omitempty"`
	APIGroup string   `json:"apiGroup,omitempty"`
	Resource string   `json:"resource,omitempty"`
	URL      string   `json:"url,omitempty"`
	Name     string   `json:"name,omitempty"`
}

type PodConfig struct {
	Hostname               string       `json:"hostname,omitempty"`
	Global                 bool         `json:"global,omitempty"`
	Scheduling             Scheduling   `json:"scheduling,omitempty"`
	StopGracePeriodSeconds *int         `json:"stopGracePeriod,omitempty"`                                                           // support friendly numbers
	RestartPolicy          string       `json:"restart,omitempty" norman:"type=enum,options=never|on-failure|always,default=always"` //support no and OnFailure
	DNS                    []string     `json:"dns,omitempty"`                                                                       // support string
	DNSOptions             []string     `json:"dnsOptions,omitempty"`                                                                // support string
	DNSSearch              []string     `json:"dnsSearch,omitempty"`                                                                 // support string
	ExtraHosts             []string     `json:"extraHosts,omitempty"`                                                                // support map
	GlobalPermissions      []Permission `json:"globalPermissions,omitempty"`
	Permissions            []Permission `json:"permissions,omitempty"`
}

type PortBinding struct {
	Port       int64  `json:"port,omitempty"`
	Protocol   string `json:"protocol,omitempty"`
	IP         string `json:"ip,omitempty"`
	TargetPort int64  `json:"targetPort,omitempty"`
}

type PrivilegedConfig struct {
	NetworkMode string `json:"net,omitempty" norman:"type=enum,options=default|host,default=default"` // alias network, support bridge
	IpcMode     string `json:"ipc,omitempty" norman:"type=enum,options=default|host,default=default"`
	PidMode     string `json:"pid,omitempty" norman:"type=enum,options=default|host,default=default"`
}

type Propagation string

type Redirect struct {
	Host string `json:"host,omitempty"`
	Path string `json:"path,omitempty"`
}

type Retry struct {
	Attempts      int `json:"attempts,omitempty"`
	TimeoutMillis int `json:"timeoutMillis,omitempty"`
}

type Rewrite struct {
	Host string `json:"host,omitempty"`
	Path string `json:"path,omitempty"`
}

type RouteSet struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   RouteSetSpec   `json:"spec,omitempty"`
	Status RouteSetStatus `json:"status,omitempty"`
}

type RouteSetChangeHandlerFunc func(obj *RouteSet) (runtime.Object, error)

type RouteSetClient interface {
	Create(*RouteSet) (*RouteSet, error)
	Get(namespace, name string, opts metav1.GetOptions) (*RouteSet, error)
	Update(*RouteSet) (*RouteSet, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*RouteSetList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() RouteSetClientCache

	OnCreate(ctx context.Context, name string, sync RouteSetChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync RouteSetChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync RouteSetChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() RouteSetInterface
}

type RouteSetClientCache interface {
	Get(namespace, name string) (*RouteSet, error)
	List(namespace string, selector labels.Selector) ([]*RouteSet, error)

	Index(name string, indexer RouteSetIndexer)
	GetIndexed(name, key string) ([]*RouteSet, error)
}

type RouteSetController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() RouteSetLister
	AddHandler(ctx context.Context, name string, handler RouteSetHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RouteSetHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type RouteSetHandlerFunc func(key string, obj *RouteSet) (runtime.Object, error)

type RouteSetIndexer func(obj *RouteSet) ([]string, error)

type RouteSetInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*RouteSet) (*RouteSet, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*RouteSet, error)
	Get(name string, opts metav1.GetOptions) (*RouteSet, error)
	Update(*RouteSet) (*RouteSet, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*RouteSetList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() RouteSetController
	AddHandler(ctx context.Context, name string, sync RouteSetHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle RouteSetLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RouteSetHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RouteSetLifecycle)
}

type RouteSetLifecycle interface {
	Create(obj *RouteSet) (runtime.Object, error)
	Remove(obj *RouteSet) (runtime.Object, error)
	Updated(obj *RouteSet) (runtime.Object, error)
}

type RouteSetList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []RouteSet
}

type RouteSetLister interface {
	List(namespace string, selector labels.Selector) (ret []*RouteSet, err error)
	Get(namespace, name string) (*RouteSet, error)
}

type RouteSetSpec struct {
	Routes []RouteSpec `json:"routes,omitempty"`
	StackScoped
}

type RouteSetStatus struct {
	Conditions []Condition `json:"conditions,omitempty"`
}

type RouteSetsGetter interface {
	RouteSets(namespace string) RouteSetInterface
}

type RouteSpec struct {
	Matches    []Match               `json:"matches,omitempty"`
	To         []WeightedDestination `json:"to,omitempty"`
	Redirect   *Redirect             `json:"redirect,omitempty"`
	Rewrite    *Rewrite              `json:"rewrite,omitempty"`
	AddHeaders []string              `json:"addHeaders,omitempty"`

	RouteTraffic
}

type RouteTraffic struct {
	Fault         *Fault       `json:"fault,omitempty"`
	Mirror        *Destination `json:"mirror,omitempty"`
	TimeoutMillis *int         `json:"timeoutMillis,omitempty"`
	Retry         *Retry       `json:"retry,omitempty"`
}

type ScaleStatus struct {
	Ready       int `json:"ready,omitempty"`
	Unavailable int `json:"unavailable,omitempty"`
	Available   int `json:"available,omitempty"`
	Updated     int `json:"updated,omitempty"`
}

type Scheduling struct {
	Node      NodeScheduling `json:"node,omitempty"`
	Scheduler string         `json:"scheduler,omitempty"`
}

type SecretMapping struct {
	Source string `json:"source,omitempty" norman:"required"`
	Target string `json:"target,omitempty"`
	Mode   string `json:"mode,omitempty"`
}

type Service struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ServiceSpec   `json:"spec,omitempty"`
	Status ServiceStatus `json:"status,omitempty"`
}

type ServiceChangeHandlerFunc func(obj *Service) (runtime.Object, error)

type ServiceClient interface {
	Create(*Service) (*Service, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Service, error)
	Update(*Service) (*Service, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*ServiceList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() ServiceClientCache

	OnCreate(ctx context.Context, name string, sync ServiceChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync ServiceChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync ServiceChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() ServiceInterface
}

type ServiceClientCache interface {
	Get(namespace, name string) (*Service, error)
	List(namespace string, selector labels.Selector) ([]*Service, error)

	Index(name string, indexer ServiceIndexer)
	GetIndexed(name, key string) ([]*Service, error)
}

type ServiceController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() ServiceLister
	AddHandler(ctx context.Context, name string, handler ServiceHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ServiceHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type ServiceHandlerFunc func(key string, obj *Service) (runtime.Object, error)

type ServiceIndexer func(obj *Service) ([]string, error)

type ServiceInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Service) (*Service, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Service, error)
	Get(name string, opts metav1.GetOptions) (*Service, error)
	Update(*Service) (*Service, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*ServiceList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() ServiceController
	AddHandler(ctx context.Context, name string, sync ServiceHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle ServiceLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ServiceHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ServiceLifecycle)
}

type ServiceLifecycle interface {
	Create(obj *Service) (runtime.Object, error)
	Remove(obj *Service) (runtime.Object, error)
	Updated(obj *Service) (runtime.Object, error)
}

type ServiceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Service
}

type ServiceLister interface {
	List(namespace string, selector labels.Selector) (ret []*Service, err error)
	Get(namespace, name string) (*Service, error)
}

type ServiceRevision struct {
	Version       string `json:"version,omitempty"`
	Weight        int    `json:"weight,omitempty"`
	Promote       bool   `json:"promote,omitempty"`
	ServiceName   string `json:"serviceName,omitempty"`
	ParentService string `json:"parentService,omitempty"`
}

type ServiceSource struct {
	Service  string `json:"service,omitempty"`
	Stack    string `json:"stack,omitempty"`
	Revision string `json:"revision,omitempty"`
}

type ServiceSpec struct {
	ServiceUnversionedSpec
	StackScoped
	Revision ServiceRevision `json:"revision,omitempty"`
}

type ServiceStatus struct {
	DeploymentStatus  *appsv1.DeploymentStatus  `json:"deploymentStatus,omitempty"`
	DaemonSetStatus   *appsv1.DaemonSetStatus   `json:"daemonSetStatus,omitempty"`
	StatefulSetStatus *appsv1.StatefulSetStatus `json:"statefulSetStatus,omitempty"`
	ScaleStatus       *ScaleStatus              `json:"scaleStatus,omitempty"`
	Conditions        []Condition               `json:"conditions,omitempty"`
	Endpoints         []Endpoint                `json:"endpoints,omitempty"`
}

type ServiceUnversionedSpec struct {
	Labels             map[string]string `json:"labels,omitempty"`
	Metadata           map[string]string `json:"metadata,omitempty"` //alias annotations
	Scale              int               `json:"scale"`
	BatchSize          int               `json:"batchSize,omitempty"`
	UpdateOrder        string            `json:"updateOrder,omitempty" norman:"type=enum,options=start-first|stop-first"`
	UpdateStrategy     string            `json:"updateStrategy,omitempty" norman:"type=enum,options=rolling|on-delete,default=rolling"`
	DeploymentStrategy string            `json:"deploymentStrategy,omitempty" norman:"type=enum,options=parallel|ordered,default=parallel"`
	AutoscaleConfig

	PodConfig
	PrivilegedConfig
	Sidekicks map[string]SidekickConfig `json:"sidekicks,omitempty"`

	ContainerConfig
}

type ServicesGetter interface {
	Services(namespace string) ServiceInterface
}

type SidekickConfig struct {
	InitContainer bool `json:"initContainer,omitempty"`
	ContainerConfig
}

type Stack struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   StackSpec   `json:"spec"`
	Status StackStatus `json:"status"`
}

type StackChangeHandlerFunc func(obj *Stack) (runtime.Object, error)

type StackClient interface {
	Create(*Stack) (*Stack, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Stack, error)
	Update(*Stack) (*Stack, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*StackList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() StackClientCache

	OnCreate(ctx context.Context, name string, sync StackChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync StackChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync StackChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() StackInterface
}

type StackClientCache interface {
	Get(namespace, name string) (*Stack, error)
	List(namespace string, selector labels.Selector) ([]*Stack, error)

	Index(name string, indexer StackIndexer)
	GetIndexed(name, key string) ([]*Stack, error)
}

type StackController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() StackLister
	AddHandler(ctx context.Context, name string, handler StackHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler StackHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type StackHandlerFunc func(key string, obj *Stack) (runtime.Object, error)

type StackIndexer func(obj *Stack) ([]string, error)

type StackInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Stack) (*Stack, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Stack, error)
	Get(name string, opts metav1.GetOptions) (*Stack, error)
	Update(*Stack) (*Stack, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*StackList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() StackController
	AddHandler(ctx context.Context, name string, sync StackHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle StackLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync StackHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle StackLifecycle)
}

type StackLifecycle interface {
	Create(obj *Stack) (runtime.Object, error)
	Remove(obj *Stack) (runtime.Object, error)
	Updated(obj *Stack) (runtime.Object, error)
}

type StackList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Stack
}

type StackLister interface {
	List(namespace string, selector labels.Selector) (ret []*Stack, err error)
	Get(namespace, name string) (*Stack, error)
}

type StackScoped struct {
	StackName   string `json:"stackName,omitempty" norman:"type=reference[stack],required,noupdate"`
	ProjectName string `json:"projectName,omitempty" norman:"type=reference[/v1-rio/schemas/project],noupdate"`
}

type StackSpec struct {
	Description               string            `json:"description,omitempty"`
	Template                  string            `json:"template,omitempty"`
	AdditionalFiles           map[string]string `json:"additionalFiles,omitempty"`
	Answers                   map[string]string `json:"answers,omitempty"`
	Questions                 []v3.Question     `json:"questions,omitempty"`
	DisableMesh               bool              `json:"disableMesh,omitempty"`
	EnableAutoscale           bool              `json:"enableAutoscale,omitempty"`
	EnableKubernetesResources bool              `json:"enableKubernetesResources,omitempty"`
}

type StackStatus struct {
	Conditions []Condition `json:"conditions,omitempty"`
}

type StacksGetter interface {
	Stacks(namespace string) StackInterface
}

type StringMatch struct {
	Exact  string `json:"exact,omitempty"`
	Prefix string `json:"prefix,omitempty"`
	Regexp string `json:"regexp,omitempty"`
}

type Tmpfs struct {
	SizeBytes int64  `json:"sizeBytes,omitempty"`
	ReadOnly  bool   `json:"readOnly,omitempty"`
	Path      string `json:"path,omitempty" norman:"required"`
}

type Volume struct {
	types.Namespaced

	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VolumeSpec   `json:"spec,omitempty"`
	Status VolumeStatus `json:"status,omitempty"`
}

type VolumeChangeHandlerFunc func(obj *Volume) (runtime.Object, error)

type VolumeClient interface {
	Create(*Volume) (*Volume, error)
	Get(namespace, name string, opts metav1.GetOptions) (*Volume, error)
	Update(*Volume) (*Volume, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	List(namespace string, opts metav1.ListOptions) (*VolumeList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)

	Cache() VolumeClientCache

	OnCreate(ctx context.Context, name string, sync VolumeChangeHandlerFunc)
	OnChange(ctx context.Context, name string, sync VolumeChangeHandlerFunc)
	OnRemove(ctx context.Context, name string, sync VolumeChangeHandlerFunc)
	Enqueue(namespace, name string)

	Generic() controller.GenericController
	ObjectClient() *objectclient.ObjectClient
	Interface() VolumeInterface
}

type VolumeClientCache interface {
	Get(namespace, name string) (*Volume, error)
	List(namespace string, selector labels.Selector) ([]*Volume, error)

	Index(name string, indexer VolumeIndexer)
	GetIndexed(name, key string) ([]*Volume, error)
}

type VolumeController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() VolumeLister
	AddHandler(ctx context.Context, name string, handler VolumeHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler VolumeHandlerFunc)
	Enqueue(namespace, name string)
	Sync(ctx context.Context) error
	Start(ctx context.Context, threadiness int) error
}

type VolumeHandlerFunc func(key string, obj *Volume) (runtime.Object, error)

type VolumeIndexer func(obj *Volume) ([]string, error)

type VolumeInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*Volume) (*Volume, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*Volume, error)
	Get(name string, opts metav1.GetOptions) (*Volume, error)
	Update(*Volume) (*Volume, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*VolumeList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() VolumeController
	AddHandler(ctx context.Context, name string, sync VolumeHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle VolumeLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync VolumeHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle VolumeLifecycle)
}

type VolumeLifecycle interface {
	Create(obj *Volume) (runtime.Object, error)
	Remove(obj *Volume) (runtime.Object, error)
	Updated(obj *Volume) (runtime.Object, error)
}

type VolumeList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Volume
}

type VolumeLister interface {
	List(namespace string, selector labels.Selector) (ret []*Volume, err error)
	Get(namespace, name string) (*Volume, error)
}

type VolumeOptions struct {
	NoCopy   bool   `json:"noCopy,omitempty"`
	Driver   string `json:"driver,omitempty"`
	SizeInGB int    `json:"sizeInGb,omitempty"`
	SubPath  string `json:"subPath,omitempty"`
}

type VolumeSpec struct {
	Description string `json:"description,omitempty"`
	Driver      string `json:"driver,omitempty"`
	Template    bool   `json:"template,omitempty,noupdate"`
	SizeInGB    int    `json:"sizeInGb,omitempty,required"`
	AccessMode  string `json:"accessMode,omitempty" norman:"type=enum,options=readWriteOnce|readOnlyMany|readWriteMany,default=readWriteOnce"`
	StackScoped
}

type VolumeStatus struct {
	PVCStatus  *v1.PersistentVolumeClaimStatus `json:"pvcStatus,omitempty"`
	Conditions []Condition                     `json:"conditions,omitempty"`
}

type VolumesGetter interface {
	Volumes(namespace string) VolumeInterface
}

type WeightedDestination struct {
	Destination
	Weight int `json:"weight,omitempty"`
}