diff --git a/api/v1/cluster.go b/api/v1/cluster.go
index 68fe02110..c10d69e65 100644
--- a/api/v1/cluster.go
+++ b/api/v1/cluster.go
@@ -85,6 +85,26 @@ type ClusterMetadata struct {
 	HubClusterID         string          `json:"hubClusterID,omitempty" protobuf:"bytes,10,opt,name=hubClusterID"`
 	CloudServiceAuthMode string          `json:"cloudServiceAuthMode,omitempty" protobuf:"bytes,11,opt,name=cloudServiceAuthMode"`
 	Mode                 ClusterMode     `json:"mode,omitempty" protobuf:"bytes,12,opt,name=mode,casttype=ClusterMode"`
+	License              *LicenseInfo    `json:"license,omitempty" protobuf:"bytes,13,opt,name=license"`
+}
+
+// +kubebuilder:validation:Enum=appscode;selfhosted
+type LicenseDistributor string
+
+const (
+	LicenseDistributorAppsCode   LicenseDistributor = "appscode"
+	LicenseDistributorSelfHosted LicenseDistributor = "selfhosted"
+)
+
+type LicenseInfo struct {
+	Distributor LicenseDistributor `json:"distributor,omitempty" protobuf:"bytes,1,opt,name=distributor,casttype=LicenseDistributor"`
+	// Endpoint is the platform-api to acquire licenses from, when Distributor is selfhosted.
+	Endpoint string `json:"endpoint,omitempty" protobuf:"bytes,2,opt,name=endpoint"`
+	OrgID    string `json:"orgID,omitempty" protobuf:"bytes,3,opt,name=orgID"`
+}
+
+func (l *LicenseInfo) IsEmpty() bool {
+	return l == nil || (l.Distributor == "" && l.Endpoint == "" && l.OrgID == "")
 }
 
 func (md ClusterMetadata) Manager() string {
diff --git a/api/v1/generated.pb.go b/api/v1/generated.pb.go
index b70728acd..960901b3a 100644
--- a/api/v1/generated.pb.go
+++ b/api/v1/generated.pb.go
@@ -325,10 +325,38 @@ func (m *ImageInfo) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ImageInfo proto.InternalMessageInfo
 
+func (m *LicenseInfo) Reset()      { *m = LicenseInfo{} }
+func (*LicenseInfo) ProtoMessage() {}
+func (*LicenseInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{10}
+}
+func (m *LicenseInfo) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *LicenseInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+func (m *LicenseInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_LicenseInfo.Merge(m, src)
+}
+func (m *LicenseInfo) XXX_Size() int {
+	return m.Size()
+}
+func (m *LicenseInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_LicenseInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LicenseInfo proto.InternalMessageInfo
+
 func (m *Lineage) Reset()      { *m = Lineage{} }
 func (*Lineage) ProtoMessage() {}
 func (*Lineage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{10}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{11}
 }
 func (m *Lineage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -356,7 +384,7 @@ var xxx_messageInfo_Lineage proto.InternalMessageInfo
 func (m *ObjectID) Reset()      { *m = ObjectID{} }
 func (*ObjectID) ProtoMessage() {}
 func (*ObjectID) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{11}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{12}
 }
 func (m *ObjectID) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -384,7 +412,7 @@ var xxx_messageInfo_ObjectID proto.InternalMessageInfo
 func (m *ObjectInfo) Reset()      { *m = ObjectInfo{} }
 func (*ObjectInfo) ProtoMessage() {}
 func (*ObjectInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{12}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{13}
 }
 func (m *ObjectInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -412,7 +440,7 @@ var xxx_messageInfo_ObjectInfo proto.InternalMessageInfo
 func (m *ObjectReference) Reset()      { *m = ObjectReference{} }
 func (*ObjectReference) ProtoMessage() {}
 func (*ObjectReference) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{13}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{14}
 }
 func (m *ObjectReference) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -440,7 +468,7 @@ var xxx_messageInfo_ObjectReference proto.InternalMessageInfo
 func (m *PullCredentials) Reset()      { *m = PullCredentials{} }
 func (*PullCredentials) ProtoMessage() {}
 func (*PullCredentials) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{14}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{15}
 }
 func (m *PullCredentials) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -468,7 +496,7 @@ var xxx_messageInfo_PullCredentials proto.InternalMessageInfo
 func (m *ReadonlyHealthCheckSpec) Reset()      { *m = ReadonlyHealthCheckSpec{} }
 func (*ReadonlyHealthCheckSpec) ProtoMessage() {}
 func (*ReadonlyHealthCheckSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{15}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{16}
 }
 func (m *ReadonlyHealthCheckSpec) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -496,7 +524,7 @@ var xxx_messageInfo_ReadonlyHealthCheckSpec proto.InternalMessageInfo
 func (m *ResourceID) Reset()      { *m = ResourceID{} }
 func (*ResourceID) ProtoMessage() {}
 func (*ResourceID) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{16}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{17}
 }
 func (m *ResourceID) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -524,7 +552,7 @@ var xxx_messageInfo_ResourceID proto.InternalMessageInfo
 func (m *TLSConfig) Reset()      { *m = TLSConfig{} }
 func (*TLSConfig) ProtoMessage() {}
 func (*TLSConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{17}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{18}
 }
 func (m *TLSConfig) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -552,7 +580,7 @@ var xxx_messageInfo_TLSConfig proto.InternalMessageInfo
 func (m *TimeOfDay) Reset()      { *m = TimeOfDay{} }
 func (*TimeOfDay) ProtoMessage() {}
 func (*TimeOfDay) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{18}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{19}
 }
 func (m *TimeOfDay) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TimeOfDay.Unmarshal(m, b)
@@ -575,7 +603,7 @@ var xxx_messageInfo_TimeOfDay proto.InternalMessageInfo
 func (m *TypeReference) Reset()      { *m = TypeReference{} }
 func (*TypeReference) ProtoMessage() {}
 func (*TypeReference) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{19}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{20}
 }
 func (m *TypeReference) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -603,7 +631,7 @@ var xxx_messageInfo_TypeReference proto.InternalMessageInfo
 func (m *TypedObjectReference) Reset()      { *m = TypedObjectReference{} }
 func (*TypedObjectReference) ProtoMessage() {}
 func (*TypedObjectReference) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{20}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{21}
 }
 func (m *TypedObjectReference) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -631,7 +659,7 @@ var xxx_messageInfo_TypedObjectReference proto.InternalMessageInfo
 func (m *X509Subject) Reset()      { *m = X509Subject{} }
 func (*X509Subject) ProtoMessage() {}
 func (*X509Subject) Descriptor() ([]byte, []int) {
-	return fileDescriptor_af8e7a11c7a1ccd9, []int{21}
+	return fileDescriptor_af8e7a11c7a1ccd9, []int{22}
 }
 func (m *X509Subject) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -668,6 +696,7 @@ func init() {
 	proto.RegisterType((*Condition)(nil), "kmodules.xyz.client_go.api.v1.Condition")
 	proto.RegisterType((*HealthCheckSpec)(nil), "kmodules.xyz.client_go.api.v1.HealthCheckSpec")
 	proto.RegisterType((*ImageInfo)(nil), "kmodules.xyz.client_go.api.v1.ImageInfo")
+	proto.RegisterType((*LicenseInfo)(nil), "kmodules.xyz.client_go.api.v1.LicenseInfo")
 	proto.RegisterType((*Lineage)(nil), "kmodules.xyz.client_go.api.v1.Lineage")
 	proto.RegisterType((*ObjectID)(nil), "kmodules.xyz.client_go.api.v1.ObjectID")
 	proto.RegisterType((*ObjectInfo)(nil), "kmodules.xyz.client_go.api.v1.ObjectInfo")
@@ -687,141 +716,146 @@ func init() {
 }
 
 var fileDescriptor_af8e7a11c7a1ccd9 = []byte{
-	// 2140 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcf, 0x6f, 0x1c, 0x49,
-	0xf5, 0x77, 0x67, 0xc6, 0xf1, 0xcc, 0x1b, 0x3b, 0x4e, 0x2a, 0xfe, 0x2a, 0x93, 0x7c, 0x37, 0x1e,
-	0xd3, 0x11, 0x51, 0x02, 0x9b, 0x36, 0x8e, 0x12, 0x08, 0x11, 0x08, 0x3c, 0x63, 0x27, 0x99, 0x5d,
-	0x3b, 0x1e, 0x6a, 0x1c, 0x76, 0xb5, 0x8b, 0x58, 0x95, 0xbb, 0xcb, 0xe3, 0xc2, 0x3d, 0xdd, 0xad,
-	0xaa, 0xee, 0xd9, 0x9d, 0x3d, 0x2d, 0x27, 0x40, 0x5c, 0x96, 0x1b, 0xc7, 0x8d, 0xc4, 0x9f, 0x80,
-	0x84, 0xf8, 0x0b, 0xc8, 0x31, 0x5c, 0xd0, 0x4a, 0xa0, 0x11, 0x19, 0xae, 0x88, 0x0b, 0x42, 0x02,
-	0x9f, 0x50, 0x55, 0x57, 0xff, 0x98, 0xf6, 0x78, 0xed, 0x85, 0xe5, 0x36, 0xf3, 0xde, 0xe7, 0x7d,
-	0xea, 0x55, 0xd5, 0xab, 0xf7, 0xa3, 0xe1, 0xce, 0x61, 0xdf, 0x77, 0x22, 0x97, 0x0a, 0xeb, 0x83,
-	0xe1, 0x87, 0xab, 0xb6, 0xcb, 0xa8, 0x17, 0xde, 0xe9, 0xf9, 0xab, 0x24, 0x60, 0xab, 0x83, 0xb5,
-	0xd5, 0x1e, 0xf5, 0x28, 0x27, 0x21, 0x75, 0xac, 0x80, 0xfb, 0xa1, 0x8f, 0xae, 0xe7, 0xe1, 0x56,
-	0x0c, 0x7f, 0xaf, 0xe7, 0x5b, 0x24, 0x60, 0xd6, 0x60, 0xed, 0xda, 0x9d, 0x1e, 0x0b, 0x0f, 0xa2,
-	0x3d, 0xcb, 0xf6, 0xfb, 0xab, 0x3d, 0xbf, 0xe7, 0xaf, 0x2a, 0xab, 0xbd, 0x68, 0x5f, 0xfd, 0x53,
-	0x7f, 0xd4, 0xaf, 0x98, 0xed, 0x9a, 0x79, 0xf8, 0x40, 0x58, 0x2c, 0x5e, 0xcc, 0xf6, 0x39, 0x9d,
-	0xb2, 0xe2, 0xb5, 0x7b, 0x19, 0xa6, 0x4f, 0xec, 0x03, 0xe6, 0x51, 0x3e, 0x5c, 0x0d, 0x0e, 0x7b,
-	0x52, 0x20, 0x56, 0xfb, 0x34, 0x24, 0x53, 0xac, 0xcc, 0xdf, 0x18, 0xb0, 0xd8, 0x5a, 0xef, 0xb4,
-	0x5b, 0x6e, 0x24, 0x42, 0xca, 0xdb, 0xde, 0xbe, 0x8f, 0xbe, 0x05, 0x95, 0x80, 0xfb, 0x03, 0xe6,
-	0x50, 0x5e, 0x37, 0x56, 0x8c, 0x5b, 0xd5, 0xe6, 0xca, 0x8b, 0x51, 0x63, 0x66, 0x3c, 0x6a, 0x54,
-	0x3a, 0x5a, 0x7e, 0x34, 0x6a, 0xcc, 0x4b, 0xb3, 0xe4, 0x3f, 0x4e, 0x2d, 0xd0, 0x2a, 0x54, 0x3d,
-	0xd2, 0xa7, 0x22, 0x20, 0x36, 0xad, 0x9f, 0x53, 0xe6, 0x97, 0xb4, 0x79, 0xf5, 0x69, 0xa2, 0xc0,
-	0x19, 0x06, 0xdd, 0x87, 0x9a, 0x1d, 0xaf, 0x2e, 0xd5, 0xf5, 0x92, 0x32, 0xb9, 0xac, 0x4d, 0x6a,
-	0xad, 0x4c, 0x85, 0xf3, 0x38, 0xf3, 0x5d, 0xf8, 0xbf, 0x16, 0xe5, 0x21, 0xdb, 0x67, 0x36, 0x09,
-	0x69, 0x87, 0xb3, 0x01, 0x09, 0xe9, 0x9b, 0x74, 0x88, 0x9a, 0x50, 0xa1, 0x9e, 0xed, 0x3b, 0xcc,
-	0xeb, 0x69, 0xf7, 0x6f, 0x26, 0xee, 0x6f, 0x6a, 0xf9, 0xd1, 0xa8, 0x81, 0x32, 0x8b, 0x44, 0x8a,
-	0x53, 0x3b, 0xf3, 0xef, 0xb3, 0xb0, 0x98, 0x63, 0xef, 0x06, 0xd4, 0x46, 0x37, 0x60, 0x96, 0xb8,
-	0x8c, 0x08, 0x4d, 0xba, 0xa0, 0x49, 0x67, 0xd7, 0xa5, 0x10, 0xc7, 0x3a, 0xf4, 0x0e, 0x54, 0x99,
-	0x10, 0x11, 0xe5, 0x98, 0xee, 0xab, 0xdd, 0xd7, 0xee, 0xde, 0xb1, 0xe2, 0x9b, 0x51, 0x77, 0x2f,
-	0x6f, 0xcf, 0x1a, 0xac, 0x59, 0xbb, 0xc3, 0x80, 0x3a, 0x5b, 0xbe, 0x4d, 0xdc, 0x9d, 0xbd, 0x1f,
-	0x51, 0x3b, 0xc4, 0x74, 0x9f, 0x72, 0xea, 0xd9, 0xb4, 0xb9, 0x20, 0x0f, 0xaa, 0x9d, 0x70, 0xe0,
-	0x8c, 0x0e, 0xdd, 0x05, 0x10, 0xd4, 0xe6, 0x34, 0xcc, 0x9d, 0x13, 0xd2, 0x5e, 0x40, 0x37, 0xd5,
-	0xe0, 0x1c, 0x0a, 0x7d, 0x0f, 0xe6, 0x44, 0xa4, 0x56, 0xa8, 0x97, 0x95, 0x37, 0x5f, 0xb1, 0x3e,
-	0x33, 0x32, 0xad, 0xb7, 0xef, 0x7f, 0xed, 0x9b, 0xdd, 0xd8, 0xa2, 0x59, 0x1b, 0x8f, 0x1a, 0x73,
-	0xfa, 0x0f, 0x4e, 0x78, 0xd0, 0xdb, 0x50, 0x71, 0x22, 0x4e, 0x42, 0xe6, 0x7b, 0xf5, 0x59, 0xc5,
-	0x69, 0xe5, 0x76, 0x98, 0xc6, 0x9e, 0x15, 0x1c, 0xf6, 0xa4, 0x40, 0x58, 0x32, 0xf6, 0x24, 0xf5,
-	0x86, 0xb6, 0x6a, 0xce, 0xcb, 0xbb, 0x48, 0xfe, 0xe1, 0x94, 0x0d, 0x11, 0xa8, 0x71, 0xea, 0xd1,
-	0xf7, 0x9b, 0x74, 0xdf, 0xe7, 0xb4, 0x7e, 0xfe, 0x3f, 0x22, 0x5f, 0x94, 0x51, 0x83, 0x33, 0x1a,
-	0x9c, 0xe7, 0x44, 0xb7, 0xa0, 0xe2, 0x78, 0x42, 0xc5, 0x61, 0x7d, 0x6e, 0xa5, 0x74, 0xab, 0xaa,
-	0x9d, 0x79, 0xda, 0x55, 0x32, 0x9c, 0x6a, 0xd1, 0x1a, 0xd4, 0x58, 0xb0, 0xee, 0x38, 0x9c, 0x0a,
-	0x41, 0x45, 0xbd, 0xa2, 0xc0, 0x8a, 0xbc, 0xdd, 0x49, 0xc5, 0x38, 0x8f, 0x41, 0xaf, 0x41, 0x39,
-	0xe2, 0x4c, 0xd4, 0xab, 0x0a, 0x5b, 0x19, 0x8f, 0x1a, 0xe5, 0x67, 0xb8, 0x2d, 0xb0, 0x92, 0xa2,
-	0x87, 0x70, 0x81, 0xf6, 0x09, 0x73, 0x33, 0x4e, 0x50, 0x38, 0x34, 0x1e, 0x35, 0x2e, 0x6c, 0x4e,
-	0x68, 0x70, 0x01, 0x89, 0x1c, 0x80, 0x20, 0x8d, 0xd7, 0x7a, 0x4d, 0x1d, 0xcc, 0xbd, 0x53, 0x6e,
-	0x72, 0xea, 0xeb, 0x68, 0x5e, 0x90, 0xc1, 0x92, 0xfd, 0xc7, 0x39, 0x5e, 0xf3, 0x27, 0x25, 0x58,
-	0xd2, 0xef, 0xad, 0xe5, 0x12, 0xd6, 0x7f, 0x44, 0x49, 0x18, 0x71, 0x2a, 0xd0, 0xcf, 0x0d, 0x58,
-	0xa4, 0x1e, 0xd9, 0x73, 0xa9, 0x93, 0xc8, 0xea, 0xc6, 0x4a, 0xe9, 0x56, 0xed, 0xee, 0x93, 0xd3,
-	0x9c, 0x98, 0x42, 0x67, 0x6d, 0x4e, 0x52, 0x6d, 0x7a, 0x21, 0x1f, 0x36, 0xaf, 0xe8, 0x48, 0x5e,
-	0x2c, 0x68, 0x71, 0x71, 0x65, 0xf4, 0x2e, 0x5c, 0xa5, 0x1f, 0x84, 0x94, 0x7b, 0xc4, 0x75, 0x87,
-	0xdb, 0xc4, 0x23, 0xbd, 0x9c, 0x5b, 0xe7, 0xd4, 0x99, 0x5e, 0x1f, 0x8f, 0x1a, 0x57, 0x37, 0x4f,
-	0x02, 0xe1, 0x93, 0xed, 0xd1, 0x77, 0xe1, 0xa2, 0xc3, 0xc4, 0xe4, 0x56, 0x4b, 0x8a, 0x73, 0x69,
-	0x3c, 0x6a, 0x5c, 0xdc, 0x28, 0xe8, 0xf0, 0x31, 0xf4, 0xb5, 0x26, 0x2c, 0x4d, 0xdb, 0x20, 0xba,
-	0x08, 0xa5, 0x43, 0x3a, 0x8c, 0xb3, 0x07, 0x96, 0x3f, 0xd1, 0x12, 0xcc, 0x0e, 0x88, 0x1b, 0xe9,
-	0x34, 0x89, 0xe3, 0x3f, 0x0f, 0xcf, 0x3d, 0x30, 0xcc, 0x1f, 0x1b, 0x70, 0x31, 0x7f, 0x74, 0x2a,
-	0x2f, 0xf7, 0x61, 0x51, 0x27, 0xc0, 0x6d, 0x1a, 0x12, 0x87, 0x84, 0x44, 0x91, 0x9d, 0xfe, 0xa6,
-	0x73, 0xc9, 0x3d, 0x3b, 0xe6, 0xd6, 0x24, 0x15, 0x2e, 0x72, 0x9b, 0x7f, 0x34, 0xa0, 0x96, 0x2f,
-	0x0b, 0xd7, 0xa1, 0x14, 0x31, 0x47, 0x67, 0xbf, 0x9a, 0xa6, 0x29, 0x3d, 0x6b, 0x6f, 0x60, 0x29,
-	0x47, 0x2b, 0x50, 0x96, 0x39, 0x5d, 0xa7, 0xfc, 0x79, 0xad, 0x2f, 0xab, 0x8c, 0xa4, 0x34, 0xe8,
-	0xdb, 0x99, 0xff, 0xea, 0xd0, 0x79, 0x72, 0xb2, 0x97, 0xf3, 0xfe, 0x68, 0x15, 0x2e, 0x62, 0xd1,
-	0x16, 0x94, 0x6d, 0x12, 0x30, 0x9d, 0xc7, 0xac, 0xd3, 0xf6, 0x3c, 0x59, 0xd4, 0xe2, 0xd7, 0x28,
-	0x85, 0x58, 0xb1, 0x98, 0xff, 0x2a, 0x43, 0xf1, 0x08, 0xfe, 0xfb, 0x1d, 0xde, 0x87, 0x9a, 0xc3,
-	0x44, 0xe0, 0x92, 0xe1, 0xb4, 0x52, 0xb6, 0x91, 0xa9, 0x70, 0x1e, 0x87, 0xbe, 0x93, 0x2b, 0xb8,
-	0x65, 0x65, 0x73, 0x63, 0x4a, 0xc1, 0x5d, 0x7c, 0xe2, 0x8b, 0x90, 0x79, 0xbd, 0x29, 0x35, 0xf7,
-	0x36, 0xcc, 0xf9, 0xef, 0x7b, 0x94, 0xb7, 0x37, 0x54, 0x46, 0xae, 0x36, 0x17, 0xb5, 0xfd, 0xdc,
-	0x4e, 0x2c, 0xc6, 0x89, 0x5e, 0x96, 0x67, 0xf5, 0x53, 0x16, 0x20, 0x95, 0x61, 0x73, 0xe5, 0x79,
-	0x27, 0x51, 0xe0, 0x0c, 0x23, 0xf7, 0x44, 0x02, 0xb6, 0xe9, 0x39, 0x81, 0xcf, 0xbc, 0xb0, 0x3e,
-	0x37, 0xb9, 0xa7, 0xf5, 0x4e, 0x3b, 0x51, 0xe1, 0x3c, 0x0e, 0xbd, 0x0e, 0x15, 0x9b, 0x34, 0x23,
-	0xcf, 0x71, 0x69, 0xbd, 0xa2, 0x6c, 0x2e, 0x26, 0x7b, 0x6a, 0xad, 0xc7, 0x72, 0x9c, 0x22, 0xa4,
-	0x57, 0xfd, 0xf8, 0x9e, 0xdb, 0x1b, 0xf5, 0xea, 0xa4, 0x57, 0xdb, 0x89, 0x02, 0x67, 0x18, 0xf4,
-	0x00, 0xe6, 0x0f, 0xa2, 0xbd, 0xe4, 0x82, 0x37, 0xea, 0xa0, 0x6c, 0x96, 0xb4, 0xcd, 0xfc, 0x93,
-	0x9c, 0x0e, 0x4f, 0x20, 0x51, 0x07, 0x96, 0x6c, 0xd7, 0x8f, 0x9c, 0x2e, 0xe5, 0x03, 0x66, 0xd3,
-	0xf5, 0x28, 0x3c, 0xd8, 0xf6, 0x1d, 0xaa, 0x92, 0x6a, 0xb5, 0xf9, 0x9a, 0x66, 0x58, 0x6a, 0x4d,
-	0xc1, 0xe0, 0xa9, 0x96, 0x68, 0x15, 0xca, 0x7d, 0xc9, 0x30, 0xaf, 0x18, 0xfe, 0x3f, 0x89, 0x0b,
-	0xa9, 0x3b, 0xca, 0x3a, 0x18, 0x45, 0xa0, 0x80, 0xe6, 0x3f, 0x4b, 0x50, 0x6d, 0xf9, 0x9e, 0xc3,
-	0x54, 0xd5, 0x5b, 0x83, 0x72, 0x28, 0x2f, 0x23, 0xbe, 0xf9, 0xeb, 0x89, 0xb9, 0x3c, 0xfc, 0xa3,
-	0x51, 0x63, 0x21, 0x05, 0xaa, 0x8b, 0x51, 0x50, 0xf4, 0x43, 0x38, 0x2f, 0x42, 0x12, 0x46, 0x42,
-	0x5f, 0xf7, 0x23, 0x6d, 0x74, 0xbe, 0xab, 0xa4, 0x47, 0xa3, 0xc6, 0x99, 0xba, 0x41, 0x2b, 0xe5,
-	0x8e, 0xed, 0xb0, 0x66, 0x45, 0x6f, 0x00, 0xf2, 0xf7, 0x04, 0xe5, 0x03, 0xea, 0x3c, 0x8e, 0x1b,
-	0x46, 0x59, 0xec, 0x65, 0x38, 0x97, 0x9a, 0xd7, 0xf4, 0x5a, 0x68, 0xe7, 0x18, 0x02, 0x4f, 0xb1,
-	0x42, 0xeb, 0x50, 0x11, 0x74, 0x40, 0x39, 0x0b, 0x87, 0x3a, 0xde, 0xbe, 0x9c, 0x04, 0x42, 0x57,
-	0xcb, 0x8f, 0x46, 0x8d, 0x4b, 0x99, 0x2b, 0x5a, 0x88, 0x53, 0x33, 0x34, 0x00, 0xe4, 0x12, 0x11,
-	0xee, 0x72, 0xe2, 0x89, 0xf8, 0x28, 0x58, 0x9f, 0xaa, 0x48, 0x54, 0xb9, 0xef, 0x2c, 0xed, 0x81,
-	0xb4, 0xc8, 0x5c, 0xdf, 0x3a, 0xc6, 0x86, 0xa7, 0xac, 0x80, 0x6e, 0xc2, 0x79, 0x4e, 0x89, 0xf0,
-	0x3d, 0x1d, 0xc1, 0x17, 0x92, 0x63, 0xc6, 0x4a, 0x8a, 0xb5, 0x56, 0x3e, 0xbf, 0x3e, 0x15, 0x82,
-	0xf4, 0xa8, 0x8e, 0xdd, 0xf4, 0xf9, 0x6d, 0xc7, 0x62, 0x9c, 0xe8, 0xcd, 0xbf, 0x19, 0xb0, 0xf8,
-	0x84, 0x12, 0x37, 0x3c, 0x68, 0x1d, 0x50, 0xfb, 0x50, 0x35, 0x96, 0xbf, 0x30, 0xe0, 0x0a, 0xa7,
-	0xc4, 0xf1, 0x3d, 0x77, 0x58, 0xd0, 0xe9, 0x04, 0xff, 0xf5, 0x53, 0x92, 0x1d, 0x9e, 0x6e, 0xdd,
-	0x6c, 0x68, 0x3f, 0xae, 0x9c, 0x00, 0xc0, 0x27, 0xad, 0x8b, 0x1e, 0xc3, 0x25, 0x5d, 0xd8, 0xde,
-	0xe2, 0x2c, 0xa4, 0x4a, 0xa1, 0x12, 0x5f, 0xa5, 0x79, 0x55, 0x93, 0x5e, 0xda, 0x28, 0x02, 0xf0,
-	0x71, 0x1b, 0xf3, 0x1f, 0x06, 0x54, 0xdb, 0x7d, 0xd2, 0xa3, 0xaa, 0x86, 0xdc, 0x80, 0x59, 0x26,
-	0xff, 0x14, 0x7b, 0x68, 0x85, 0xc0, 0xb1, 0x0e, 0xed, 0x42, 0xc5, 0x65, 0x1e, 0x25, 0x3d, 0x5d,
-	0xce, 0x6b, 0x77, 0x6f, 0x9e, 0xb2, 0xff, 0xad, 0x18, 0x9e, 0xa5, 0x18, 0x2d, 0x10, 0x38, 0x65,
-	0x92, 0xd5, 0x33, 0x88, 0x5c, 0xb7, 0xc5, 0xa9, 0x43, 0xbd, 0x90, 0x11, 0x57, 0xa8, 0x80, 0x3e,
-	0xbd, 0x92, 0x74, 0x26, 0xad, 0xe2, 0x6a, 0x55, 0x10, 0xe2, 0x22, 0xb7, 0xf9, 0x33, 0x03, 0xe6,
-	0xb4, 0x17, 0xe8, 0x29, 0xcc, 0xda, 0x07, 0x84, 0x79, 0xba, 0x67, 0xba, 0x7d, 0xca, 0x82, 0xf1,
-	0x44, 0xa0, 0xaa, 0x56, 0x7a, 0x40, 0x2d, 0x69, 0x8f, 0x63, 0x1a, 0x64, 0x01, 0xd8, 0xbe, 0x17,
-	0x12, 0x19, 0xeb, 0x49, 0xc7, 0xa3, 0xfa, 0xba, 0x56, 0x2a, 0xc5, 0x39, 0x84, 0xf9, 0x2b, 0x03,
-	0x2a, 0x9a, 0x74, 0x43, 0x5e, 0x41, 0x8f, 0xfb, 0x51, 0x50, 0xbc, 0x82, 0xc7, 0x52, 0x88, 0x63,
-	0x9d, 0x2c, 0x75, 0x87, 0xcc, 0x73, 0x8a, 0xa5, 0xee, 0x4d, 0xe6, 0x39, 0x58, 0x69, 0x26, 0xc7,
-	0xbc, 0xd2, 0x19, 0xc6, 0xbc, 0xa4, 0x7a, 0x96, 0x4f, 0xaa, 0x9e, 0xe6, 0xaf, 0x0d, 0x80, 0x6c,
-	0xef, 0xe8, 0x2d, 0xa8, 0x70, 0x2a, 0xfc, 0x88, 0xdb, 0x54, 0x3f, 0x83, 0xdb, 0xa7, 0x3e, 0x83,
-	0x18, 0xde, 0xde, 0xc8, 0x22, 0x21, 0x91, 0xe1, 0x94, 0x0c, 0x6d, 0x43, 0x89, 0xa7, 0xd3, 0x99,
-	0x75, 0xa6, 0xcb, 0xc8, 0xc6, 0xb3, 0xb4, 0x2d, 0x90, 0xc3, 0x99, 0xe4, 0x31, 0x1d, 0x58, 0x2c,
-	0x80, 0x26, 0x0f, 0xc7, 0xf8, 0x1c, 0x87, 0x73, 0x62, 0x6b, 0x61, 0xfe, 0xd5, 0x80, 0x62, 0xd0,
-	0x7d, 0xfe, 0x65, 0xde, 0x00, 0x24, 0x74, 0xf1, 0xb2, 0x6d, 0x3f, 0xf2, 0xe2, 0x49, 0x32, 0x5e,
-	0x34, 0x4d, 0x8e, 0xdd, 0x63, 0x08, 0x3c, 0xc5, 0x0a, 0xfd, 0x20, 0x99, 0x46, 0x31, 0xdd, 0x8f,
-	0x1b, 0xb9, 0xda, 0xdd, 0x5b, 0xd3, 0x46, 0xdd, 0xa9, 0x53, 0x6e, 0x61, 0x6e, 0x95, 0x1c, 0x38,
-	0xc7, 0x67, 0xbe, 0x34, 0xe0, 0xa4, 0xa4, 0x85, 0xbe, 0x01, 0x0b, 0x01, 0xe5, 0xcc, 0x77, 0xba,
-	0xd4, 0xf6, 0x3d, 0x27, 0x1e, 0xc8, 0x67, 0x9b, 0x97, 0xc6, 0xa3, 0xc6, 0x42, 0x27, 0xaf, 0xc0,
-	0x93, 0x38, 0x39, 0x81, 0x85, 0xac, 0x4f, 0xfd, 0x28, 0x4c, 0x2c, 0xcf, 0x29, 0x4b, 0x35, 0x81,
-	0xed, 0x4e, 0x68, 0x70, 0x01, 0x29, 0xe7, 0x82, 0x7d, 0xc2, 0xdc, 0x88, 0xd3, 0xdd, 0x03, 0x4e,
-	0xc5, 0x81, 0xef, 0x3a, 0x2a, 0xec, 0x67, 0xe3, 0xb9, 0xe0, 0x51, 0x41, 0x87, 0x8f, 0xa1, 0xcd,
-	0x3f, 0x18, 0x00, 0x59, 0x84, 0x9e, 0xed, 0x1d, 0xde, 0x86, 0xb9, 0x01, 0xe5, 0x42, 0x56, 0xdf,
-	0x73, 0x93, 0x95, 0xe5, 0xfb, 0xb1, 0x18, 0x27, 0xfa, 0x34, 0x84, 0x4a, 0x27, 0x76, 0xa7, 0xc9,
-	0xa3, 0x2e, 0x9f, 0xf8, 0xa8, 0xef, 0xc1, 0xac, 0xb0, 0xfd, 0x80, 0xea, 0xb6, 0x62, 0x39, 0xf1,
-	0xa9, 0x2b, 0x85, 0xb2, 0x19, 0x49, 0xfc, 0x57, 0x02, 0x1c, 0x83, 0xcd, 0xdf, 0x1b, 0x50, 0xdd,
-	0xdd, 0xea, 0xb6, 0x7c, 0x6f, 0x9f, 0xf5, 0x26, 0xbf, 0x80, 0x18, 0x5f, 0xec, 0x17, 0x90, 0x03,
-	0x98, 0xb7, 0xb3, 0xa9, 0x36, 0xa9, 0x0e, 0xd6, 0xd9, 0x07, 0x61, 0x55, 0x15, 0xd3, 0x2e, 0x31,
-	0xa7, 0x10, 0x78, 0x82, 0xd9, 0xfc, 0x12, 0x54, 0x65, 0x40, 0xec, 0xec, 0x6f, 0x90, 0xe1, 0xc3,
-	0xa5, 0x5f, 0x7e, 0xd2, 0x98, 0xf9, 0xe9, 0xf3, 0xc6, 0xcc, 0xc7, 0xcf, 0x1b, 0x33, 0x9f, 0x3c,
-	0x6f, 0xcc, 0x7c, 0xf4, 0xa7, 0x95, 0x19, 0xf3, 0x3d, 0x58, 0x50, 0x2d, 0x59, 0xfa, 0xea, 0x5f,
-	0x87, 0x0a, 0x09, 0xd8, 0xe3, 0xdc, 0xa5, 0xa6, 0x59, 0x68, 0xbd, 0xd3, 0x8e, 0xef, 0x35, 0x45,
-	0x9c, 0x9e, 0x62, 0xcd, 0xdf, 0x1a, 0xb0, 0xa4, 0x4e, 0xa9, 0x98, 0x5e, 0xbe, 0xe0, 0x85, 0xfe,
-	0x17, 0xb9, 0xfc, 0x77, 0x25, 0xa8, 0xe5, 0x3e, 0x25, 0xc9, 0x37, 0xeb, 0xf3, 0x1e, 0xf1, 0xd8,
-	0x87, 0xaa, 0x2b, 0x8c, 0x3f, 0x1f, 0x54, 0xe3, 0x37, 0xbb, 0x93, 0x57, 0xe0, 0x49, 0x1c, 0xfa,
-	0x2a, 0x54, 0x55, 0xce, 0xe1, 0x2c, 0x1d, 0xee, 0x55, 0x7c, 0xb4, 0x12, 0x21, 0xce, 0xf4, 0xa8,
-	0x0d, 0x97, 0xf3, 0xd6, 0xc4, 0x7d, 0xe6, 0xb1, 0x30, 0x99, 0x32, 0xaf, 0x8c, 0x47, 0x8d, 0xcb,
-	0x3b, 0xc7, 0xd5, 0x78, 0x9a, 0x8d, 0xac, 0xb1, 0xae, 0x0c, 0x4e, 0x16, 0xca, 0x85, 0xcb, 0x59,
-	0x8d, 0xdd, 0x4a, 0xa5, 0x38, 0x87, 0x90, 0x7e, 0xaa, 0x71, 0xcc, 0xb3, 0xa9, 0xec, 0xca, 0x53,
-	0x3f, 0x3b, 0x89, 0x10, 0x67, 0x7a, 0x39, 0x09, 0x8b, 0x90, 0x53, 0x1a, 0x66, 0xdf, 0x82, 0xce,
-	0x67, 0x93, 0x70, 0x77, 0x52, 0x85, 0x8b, 0x58, 0xb4, 0x06, 0xb5, 0xc0, 0x17, 0x21, 0x71, 0x5b,
-	0xbe, 0x93, 0x7e, 0xc7, 0x52, 0x9f, 0xa6, 0x3a, 0x99, 0x18, 0xe7, 0x31, 0x72, 0x5e, 0x12, 0x94,
-	0x33, 0xe2, 0x3e, 0x8d, 0xfa, 0x7b, 0x94, 0xeb, 0x86, 0x36, 0x7d, 0x09, 0xdd, 0x9c, 0x0e, 0x4f,
-	0x20, 0x9b, 0xad, 0x17, 0xaf, 0x96, 0x67, 0x5e, 0xbe, 0x5a, 0x9e, 0xf9, 0xf4, 0xd5, 0xf2, 0xcc,
-	0x47, 0xe3, 0x65, 0xe3, 0xc5, 0x78, 0xd9, 0x78, 0x39, 0x5e, 0x36, 0x3e, 0x1d, 0x2f, 0x1b, 0x7f,
-	0x1e, 0x2f, 0x1b, 0x1f, 0xff, 0x65, 0x79, 0xe6, 0x9d, 0xeb, 0x9f, 0xf9, 0x79, 0xfc, 0xdf, 0x01,
-	0x00, 0x00, 0xff, 0xff, 0x1e, 0x81, 0x20, 0x02, 0x3e, 0x17, 0x00, 0x00,
+	// 2218 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0xcd, 0x6f, 0x1c, 0x49,
+	0x15, 0x77, 0x7b, 0xc6, 0xf6, 0xcc, 0x1b, 0x3b, 0x4e, 0x2a, 0x46, 0xe9, 0x0d, 0x1b, 0x8f, 0xe9,
+	0x15, 0x51, 0x02, 0x9b, 0x31, 0x89, 0x12, 0x08, 0x11, 0x08, 0x3c, 0x33, 0x4e, 0x32, 0x1b, 0x7f,
+	0x0c, 0x35, 0x0e, 0xbb, 0xda, 0x45, 0xac, 0xca, 0xdd, 0xe5, 0x71, 0xe1, 0x9e, 0xee, 0x51, 0x55,
+	0xf7, 0xec, 0xce, 0x9e, 0x96, 0x13, 0x20, 0x2e, 0xcb, 0x8d, 0xe3, 0x46, 0xe2, 0xca, 0x0d, 0x09,
+	0xf1, 0x17, 0x90, 0x03, 0x87, 0x70, 0x41, 0x2b, 0x81, 0x46, 0x64, 0xb8, 0x22, 0x2e, 0x08, 0x09,
+	0xf9, 0x84, 0xaa, 0xba, 0xfa, 0x6b, 0x3c, 0x5e, 0x7b, 0x61, 0xb9, 0x4d, 0xbf, 0xf7, 0x7b, 0xbf,
+	0xfa, 0x7a, 0x5f, 0x55, 0x03, 0xb7, 0x8e, 0x7a, 0xbe, 0x13, 0xba, 0x54, 0xd4, 0xde, 0x1f, 0x7e,
+	0xb0, 0x6e, 0xbb, 0x8c, 0x7a, 0xc1, 0xad, 0xae, 0xbf, 0x4e, 0xfa, 0x6c, 0x7d, 0x70, 0x7b, 0xbd,
+	0x4b, 0x3d, 0xca, 0x49, 0x40, 0x9d, 0x5a, 0x9f, 0xfb, 0x81, 0x8f, 0xae, 0x65, 0xe1, 0xb5, 0x08,
+	0xfe, 0x6e, 0xd7, 0xaf, 0x91, 0x3e, 0xab, 0x0d, 0x6e, 0x5f, 0xbd, 0xd5, 0x65, 0xc1, 0x61, 0xb8,
+	0x5f, 0xb3, 0xfd, 0xde, 0x7a, 0xd7, 0xef, 0xfa, 0xeb, 0xca, 0x6a, 0x3f, 0x3c, 0x50, 0x5f, 0xea,
+	0x43, 0xfd, 0x8a, 0xd8, 0xae, 0x5a, 0x47, 0xf7, 0x45, 0x8d, 0x45, 0x83, 0xd9, 0x3e, 0xa7, 0x53,
+	0x46, 0xbc, 0x7a, 0x37, 0xc5, 0xf4, 0x88, 0x7d, 0xc8, 0x3c, 0xca, 0x87, 0xeb, 0xfd, 0xa3, 0xae,
+	0x14, 0x88, 0xf5, 0x1e, 0x0d, 0xc8, 0x14, 0x2b, 0xeb, 0xb7, 0x06, 0x2c, 0x37, 0x36, 0xda, 0xad,
+	0x86, 0x1b, 0x8a, 0x80, 0xf2, 0x96, 0x77, 0xe0, 0xa3, 0x6f, 0x41, 0xa9, 0xcf, 0xfd, 0x01, 0x73,
+	0x28, 0x37, 0x8d, 0x35, 0xe3, 0x46, 0xb9, 0xbe, 0xf6, 0x7c, 0x54, 0x9d, 0x19, 0x8f, 0xaa, 0xa5,
+	0xb6, 0x96, 0x1f, 0x8f, 0xaa, 0x8b, 0xd2, 0x2c, 0xfe, 0xc6, 0x89, 0x05, 0x5a, 0x87, 0xb2, 0x47,
+	0x7a, 0x54, 0xf4, 0x89, 0x4d, 0xcd, 0x59, 0x65, 0x7e, 0x49, 0x9b, 0x97, 0x77, 0x62, 0x05, 0x4e,
+	0x31, 0xe8, 0x1e, 0x54, 0xec, 0x68, 0x74, 0xa9, 0x36, 0x0b, 0xca, 0xe4, 0xb2, 0x36, 0xa9, 0x34,
+	0x52, 0x15, 0xce, 0xe2, 0xac, 0x77, 0xe0, 0x0b, 0x0d, 0xca, 0x03, 0x76, 0xc0, 0x6c, 0x12, 0xd0,
+	0x36, 0x67, 0x03, 0x12, 0xd0, 0x27, 0x74, 0x88, 0xea, 0x50, 0xa2, 0x9e, 0xed, 0x3b, 0xcc, 0xeb,
+	0xea, 0xe9, 0x5f, 0x8f, 0xa7, 0xbf, 0xa9, 0xe5, 0xc7, 0xa3, 0x2a, 0x4a, 0x2d, 0x62, 0x29, 0x4e,
+	0xec, 0xac, 0x7f, 0xce, 0xc1, 0x72, 0x86, 0xbd, 0xd3, 0xa7, 0x36, 0x7a, 0x0d, 0xe6, 0x88, 0xcb,
+	0x88, 0xd0, 0xa4, 0x4b, 0x9a, 0x74, 0x6e, 0x43, 0x0a, 0x71, 0xa4, 0x43, 0x6f, 0x43, 0x99, 0x09,
+	0x11, 0x52, 0x8e, 0xe9, 0x81, 0x5a, 0x7d, 0xe5, 0xce, 0xad, 0x5a, 0x74, 0x32, 0xea, 0xec, 0xe5,
+	0xe9, 0xd5, 0x06, 0xb7, 0x6b, 0x7b, 0xc3, 0x3e, 0x75, 0xb6, 0x7c, 0x9b, 0xb8, 0xbb, 0xfb, 0x3f,
+	0xa2, 0x76, 0x80, 0xe9, 0x01, 0xe5, 0xd4, 0xb3, 0x69, 0x7d, 0x49, 0x6e, 0x54, 0x2b, 0xe6, 0xc0,
+	0x29, 0x1d, 0xba, 0x03, 0x20, 0xa8, 0xcd, 0x69, 0x90, 0xd9, 0x27, 0xa4, 0x67, 0x01, 0x9d, 0x44,
+	0x83, 0x33, 0x28, 0xf4, 0x3d, 0x58, 0x10, 0xa1, 0x1a, 0xc1, 0x2c, 0xaa, 0xd9, 0x7c, 0xa5, 0xf6,
+	0xa9, 0x9e, 0x59, 0x7b, 0xeb, 0xde, 0xd7, 0xbe, 0xd9, 0x89, 0x2c, 0xea, 0x95, 0xf1, 0xa8, 0xba,
+	0xa0, 0x3f, 0x70, 0xcc, 0x83, 0xde, 0x82, 0x92, 0x13, 0x72, 0x12, 0x30, 0xdf, 0x33, 0xe7, 0x14,
+	0x67, 0x2d, 0xb3, 0xc2, 0xc4, 0xf7, 0x6a, 0xfd, 0xa3, 0xae, 0x14, 0x88, 0x9a, 0xf4, 0x3d, 0x49,
+	0xdd, 0xd4, 0x56, 0xf5, 0x45, 0x79, 0x16, 0xf1, 0x17, 0x4e, 0xd8, 0x10, 0x81, 0x0a, 0xa7, 0x1e,
+	0x7d, 0xaf, 0x4e, 0x0f, 0x7c, 0x4e, 0xcd, 0xf9, 0xff, 0x8a, 0x7c, 0x59, 0x7a, 0x0d, 0x4e, 0x69,
+	0x70, 0x96, 0x13, 0xdd, 0x80, 0x92, 0xe3, 0x09, 0xe5, 0x87, 0xe6, 0xc2, 0x5a, 0xe1, 0x46, 0x59,
+	0x4f, 0x66, 0xa7, 0xa3, 0x64, 0x38, 0xd1, 0xa2, 0xdb, 0x50, 0x61, 0xfd, 0x0d, 0xc7, 0xe1, 0x54,
+	0x08, 0x2a, 0xcc, 0x92, 0x02, 0x2b, 0xf2, 0x56, 0x3b, 0x11, 0xe3, 0x2c, 0x06, 0xbd, 0x0a, 0xc5,
+	0x90, 0x33, 0x61, 0x96, 0x15, 0xb6, 0x34, 0x1e, 0x55, 0x8b, 0x4f, 0x71, 0x4b, 0x60, 0x25, 0x45,
+	0x0f, 0xe0, 0x02, 0xed, 0x11, 0xe6, 0xa6, 0x9c, 0xa0, 0x70, 0x68, 0x3c, 0xaa, 0x5e, 0xd8, 0xcc,
+	0x69, 0xf0, 0x04, 0x12, 0x39, 0x00, 0xfd, 0xc4, 0x5f, 0xcd, 0x8a, 0xda, 0x98, 0xbb, 0x67, 0x9c,
+	0xe4, 0xd4, 0xe8, 0xa8, 0x5f, 0x90, 0xce, 0x92, 0x7e, 0xe3, 0x0c, 0xaf, 0xf5, 0x93, 0x02, 0xac,
+	0xe8, 0x78, 0x6b, 0xb8, 0x84, 0xf5, 0x1e, 0x52, 0x12, 0x84, 0x9c, 0x0a, 0xf4, 0x73, 0x03, 0x96,
+	0xa9, 0x47, 0xf6, 0x5d, 0xea, 0xc4, 0x32, 0xd3, 0x58, 0x2b, 0xdc, 0xa8, 0xdc, 0x79, 0x7c, 0xd6,
+	0x24, 0xa6, 0xd0, 0xd5, 0x36, 0xf3, 0x54, 0x9b, 0x5e, 0xc0, 0x87, 0xf5, 0x2b, 0xda, 0x93, 0x97,
+	0x27, 0xb4, 0x78, 0x72, 0x64, 0xf4, 0x0e, 0xbc, 0x42, 0xdf, 0x0f, 0x28, 0xf7, 0x88, 0xeb, 0x0e,
+	0xb7, 0x89, 0x47, 0xba, 0x99, 0x69, 0xcd, 0xaa, 0x3d, 0xbd, 0x36, 0x1e, 0x55, 0x5f, 0xd9, 0x3c,
+	0x0d, 0x84, 0x4f, 0xb7, 0x47, 0xdf, 0x85, 0x8b, 0x0e, 0x13, 0xf9, 0xa5, 0x16, 0x14, 0xe7, 0xca,
+	0x78, 0x54, 0xbd, 0xd8, 0x9c, 0xd0, 0xe1, 0x13, 0xe8, 0xab, 0x75, 0x58, 0x99, 0xb6, 0x40, 0x74,
+	0x11, 0x0a, 0x47, 0x74, 0x18, 0x65, 0x0f, 0x2c, 0x7f, 0xa2, 0x15, 0x98, 0x1b, 0x10, 0x37, 0xd4,
+	0x69, 0x12, 0x47, 0x1f, 0x0f, 0x66, 0xef, 0x1b, 0xd6, 0x8f, 0x0d, 0xb8, 0x98, 0xdd, 0x3a, 0x95,
+	0x97, 0x7b, 0xb0, 0xac, 0x13, 0xe0, 0x36, 0x0d, 0x88, 0x43, 0x02, 0x62, 0x1a, 0xe7, 0x8a, 0xe9,
+	0x4c, 0x72, 0x4f, 0xb7, 0xb9, 0x91, 0xa7, 0xc2, 0x93, 0xdc, 0xd6, 0x9f, 0x0d, 0xa8, 0x64, 0xcb,
+	0xc2, 0x35, 0x28, 0x84, 0xcc, 0xd1, 0xd9, 0xaf, 0xa2, 0x69, 0x0a, 0x4f, 0x5b, 0x4d, 0x2c, 0xe5,
+	0x68, 0x0d, 0x8a, 0x32, 0xa7, 0xeb, 0x94, 0xbf, 0xa8, 0xf5, 0x45, 0x95, 0x91, 0x94, 0x06, 0x7d,
+	0x3b, 0x9d, 0xbf, 0xda, 0x74, 0x1e, 0xef, 0xec, 0xe5, 0xec, 0x7c, 0xb4, 0x0a, 0x4f, 0x62, 0xd1,
+	0x16, 0x14, 0x6d, 0xd2, 0x67, 0x3a, 0x8f, 0xd5, 0xce, 0x5a, 0x73, 0xbe, 0xa8, 0x45, 0xd1, 0x28,
+	0x85, 0x58, 0xb1, 0x58, 0x7f, 0x90, 0x19, 0x3e, 0xbf, 0xe2, 0xff, 0x7d, 0x85, 0xf7, 0xa0, 0xe2,
+	0x30, 0xd1, 0x77, 0xc9, 0x70, 0x5a, 0x29, 0x6b, 0xa6, 0x2a, 0x9c, 0xc5, 0xa1, 0xef, 0x64, 0x0a,
+	0x6e, 0x51, 0xd9, 0xbc, 0x36, 0xa5, 0xe0, 0x2e, 0x3f, 0xf6, 0x45, 0xc0, 0xbc, 0xee, 0x94, 0x9a,
+	0x7b, 0x13, 0x16, 0xfc, 0xf7, 0x3c, 0xca, 0x5b, 0x4d, 0x95, 0x91, 0xcb, 0xf5, 0x65, 0x6d, 0xbf,
+	0xb0, 0x1b, 0x89, 0x71, 0xac, 0x97, 0xe5, 0x59, 0xfd, 0x94, 0x05, 0xc8, 0x9c, 0xcf, 0x97, 0xe7,
+	0xdd, 0x58, 0x81, 0x53, 0x8c, 0x5c, 0x13, 0xe9, 0xb3, 0x4d, 0xcf, 0xe9, 0xfb, 0xcc, 0x0b, 0xcc,
+	0x85, 0xfc, 0x9a, 0x36, 0xda, 0xad, 0x58, 0x85, 0xb3, 0x38, 0xf4, 0x3a, 0x94, 0x6c, 0x52, 0x0f,
+	0x3d, 0xc7, 0xa5, 0x66, 0x49, 0xd9, 0x5c, 0x8c, 0xd7, 0xd4, 0xd8, 0x88, 0xe4, 0x38, 0x41, 0xc8,
+	0x59, 0xf5, 0xa2, 0x73, 0x6e, 0x35, 0xcd, 0x72, 0x7e, 0x56, 0xdb, 0xb1, 0x02, 0xa7, 0x18, 0x74,
+	0x1f, 0x16, 0x0f, 0xc3, 0xfd, 0xf8, 0x80, 0x9b, 0x26, 0x28, 0x9b, 0x15, 0x6d, 0xb3, 0xf8, 0x38,
+	0xa3, 0xc3, 0x39, 0x24, 0x6a, 0xc3, 0x8a, 0xed, 0xfa, 0xa1, 0xd3, 0xa1, 0x7c, 0xc0, 0x6c, 0xba,
+	0x11, 0x06, 0x87, 0xdb, 0xbe, 0x43, 0x55, 0x52, 0x2d, 0xd7, 0x5f, 0xd5, 0x0c, 0x2b, 0x8d, 0x29,
+	0x18, 0x3c, 0xd5, 0x12, 0xad, 0x43, 0xb1, 0x27, 0x19, 0x16, 0x15, 0xc3, 0x17, 0x63, 0xbf, 0x90,
+	0xba, 0xe3, 0xb4, 0x83, 0x51, 0x04, 0x0a, 0x28, 0x8b, 0xb2, 0xcb, 0x6c, 0xea, 0x09, 0x6a, 0x2e,
+	0x9d, 0x2b, 0x80, 0xb7, 0x22, 0xb4, 0x72, 0x64, 0x55, 0x94, 0xb5, 0x00, 0xc7, 0x3c, 0xd6, 0xbf,
+	0x0b, 0x50, 0x6e, 0xf8, 0x9e, 0xc3, 0x54, 0x21, 0xbd, 0x0d, 0xc5, 0x40, 0x9e, 0x6f, 0xe4, 0x4c,
+	0xd7, 0xe2, 0x19, 0xc9, 0xf3, 0x3c, 0x1e, 0x55, 0x97, 0x12, 0xa0, 0x3a, 0x6b, 0x05, 0x45, 0x3f,
+	0x84, 0x79, 0x11, 0x90, 0x20, 0x14, 0xda, 0x83, 0x1e, 0x6a, 0xa3, 0xf9, 0x8e, 0x92, 0x1e, 0x8f,
+	0xaa, 0xe7, 0x6a, 0x30, 0x6b, 0x09, 0x77, 0x64, 0x87, 0x35, 0x2b, 0x7a, 0x03, 0x90, 0xbf, 0x2f,
+	0x28, 0x1f, 0x50, 0xe7, 0x51, 0xd4, 0x83, 0xca, 0xfe, 0x41, 0x46, 0x48, 0xa1, 0x7e, 0x55, 0x8f,
+	0x85, 0x76, 0x4f, 0x20, 0xf0, 0x14, 0x2b, 0xb4, 0x01, 0x25, 0x41, 0x07, 0x94, 0xb3, 0x60, 0xa8,
+	0x5d, 0xf8, 0xcb, 0xb1, 0x6f, 0x75, 0xb4, 0xfc, 0x78, 0x54, 0xbd, 0x94, 0x4e, 0x45, 0x0b, 0x71,
+	0x62, 0x86, 0x06, 0x80, 0x5c, 0x22, 0x82, 0x3d, 0x4e, 0x3c, 0x11, 0x6d, 0x05, 0xeb, 0x51, 0x73,
+	0x21, 0x3e, 0x8d, 0xf3, 0x74, 0x1c, 0xd2, 0x22, 0x9d, 0xfa, 0xd6, 0x09, 0x36, 0x3c, 0x65, 0x04,
+	0x74, 0x1d, 0xe6, 0x39, 0x25, 0xc2, 0xf7, 0x74, 0x50, 0x5c, 0x88, 0xb7, 0x19, 0x2b, 0x29, 0xd6,
+	0x5a, 0x19, 0xd1, 0x3d, 0x2a, 0x04, 0xe9, 0x52, 0xb3, 0x9c, 0x8f, 0xe8, 0xed, 0x48, 0x8c, 0x63,
+	0xbd, 0xf5, 0x0f, 0x03, 0x96, 0x1f, 0x53, 0xe2, 0x06, 0x87, 0x8d, 0x43, 0x6a, 0x1f, 0xa9, 0x5e,
+	0xf5, 0x17, 0x06, 0x5c, 0xe1, 0x94, 0x38, 0xbe, 0xe7, 0x0e, 0x27, 0x74, 0xba, 0x66, 0x7c, 0xfd,
+	0x0c, 0x97, 0xc3, 0xd3, 0xad, 0xeb, 0x55, 0x3d, 0x8f, 0x2b, 0xa7, 0x00, 0xf0, 0x69, 0xe3, 0xa2,
+	0x47, 0x70, 0x49, 0xd7, 0xca, 0x37, 0x39, 0x0b, 0xa8, 0x52, 0xa8, 0x5c, 0x5a, 0xaa, 0xbf, 0xa2,
+	0x49, 0x2f, 0x35, 0x27, 0x01, 0xf8, 0xa4, 0x8d, 0xf5, 0x2f, 0x03, 0xca, 0xad, 0x1e, 0xe9, 0xaa,
+	0x78, 0x90, 0x6d, 0x39, 0x93, 0x1f, 0x93, 0x6d, 0xb9, 0x42, 0xe0, 0x48, 0x87, 0xf6, 0xa0, 0xe4,
+	0x32, 0x8f, 0x92, 0xae, 0xee, 0x10, 0x2a, 0x77, 0xae, 0x9f, 0x19, 0x72, 0x0a, 0x9e, 0x66, 0x2d,
+	0x2d, 0x10, 0x38, 0x61, 0x92, 0x05, 0xb9, 0x1f, 0xba, 0x6e, 0x83, 0x53, 0x87, 0x7a, 0x01, 0x23,
+	0xae, 0x30, 0x0b, 0xe7, 0x2a, 0x4e, 0xed, 0xbc, 0x55, 0x54, 0x00, 0x27, 0x84, 0x78, 0x92, 0xdb,
+	0xfa, 0xb5, 0x01, 0x95, 0x4c, 0x26, 0x40, 0x4f, 0x54, 0xb5, 0x09, 0x38, 0xdb, 0x0f, 0x03, 0x3f,
+	0xbe, 0xaa, 0xdd, 0xcc, 0x54, 0x9b, 0x58, 0x25, 0xaf, 0x3b, 0xda, 0x30, 0x23, 0xc5, 0x59, 0x6b,
+	0x99, 0xaf, 0x69, 0x9c, 0xe3, 0x67, 0xf3, 0xf9, 0x3a, 0x49, 0xf0, 0x09, 0x42, 0x6e, 0xba, 0xcf,
+	0xbb, 0xad, 0xa6, 0x59, 0xc8, 0x6f, 0xfa, 0xae, 0x14, 0xe2, 0x48, 0x67, 0xfd, 0xcc, 0x80, 0x05,
+	0xbd, 0x6b, 0x68, 0x07, 0xe6, 0xec, 0x43, 0xc2, 0x3c, 0xdd, 0x36, 0xde, 0x3c, 0x63, 0x83, 0xa2,
+	0x4b, 0x91, 0xca, 0x77, 0x09, 0x77, 0x43, 0xda, 0xe3, 0x88, 0x06, 0xd5, 0x00, 0x6c, 0xdf, 0x0b,
+	0x88, 0x8c, 0xcd, 0xb8, 0xe9, 0x53, 0xad, 0x6d, 0x23, 0x91, 0xe2, 0x0c, 0xc2, 0xfa, 0x95, 0x01,
+	0x25, 0x4d, 0xda, 0x94, 0xb3, 0xef, 0x72, 0x3f, 0xec, 0x4f, 0xba, 0xcc, 0x23, 0x29, 0xc4, 0x91,
+	0x4e, 0x56, 0xfb, 0x23, 0xe6, 0x39, 0x93, 0xd5, 0xfe, 0x09, 0xf3, 0x1c, 0xac, 0x34, 0xf9, 0x9b,
+	0x6e, 0xe1, 0x1c, 0x37, 0xdd, 0xb8, 0x81, 0x28, 0x9e, 0xd6, 0x40, 0x58, 0xbf, 0x31, 0x00, 0xd2,
+	0xb5, 0xa3, 0x37, 0xa1, 0xc4, 0xa9, 0xf0, 0x43, 0x6e, 0x53, 0x1d, 0xb6, 0x37, 0xcf, 0x0c, 0xdb,
+	0x08, 0xde, 0x6a, 0xa6, 0xe7, 0x17, 0xcb, 0x70, 0x42, 0x86, 0xb6, 0xa1, 0xc0, 0x93, 0x0b, 0x6a,
+	0xed, 0x5c, 0x87, 0x91, 0xde, 0x50, 0x93, 0xce, 0x48, 0xde, 0x4f, 0x25, 0x8f, 0xe5, 0xc0, 0xf2,
+	0x04, 0x28, 0xbf, 0x39, 0xc6, 0x67, 0xd8, 0x9c, 0x53, 0xbb, 0x2b, 0xeb, 0xef, 0x06, 0x4c, 0x06,
+	0xc9, 0x67, 0x1f, 0xe6, 0x0d, 0x40, 0x42, 0xd7, 0x6f, 0xdb, 0xf6, 0x43, 0x2f, 0xd8, 0x49, 0x07,
+	0x4d, 0x92, 0x79, 0xe7, 0x04, 0x02, 0x4f, 0xb1, 0x42, 0x3f, 0x88, 0x2f, 0xe4, 0x98, 0x1e, 0x44,
+	0xbd, 0x6c, 0xe5, 0xce, 0x8d, 0x69, 0xb7, 0xfd, 0xa9, 0x17, 0xfd, 0x89, 0xab, 0xbb, 0xe4, 0xc0,
+	0x19, 0x3e, 0xeb, 0x85, 0x01, 0xa7, 0x25, 0x59, 0xf4, 0x0d, 0x58, 0xea, 0x53, 0xce, 0x7c, 0xa7,
+	0x43, 0x6d, 0xdf, 0x73, 0xa2, 0x37, 0x89, 0xb9, 0xfa, 0xa5, 0xf1, 0xa8, 0xba, 0xd4, 0xce, 0x2a,
+	0x70, 0x1e, 0x27, 0x2f, 0xa1, 0x01, 0xeb, 0x51, 0x3f, 0x0c, 0x62, 0xcb, 0x59, 0x65, 0xa9, 0x2e,
+	0xa1, 0x7b, 0x39, 0x0d, 0x9e, 0x40, 0xca, 0xab, 0xd1, 0x01, 0x61, 0x6e, 0xc8, 0xe9, 0xde, 0x21,
+	0xa7, 0xe2, 0xd0, 0x77, 0x1d, 0xe5, 0xf6, 0x73, 0xd1, 0xd5, 0xe8, 0xe1, 0x84, 0x0e, 0x9f, 0x40,
+	0x5b, 0x7f, 0x32, 0x00, 0x52, 0x0f, 0x3d, 0x5f, 0x1c, 0xde, 0x84, 0x85, 0x01, 0xe5, 0x42, 0x76,
+	0x0b, 0xb3, 0xf9, 0x4a, 0xf8, 0xfd, 0x48, 0x8c, 0x63, 0x7d, 0xe2, 0x42, 0x85, 0x53, 0x1b, 0xf4,
+	0x38, 0xa8, 0x8b, 0xa7, 0x06, 0xf5, 0x5d, 0x98, 0x13, 0xb6, 0xdf, 0xa7, 0xba, 0x0d, 0x5a, 0x8d,
+	0xe7, 0xd4, 0xb1, 0xfd, 0xa8, 0x79, 0x8a, 0xe7, 0xaf, 0x04, 0x38, 0x02, 0x5b, 0x7f, 0x34, 0xa0,
+	0xbc, 0xb7, 0xd5, 0x69, 0xf8, 0xde, 0x01, 0xeb, 0xe6, 0x1f, 0x81, 0x8c, 0xcf, 0xf7, 0x11, 0xe8,
+	0x10, 0x16, 0xed, 0xf4, 0x62, 0x1f, 0x57, 0xb3, 0xda, 0xf9, 0xdf, 0x02, 0x54, 0x15, 0x4f, 0x1a,
+	0xe5, 0x8c, 0x42, 0xe0, 0x1c, 0xb3, 0xf5, 0x25, 0x28, 0x4b, 0x87, 0xd8, 0x3d, 0x68, 0x92, 0xe1,
+	0x83, 0x95, 0x5f, 0x7e, 0x5c, 0x9d, 0xf9, 0xe9, 0xb3, 0xea, 0xcc, 0x47, 0xcf, 0xaa, 0x33, 0x1f,
+	0x3f, 0xab, 0xce, 0x7c, 0xf8, 0x97, 0xb5, 0x19, 0xeb, 0x5d, 0x58, 0x52, 0x2d, 0x64, 0x12, 0xf5,
+	0xaf, 0x43, 0x89, 0xf4, 0xd9, 0xa3, 0xcc, 0xa1, 0x26, 0x59, 0x68, 0xa3, 0xdd, 0x8a, 0xce, 0x35,
+	0x41, 0x9c, 0x9d, 0x62, 0xad, 0xdf, 0x19, 0xb0, 0xa2, 0x76, 0x69, 0x32, 0xbd, 0x7c, 0xce, 0x03,
+	0xfd, 0x3f, 0x72, 0xf9, 0xef, 0x0b, 0x50, 0xc9, 0xbc, 0xa6, 0xc9, 0x98, 0xf5, 0x79, 0x97, 0x78,
+	0xec, 0x03, 0xd5, 0xc5, 0x46, 0x2f, 0x28, 0xe5, 0x28, 0x66, 0x77, 0xb3, 0x0a, 0x9c, 0xc7, 0xa1,
+	0xaf, 0x42, 0x59, 0xe5, 0x1c, 0xce, 0x92, 0xf7, 0x0d, 0xe5, 0x1f, 0x8d, 0x58, 0x88, 0x53, 0x3d,
+	0x6a, 0xc1, 0xe5, 0xac, 0x35, 0x71, 0x9f, 0x7a, 0x2c, 0x88, 0x2f, 0xda, 0x57, 0xc6, 0xa3, 0xea,
+	0xe5, 0xdd, 0x93, 0x6a, 0x3c, 0xcd, 0x46, 0xd6, 0x58, 0x57, 0x3a, 0x27, 0x0b, 0xe4, 0xc0, 0xc5,
+	0xb4, 0xc6, 0x6e, 0x25, 0x52, 0x9c, 0x41, 0xc8, 0x79, 0xaa, 0x1b, 0xa9, 0x67, 0x53, 0x79, 0x8b,
+	0x48, 0xe6, 0xd9, 0x8e, 0x85, 0x38, 0xd5, 0xcb, 0xc7, 0x00, 0x11, 0x70, 0x4a, 0x83, 0xf4, 0x39,
+	0x6c, 0x3e, 0x7d, 0x0c, 0xe8, 0xe4, 0x55, 0x78, 0x12, 0x2b, 0x5f, 0xe7, 0xfa, 0xbe, 0x08, 0x88,
+	0xdb, 0xf0, 0x9d, 0xe4, 0x29, 0x4f, 0xbd, 0xce, 0xb5, 0x53, 0x31, 0xce, 0x62, 0xe4, 0x95, 0x51,
+	0x50, 0xce, 0x88, 0xbb, 0x13, 0xf6, 0xf6, 0x29, 0xd7, 0x0d, 0x78, 0x12, 0x09, 0x9d, 0x8c, 0x0e,
+	0xe7, 0x90, 0xf5, 0xc6, 0xf3, 0x97, 0xab, 0x33, 0x2f, 0x5e, 0xae, 0xce, 0x7c, 0xf2, 0x72, 0x75,
+	0xe6, 0xc3, 0xf1, 0xaa, 0xf1, 0x7c, 0xbc, 0x6a, 0xbc, 0x18, 0xaf, 0x1a, 0x9f, 0x8c, 0x57, 0x8d,
+	0xbf, 0x8e, 0x57, 0x8d, 0x8f, 0xfe, 0xb6, 0x3a, 0xf3, 0xf6, 0xb5, 0x4f, 0xfd, 0x87, 0xe0, 0x3f,
+	0x03, 0x00, 0x83, 0x5d, 0xa6, 0x72, 0x41, 0x18, 0x00, 0x00,
 }
 
 func (m *CAPIClusterInfo) Marshal() (dAtA []byte, err error) {
@@ -1191,6 +1225,18 @@ func (m *ClusterMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.License != nil {
+		{
+			size, err := m.License.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x6a
+	}
 	i -= len(m.Mode)
 	copy(dAtA[i:], m.Mode)
 	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Mode)))
@@ -1410,6 +1456,44 @@ func (m *ImageInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *LicenseInfo) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LicenseInfo) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LicenseInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	i -= len(m.OrgID)
+	copy(dAtA[i:], m.OrgID)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.OrgID)))
+	i--
+	dAtA[i] = 0x1a
+	i -= len(m.Endpoint)
+	copy(dAtA[i:], m.Endpoint)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Endpoint)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Distributor)
+	copy(dAtA[i:], m.Distributor)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Distributor)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
 func (m *Lineage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2111,6 +2195,10 @@ func (m *ClusterMetadata) Size() (n int) {
 	n += 1 + l + sovGenerated(uint64(l))
 	l = len(m.Mode)
 	n += 1 + l + sovGenerated(uint64(l))
+	if m.License != nil {
+		l = m.License.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
 	return n
 }
 
@@ -2169,6 +2257,21 @@ func (m *ImageInfo) Size() (n int) {
 	return n
 }
 
+func (m *LicenseInfo) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Distributor)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Endpoint)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.OrgID)
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
 func (m *Lineage) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2501,6 +2604,7 @@ func (this *ClusterMetadata) String() string {
 		`HubClusterID:` + fmt.Sprintf("%v", this.HubClusterID) + `,`,
 		`CloudServiceAuthMode:` + fmt.Sprintf("%v", this.CloudServiceAuthMode) + `,`,
 		`Mode:` + fmt.Sprintf("%v", this.Mode) + `,`,
+		`License:` + strings.Replace(this.License.String(), "LicenseInfo", "LicenseInfo", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -2549,6 +2653,18 @@ func (this *ImageInfo) String() string {
 	}, "")
 	return s
 }
+func (this *LicenseInfo) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&LicenseInfo{`,
+		`Distributor:` + fmt.Sprintf("%v", this.Distributor) + `,`,
+		`Endpoint:` + fmt.Sprintf("%v", this.Endpoint) + `,`,
+		`OrgID:` + fmt.Sprintf("%v", this.OrgID) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func (this *Lineage) String() string {
 	if this == nil {
 		return "nil"
@@ -4277,6 +4393,42 @@ func (m *ClusterMetadata) Unmarshal(dAtA []byte) error {
 			}
 			m.Mode = ClusterMode(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 13:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.License == nil {
+				m.License = &LicenseInfo{}
+			}
+			if err := m.License.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGenerated(dAtA[iNdEx:])
@@ -4815,6 +4967,152 @@ func (m *ImageInfo) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *LicenseInfo) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LicenseInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LicenseInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Distributor", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Distributor = LicenseDistributor(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Endpoint = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.OrgID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *Lineage) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/api/v1/generated.proto b/api/v1/generated.proto
index dc1b76e3d..c1730f3c1 100644
--- a/api/v1/generated.proto
+++ b/api/v1/generated.proto
@@ -55,7 +55,7 @@ message CertificateSpec {
 
   // IssuerRef is a reference to a Certificate Issuer.
   // +optional
-  optional k8s.io.api.core.v1.TypedLocalObjectReference issuerRef = 2;
+  optional .k8s.io.api.core.v1.TypedLocalObjectReference issuerRef = 2;
 
   // Specifies the k8s secret name that holds the certificates.
   // Default to <resource-name>-<cert-alias>-cert.
@@ -68,7 +68,7 @@ message CertificateSpec {
 
   // Certificate default Duration
   // +optional
-  optional k8s.io.apimachinery.pkg.apis.meta.v1.Duration duration = 5;
+  optional .k8s.io.apimachinery.pkg.apis.meta.v1.Duration duration = 5;
 
   // Certificate renew before expiration duration
   //
@@ -76,7 +76,7 @@ message CertificateSpec {
   //
   // +deprecated
   // +optional
-  optional k8s.io.apimachinery.pkg.apis.meta.v1.Duration renewBefore = 6;
+  optional .k8s.io.apimachinery.pkg.apis.meta.v1.Duration renewBefore = 6;
 
   // DNSNames is a list of subject alt names to be used on the Certificate.
   // +optional
@@ -147,6 +147,8 @@ message ClusterMetadata {
   optional string cloudServiceAuthMode = 11;
 
   optional string mode = 12;
+
+  optional LicenseInfo license = 13;
 }
 
 // Condition defines an observation of a object operational state.
@@ -174,7 +176,7 @@ message Condition {
   // Last time the condition transitioned from one status to another.
   // This should be when the underlying condition changed. If that is not known, then using the time when
   // the API field changed is acceptable.
-  optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 7;
+  optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 7;
 
   // The reason for the condition's last transition in CamelCase.
   // The specific API may choose whether this field is considered a guaranteed API.
@@ -206,6 +208,15 @@ message ImageInfo {
   optional PullCredentials pullCredentials = 3;
 }
 
+message LicenseInfo {
+  optional string distributor = 1;
+
+  // Endpoint is the platform-api to acquire licenses from, when Distributor is selfhosted.
+  optional string endpoint = 2;
+
+  optional string orgID = 3;
+}
+
 message Lineage {
   repeated ObjectInfo chain = 1;
 
@@ -245,7 +256,7 @@ message PullCredentials {
 
   optional string serviceAccountName = 2;
 
-  repeated k8s.io.api.core.v1.LocalObjectReference secretRefs = 3;
+  repeated .k8s.io.api.core.v1.LocalObjectReference secretRefs = 3;
 }
 
 // ReadonlyHealthCheckSpec defines attributes of the health check using only read-only checks
@@ -289,7 +300,7 @@ message ResourceID {
 message TLSConfig {
   // IssuerRef is a reference to a Certificate Issuer.
   // +optional
-  optional k8s.io.api.core.v1.TypedLocalObjectReference issuerRef = 1;
+  optional .k8s.io.api.core.v1.TypedLocalObjectReference issuerRef = 1;
 
   // Certificate provides server and/or client certificate options used by application pods.
   // These options are passed to a cert-manager Certificate object.
diff --git a/api/v1/openapi_generated.go b/api/v1/openapi_generated.go
index 26e0f9963..660923946 100644
--- a/api/v1/openapi_generated.go
+++ b/api/v1/openapi_generated.go
@@ -38,6 +38,7 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA
 		"kmodules.xyz/client-go/api/v1.Condition":               schema_kmodulesxyz_client_go_api_v1_Condition(ref),
 		"kmodules.xyz/client-go/api/v1.HealthCheckSpec":         schema_kmodulesxyz_client_go_api_v1_HealthCheckSpec(ref),
 		"kmodules.xyz/client-go/api/v1.ImageInfo":               schema_kmodulesxyz_client_go_api_v1_ImageInfo(ref),
+		"kmodules.xyz/client-go/api/v1.LicenseInfo":             schema_kmodulesxyz_client_go_api_v1_LicenseInfo(ref),
 		"kmodules.xyz/client-go/api/v1.Lineage":                 schema_kmodulesxyz_client_go_api_v1_Lineage(ref),
 		"kmodules.xyz/client-go/api/v1.ObjectID":                schema_kmodulesxyz_client_go_api_v1_ObjectID(ref),
 		"kmodules.xyz/client-go/api/v1.ObjectInfo":              schema_kmodulesxyz_client_go_api_v1_ObjectInfo(ref),
@@ -432,10 +433,17 @@ func schema_kmodulesxyz_client_go_api_v1_ClusterMetadata(ref common.ReferenceCal
 							Format: "",
 						},
 					},
+					"license": {
+						SchemaProps: spec.SchemaProps{
+							Ref: ref("kmodules.xyz/client-go/api/v1.LicenseInfo"),
+						},
+					},
 				},
 				Required: []string{"uid"},
 			},
 		},
+		Dependencies: []string{
+			"kmodules.xyz/client-go/api/v1.LicenseInfo"},
 	}
 }
 
@@ -586,6 +594,37 @@ func schema_kmodulesxyz_client_go_api_v1_ImageInfo(ref common.ReferenceCallback)
 	}
 }
 
+func schema_kmodulesxyz_client_go_api_v1_LicenseInfo(ref common.ReferenceCallback) common.OpenAPIDefinition {
+	return common.OpenAPIDefinition{
+		Schema: spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type: []string{"object"},
+				Properties: map[string]spec.Schema{
+					"distributor": {
+						SchemaProps: spec.SchemaProps{
+							Type:   []string{"string"},
+							Format: "",
+						},
+					},
+					"endpoint": {
+						SchemaProps: spec.SchemaProps{
+							Description: "Endpoint is the platform-api to acquire licenses from, when Distributor is selfhosted.",
+							Type:        []string{"string"},
+							Format:      "",
+						},
+					},
+					"orgID": {
+						SchemaProps: spec.SchemaProps{
+							Type:   []string{"string"},
+							Format: "",
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
 func schema_kmodulesxyz_client_go_api_v1_Lineage(ref common.ReferenceCallback) common.OpenAPIDefinition {
 	return common.OpenAPIDefinition{
 		Schema: spec.Schema{
diff --git a/api/v1/zz_generated.deepcopy.go b/api/v1/zz_generated.deepcopy.go
index cacb9e1ce..5e7400d0b 100644
--- a/api/v1/zz_generated.deepcopy.go
+++ b/api/v1/zz_generated.deepcopy.go
@@ -198,6 +198,11 @@ func (in *ClusterInfo) DeepCopy() *ClusterInfo {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *ClusterMetadata) DeepCopyInto(out *ClusterMetadata) {
 	*out = *in
+	if in.License != nil {
+		in, out := &in.License, &out.License
+		*out = new(LicenseInfo)
+		**out = **in
+	}
 	return
 }
 
@@ -295,6 +300,22 @@ func (in *ImageInfo) DeepCopy() *ImageInfo {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LicenseInfo) DeepCopyInto(out *LicenseInfo) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LicenseInfo.
+func (in *LicenseInfo) DeepCopy() *LicenseInfo {
+	if in == nil {
+		return nil
+	}
+	out := new(LicenseInfo)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *Lineage) DeepCopyInto(out *Lineage) {
 	*out = *in
diff --git a/cluster/lib.go b/cluster/lib.go
index 86fe1aa93..e1ceca0a9 100644
--- a/cluster/lib.go
+++ b/cluster/lib.go
@@ -109,6 +109,14 @@ func ClusterMetadataFromConfigMap(cm *core.ConfigMap, mode kmapi.ClusterMode, cl
 		CABundle:             cm.Data["ca.crt"],
 		CloudServiceAuthMode: cm.Data["cloudServiceAuthMode"],
 	}
+	li := kmapi.LicenseInfo{
+		Distributor: kmapi.LicenseDistributor(cm.Data["licenseDistributor"]),
+		Endpoint:    cm.Data["licenseEndpoint"],
+		OrgID:       cm.Data["licenseOrgID"],
+	}
+	if !li.IsEmpty() {
+		md.License = &li
+	}
 
 	data, err := json.Marshal(md)
 	if err != nil {
@@ -137,7 +145,17 @@ func UpsertClusterMetadata(kc client.Client, md *kmapi.ClusterMetadata) error {
 		},
 	}
 
-	data, err := json.Marshal(md)
+	// an all-empty License must sign as absent, so a reader that finds no license
+	// keys in the ConfigMap reconstructs the same payload the mac was taken over
+	signed := *md
+	var li kmapi.LicenseInfo
+	if signed.License.IsEmpty() {
+		signed.License = nil
+	} else {
+		li = *signed.License
+	}
+
+	data, err := json.Marshal(signed)
 	if err != nil {
 		return err
 	}
@@ -160,6 +178,9 @@ func UpsertClusterMetadata(kc client.Client, md *kmapi.ClusterMetadata) error {
 		cm.Data["apiEndpoint"] = md.APIEndpoint
 		cm.Data["ca.crt"] = md.CABundle
 		cm.Data["cloudServiceAuthMode"] = md.CloudServiceAuthMode
+		cm.Data["licenseDistributor"] = string(li.Distributor)
+		cm.Data["licenseEndpoint"] = li.Endpoint
+		cm.Data["licenseOrgID"] = li.OrgID
 
 		cm.BinaryData = map[string][]byte{
 			"mac": messageMAC,