github.com/cloudwan/edgelq-sdk@v1.15.4/limits/client/v1alpha2/plan/plan_service.pb.descriptors.go (about)

     1  // Code generated by protoc-gen-goten-client
     2  // API: PlanService
     3  // DO NOT EDIT!!!
     4  
     5  package plan_client
     6  
     7  import (
     8  	"google.golang.org/protobuf/proto"
     9  
    10  	gotenclient "github.com/cloudwan/goten-sdk/runtime/client"
    11  	gotenresource "github.com/cloudwan/goten-sdk/runtime/resource"
    12  )
    13  
    14  // proto imports
    15  import (
    16  	plan "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/plan"
    17  	emptypb "google.golang.org/protobuf/types/known/emptypb"
    18  )
    19  
    20  // Reference imports to suppress errors if they are not otherwise used.
    21  var (
    22  	_ = new(proto.Message)
    23  	_ = new(gotenclient.MethodDescriptor)
    24  	_ = gotenresource.WildcardId
    25  )
    26  
    27  // make sure we're using proto imports
    28  var (
    29  	_ = &plan.Plan{}
    30  	_ = &emptypb.Empty{}
    31  )
    32  
    33  var (
    34  	descriptorsInitialized  bool
    35  	planServiceDescriptor   *PlanServiceDescriptor
    36  	getPlanDescriptor       *GetPlanDescriptor
    37  	batchGetPlansDescriptor *BatchGetPlansDescriptor
    38  	listPlansDescriptor     *ListPlansDescriptor
    39  	watchPlanDescriptor     *WatchPlanDescriptor
    40  	watchPlansDescriptor    *WatchPlansDescriptor
    41  	createPlanDescriptor    *CreatePlanDescriptor
    42  	updatePlanDescriptor    *UpdatePlanDescriptor
    43  	deletePlanDescriptor    *DeletePlanDescriptor
    44  )
    45  
    46  type GetPlanDescriptor struct{}
    47  
    48  type GetPlanDescriptorClientMsgHandle struct{}
    49  
    50  type GetPlanDescriptorServerMsgHandle struct{}
    51  
    52  func (d *GetPlanDescriptor) NewEmptyClientMsg() proto.Message {
    53  	return &GetPlanRequest{}
    54  }
    55  
    56  func (d *GetPlanDescriptor) NewEmptyServerMsg() proto.Message {
    57  	return &plan.Plan{}
    58  }
    59  
    60  func (d *GetPlanDescriptor) IsUnary() bool {
    61  	return true
    62  }
    63  
    64  func (d *GetPlanDescriptor) IsClientStream() bool {
    65  	return false
    66  }
    67  
    68  func (d *GetPlanDescriptor) IsServerStream() bool {
    69  	return false
    70  }
    71  
    72  func (d *GetPlanDescriptor) IsCollection() bool {
    73  	return false
    74  }
    75  
    76  func (d *GetPlanDescriptor) IsPlural() bool {
    77  	return false
    78  }
    79  
    80  func (d *GetPlanDescriptor) HasResource() bool {
    81  	return true
    82  }
    83  
    84  func (d *GetPlanDescriptor) RequestHasResourceBody() bool {
    85  	return false
    86  }
    87  
    88  func (d *GetPlanDescriptor) GetVerb() string {
    89  	return "get"
    90  }
    91  
    92  func (d *GetPlanDescriptor) GetMethodName() string {
    93  	return "GetPlan"
    94  }
    95  
    96  func (d *GetPlanDescriptor) GetFullMethodName() string {
    97  	return "/ntt.limits.v1alpha2.PlanService/GetPlan"
    98  }
    99  
   100  func (d *GetPlanDescriptor) GetProtoPkgName() string {
   101  	return "ntt.limits.v1alpha2"
   102  }
   103  
   104  func (d *GetPlanDescriptor) GetApiName() string {
   105  	return "PlanService"
   106  }
   107  
   108  func (d *GetPlanDescriptor) GetServiceDomain() string {
   109  	return "limits.edgelq.com"
   110  }
   111  
   112  func (d *GetPlanDescriptor) GetServiceVersion() string {
   113  	return "v1alpha2"
   114  }
   115  
   116  func (d *GetPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   117  	return planServiceDescriptor
   118  }
   119  
   120  func (d *GetPlanDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   121  	return plan.GetDescriptor()
   122  }
   123  
   124  func (d *GetPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   125  	return &GetPlanDescriptorClientMsgHandle{}
   126  }
   127  
   128  func (d *GetPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   129  	return &GetPlanDescriptorServerMsgHandle{}
   130  }
   131  
   132  func (h *GetPlanDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   133  	typedMsg := msg.(*GetPlanRequest)
   134  	var asInterface interface{} = h
   135  	override, ok := asInterface.(interface {
   136  		OverrideExtractResourceName(*GetPlanRequest) *plan.Name
   137  	})
   138  	if ok {
   139  		return override.OverrideExtractResourceName(typedMsg)
   140  	}
   141  	{
   142  		if name := typedMsg.GetName(); name != nil {
   143  			return name
   144  		}
   145  	}
   146  	return (*plan.Name)(nil)
   147  }
   148  
   149  func (h *GetPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   150  	typedMsg := msg.(*GetPlanRequest)
   151  	var asInterface interface{} = h
   152  	override, ok := asInterface.(interface {
   153  		OverrideExtractResourceNames(*GetPlanRequest) []*plan.Name
   154  	})
   155  	if ok {
   156  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   157  	}
   158  	return nil
   159  }
   160  
   161  func (h *GetPlanDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   162  	return nil
   163  }
   164  
   165  func (h *GetPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   166  	typedMsg := msg.(*GetPlanRequest)
   167  	var asInterface interface{} = h
   168  	override, ok := asInterface.(interface {
   169  		OverrideExtractResourceBody(*GetPlanRequest) *plan.Plan
   170  	})
   171  	if ok {
   172  		return override.OverrideExtractResourceBody(typedMsg)
   173  	}
   174  	return nil
   175  }
   176  
   177  func (h *GetPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   178  	typedMsg := msg.(*GetPlanRequest)
   179  	var asInterface interface{} = h
   180  	override, ok := asInterface.(interface {
   181  		OverrideExtractResourceBodies(*GetPlanRequest) []*plan.Plan
   182  	})
   183  	if ok {
   184  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   185  	}
   186  	return nil
   187  }
   188  
   189  func (h *GetPlanDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   190  	typedMsg := msg.(*plan.Plan)
   191  	var asInterface interface{} = h
   192  	override, ok := asInterface.(interface {
   193  		OverrideExtractResourceName(*plan.Plan) *plan.Name
   194  	})
   195  	if ok {
   196  		return override.OverrideExtractResourceName(typedMsg)
   197  	}
   198  	{
   199  		if name := typedMsg.GetName(); name != nil {
   200  			return name
   201  		}
   202  	}
   203  	return (*plan.Name)(nil)
   204  }
   205  
   206  func (h *GetPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   207  	typedMsg := msg.(*plan.Plan)
   208  	var asInterface interface{} = h
   209  	override, ok := asInterface.(interface {
   210  		OverrideExtractResourceNames(*plan.Plan) []*plan.Name
   211  	})
   212  	if ok {
   213  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   214  	}
   215  	return nil
   216  }
   217  
   218  func (h *GetPlanDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   219  	return nil
   220  }
   221  
   222  func (h *GetPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   223  	return msg.(*plan.Plan)
   224  }
   225  
   226  func (h *GetPlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   227  	typedMsg := msg.(*plan.Plan)
   228  	var asInterface interface{} = h
   229  	override, ok := asInterface.(interface {
   230  		OverrideExtractResourceBodies(*plan.Plan) []*plan.Plan
   231  	})
   232  	if ok {
   233  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   234  	}
   235  	return nil
   236  }
   237  
   238  func GetGetPlanDescriptor() *GetPlanDescriptor {
   239  	return getPlanDescriptor
   240  }
   241  
   242  type BatchGetPlansDescriptor struct{}
   243  
   244  type BatchGetPlansDescriptorClientMsgHandle struct{}
   245  
   246  type BatchGetPlansDescriptorServerMsgHandle struct{}
   247  
   248  func (d *BatchGetPlansDescriptor) NewEmptyClientMsg() proto.Message {
   249  	return &BatchGetPlansRequest{}
   250  }
   251  
   252  func (d *BatchGetPlansDescriptor) NewEmptyServerMsg() proto.Message {
   253  	return &BatchGetPlansResponse{}
   254  }
   255  
   256  func (d *BatchGetPlansDescriptor) IsUnary() bool {
   257  	return true
   258  }
   259  
   260  func (d *BatchGetPlansDescriptor) IsClientStream() bool {
   261  	return false
   262  }
   263  
   264  func (d *BatchGetPlansDescriptor) IsServerStream() bool {
   265  	return false
   266  }
   267  
   268  func (d *BatchGetPlansDescriptor) IsCollection() bool {
   269  	return false
   270  }
   271  
   272  func (d *BatchGetPlansDescriptor) IsPlural() bool {
   273  	return true
   274  }
   275  
   276  func (d *BatchGetPlansDescriptor) HasResource() bool {
   277  	return true
   278  }
   279  
   280  func (d *BatchGetPlansDescriptor) RequestHasResourceBody() bool {
   281  	return false
   282  }
   283  
   284  func (d *BatchGetPlansDescriptor) GetVerb() string {
   285  	return "batchGet"
   286  }
   287  
   288  func (d *BatchGetPlansDescriptor) GetMethodName() string {
   289  	return "BatchGetPlans"
   290  }
   291  
   292  func (d *BatchGetPlansDescriptor) GetFullMethodName() string {
   293  	return "/ntt.limits.v1alpha2.PlanService/BatchGetPlans"
   294  }
   295  
   296  func (d *BatchGetPlansDescriptor) GetProtoPkgName() string {
   297  	return "ntt.limits.v1alpha2"
   298  }
   299  
   300  func (d *BatchGetPlansDescriptor) GetApiName() string {
   301  	return "PlanService"
   302  }
   303  
   304  func (d *BatchGetPlansDescriptor) GetServiceDomain() string {
   305  	return "limits.edgelq.com"
   306  }
   307  
   308  func (d *BatchGetPlansDescriptor) GetServiceVersion() string {
   309  	return "v1alpha2"
   310  }
   311  
   312  func (d *BatchGetPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   313  	return planServiceDescriptor
   314  }
   315  
   316  func (d *BatchGetPlansDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   317  	return plan.GetDescriptor()
   318  }
   319  
   320  func (d *BatchGetPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   321  	return &BatchGetPlansDescriptorClientMsgHandle{}
   322  }
   323  
   324  func (d *BatchGetPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   325  	return &BatchGetPlansDescriptorServerMsgHandle{}
   326  }
   327  
   328  func (h *BatchGetPlansDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   329  	typedMsg := msg.(*BatchGetPlansRequest)
   330  	var asInterface interface{} = h
   331  	override, ok := asInterface.(interface {
   332  		OverrideExtractResourceName(*BatchGetPlansRequest) *plan.Name
   333  	})
   334  	if ok {
   335  		return override.OverrideExtractResourceName(typedMsg)
   336  	}
   337  	return nil
   338  }
   339  
   340  func (h *BatchGetPlansDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   341  	typedMsg := msg.(*BatchGetPlansRequest)
   342  	var asInterface interface{} = h
   343  	override, ok := asInterface.(interface {
   344  		OverrideExtractResourceNames(*BatchGetPlansRequest) []*plan.Name
   345  	})
   346  	if ok {
   347  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   348  	}
   349  	{
   350  		if names := typedMsg.GetNames(); len(names) > 0 {
   351  			return plan.PlanNameList(names)
   352  		}
   353  	}
   354  	return (plan.PlanNameList)(nil)
   355  }
   356  
   357  func (h *BatchGetPlansDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   358  	return nil
   359  }
   360  
   361  func (h *BatchGetPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   362  	typedMsg := msg.(*BatchGetPlansRequest)
   363  	var asInterface interface{} = h
   364  	override, ok := asInterface.(interface {
   365  		OverrideExtractResourceBody(*BatchGetPlansRequest) *plan.Plan
   366  	})
   367  	if ok {
   368  		return override.OverrideExtractResourceBody(typedMsg)
   369  	}
   370  	return nil
   371  }
   372  
   373  func (h *BatchGetPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   374  	typedMsg := msg.(*BatchGetPlansRequest)
   375  	var asInterface interface{} = h
   376  	override, ok := asInterface.(interface {
   377  		OverrideExtractResourceBodies(*BatchGetPlansRequest) []*plan.Plan
   378  	})
   379  	if ok {
   380  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   381  	}
   382  	return nil
   383  }
   384  
   385  func (h *BatchGetPlansDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   386  	typedMsg := msg.(*BatchGetPlansResponse)
   387  	var asInterface interface{} = h
   388  	override, ok := asInterface.(interface {
   389  		OverrideExtractResourceName(*BatchGetPlansResponse) *plan.Name
   390  	})
   391  	if ok {
   392  		return override.OverrideExtractResourceName(typedMsg)
   393  	}
   394  	return nil
   395  }
   396  
   397  func (h *BatchGetPlansDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   398  	typedMsg := msg.(*BatchGetPlansResponse)
   399  	var asInterface interface{} = h
   400  	override, ok := asInterface.(interface {
   401  		OverrideExtractResourceNames(*BatchGetPlansResponse) []*plan.Name
   402  	})
   403  	if ok {
   404  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   405  	}
   406  	{
   407  		if resources := typedMsg.GetPlans(); len(resources) > 0 {
   408  			list := make(plan.PlanNameList, 0, len(resources))
   409  			for _, res := range resources {
   410  				list = append(list, res.GetName())
   411  			}
   412  			return list
   413  		}
   414  	}
   415  	return (plan.PlanNameList)(nil)
   416  }
   417  
   418  func (h *BatchGetPlansDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   419  	return nil
   420  }
   421  
   422  func (h *BatchGetPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   423  	typedMsg := msg.(*BatchGetPlansResponse)
   424  	var asInterface interface{} = h
   425  	override, ok := asInterface.(interface {
   426  		OverrideExtractResourceBody(*BatchGetPlansResponse) *plan.Plan
   427  	})
   428  	if ok {
   429  		return override.OverrideExtractResourceBody(typedMsg)
   430  	}
   431  	return nil
   432  }
   433  
   434  func (h *BatchGetPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   435  	typedMsg := msg.(*BatchGetPlansResponse)
   436  	var asInterface interface{} = h
   437  	override, ok := asInterface.(interface {
   438  		OverrideExtractResourceBodies(*BatchGetPlansResponse) []*plan.Plan
   439  	})
   440  	if ok {
   441  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   442  	}
   443  	{
   444  		if resources := typedMsg.GetPlans(); len(resources) > 0 {
   445  			return plan.PlanList(resources)
   446  		}
   447  	}
   448  	return (plan.PlanList)(nil)
   449  }
   450  
   451  func GetBatchGetPlansDescriptor() *BatchGetPlansDescriptor {
   452  	return batchGetPlansDescriptor
   453  }
   454  
   455  type ListPlansDescriptor struct{}
   456  
   457  type ListPlansDescriptorClientMsgHandle struct{}
   458  
   459  type ListPlansDescriptorServerMsgHandle struct{}
   460  
   461  func (d *ListPlansDescriptor) NewEmptyClientMsg() proto.Message {
   462  	return &ListPlansRequest{}
   463  }
   464  
   465  func (d *ListPlansDescriptor) NewEmptyServerMsg() proto.Message {
   466  	return &ListPlansResponse{}
   467  }
   468  
   469  func (d *ListPlansDescriptor) IsUnary() bool {
   470  	return true
   471  }
   472  
   473  func (d *ListPlansDescriptor) IsClientStream() bool {
   474  	return false
   475  }
   476  
   477  func (d *ListPlansDescriptor) IsServerStream() bool {
   478  	return false
   479  }
   480  
   481  func (d *ListPlansDescriptor) IsCollection() bool {
   482  	return true
   483  }
   484  
   485  func (d *ListPlansDescriptor) IsPlural() bool {
   486  	return true
   487  }
   488  
   489  func (d *ListPlansDescriptor) HasResource() bool {
   490  	return true
   491  }
   492  
   493  func (d *ListPlansDescriptor) RequestHasResourceBody() bool {
   494  	return false
   495  }
   496  
   497  func (d *ListPlansDescriptor) GetVerb() string {
   498  	return "list"
   499  }
   500  
   501  func (d *ListPlansDescriptor) GetMethodName() string {
   502  	return "ListPlans"
   503  }
   504  
   505  func (d *ListPlansDescriptor) GetFullMethodName() string {
   506  	return "/ntt.limits.v1alpha2.PlanService/ListPlans"
   507  }
   508  
   509  func (d *ListPlansDescriptor) GetProtoPkgName() string {
   510  	return "ntt.limits.v1alpha2"
   511  }
   512  
   513  func (d *ListPlansDescriptor) GetApiName() string {
   514  	return "PlanService"
   515  }
   516  
   517  func (d *ListPlansDescriptor) GetServiceDomain() string {
   518  	return "limits.edgelq.com"
   519  }
   520  
   521  func (d *ListPlansDescriptor) GetServiceVersion() string {
   522  	return "v1alpha2"
   523  }
   524  
   525  func (d *ListPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   526  	return planServiceDescriptor
   527  }
   528  
   529  func (d *ListPlansDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   530  	return plan.GetDescriptor()
   531  }
   532  
   533  func (d *ListPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   534  	return &ListPlansDescriptorClientMsgHandle{}
   535  }
   536  
   537  func (d *ListPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   538  	return &ListPlansDescriptorServerMsgHandle{}
   539  }
   540  
   541  func (h *ListPlansDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   542  	typedMsg := msg.(*ListPlansRequest)
   543  	var asInterface interface{} = h
   544  	override, ok := asInterface.(interface {
   545  		OverrideExtractResourceName(*ListPlansRequest) *plan.Name
   546  	})
   547  	if ok {
   548  		return override.OverrideExtractResourceName(typedMsg)
   549  	}
   550  	return nil
   551  }
   552  
   553  func (h *ListPlansDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   554  	typedMsg := msg.(*ListPlansRequest)
   555  	var asInterface interface{} = h
   556  	override, ok := asInterface.(interface {
   557  		OverrideExtractResourceNames(*ListPlansRequest) []*plan.Name
   558  	})
   559  	if ok {
   560  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   561  	}
   562  	return nil
   563  }
   564  
   565  func (h *ListPlansDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   566  	return nil
   567  }
   568  
   569  func (h *ListPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   570  	typedMsg := msg.(*ListPlansRequest)
   571  	var asInterface interface{} = h
   572  	override, ok := asInterface.(interface {
   573  		OverrideExtractResourceBody(*ListPlansRequest) *plan.Plan
   574  	})
   575  	if ok {
   576  		return override.OverrideExtractResourceBody(typedMsg)
   577  	}
   578  	return nil
   579  }
   580  
   581  func (h *ListPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   582  	typedMsg := msg.(*ListPlansRequest)
   583  	var asInterface interface{} = h
   584  	override, ok := asInterface.(interface {
   585  		OverrideExtractResourceBodies(*ListPlansRequest) []*plan.Plan
   586  	})
   587  	if ok {
   588  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   589  	}
   590  	return nil
   591  }
   592  
   593  func (h *ListPlansDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   594  	typedMsg := msg.(*ListPlansResponse)
   595  	var asInterface interface{} = h
   596  	override, ok := asInterface.(interface {
   597  		OverrideExtractResourceName(*ListPlansResponse) *plan.Name
   598  	})
   599  	if ok {
   600  		return override.OverrideExtractResourceName(typedMsg)
   601  	}
   602  	return nil
   603  }
   604  
   605  func (h *ListPlansDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   606  	typedMsg := msg.(*ListPlansResponse)
   607  	var asInterface interface{} = h
   608  	override, ok := asInterface.(interface {
   609  		OverrideExtractResourceNames(*ListPlansResponse) []*plan.Name
   610  	})
   611  	if ok {
   612  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   613  	}
   614  	{
   615  		if resources := typedMsg.GetPlans(); len(resources) > 0 {
   616  			list := make(plan.PlanNameList, 0, len(resources))
   617  			for _, res := range resources {
   618  				list = append(list, res.GetName())
   619  			}
   620  			return list
   621  		}
   622  	}
   623  	return (plan.PlanNameList)(nil)
   624  }
   625  
   626  func (h *ListPlansDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   627  	return nil
   628  }
   629  
   630  func (h *ListPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   631  	typedMsg := msg.(*ListPlansResponse)
   632  	var asInterface interface{} = h
   633  	override, ok := asInterface.(interface {
   634  		OverrideExtractResourceBody(*ListPlansResponse) *plan.Plan
   635  	})
   636  	if ok {
   637  		return override.OverrideExtractResourceBody(typedMsg)
   638  	}
   639  	return nil
   640  }
   641  
   642  func (h *ListPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   643  	typedMsg := msg.(*ListPlansResponse)
   644  	var asInterface interface{} = h
   645  	override, ok := asInterface.(interface {
   646  		OverrideExtractResourceBodies(*ListPlansResponse) []*plan.Plan
   647  	})
   648  	if ok {
   649  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   650  	}
   651  	{
   652  		if resources := typedMsg.GetPlans(); len(resources) > 0 {
   653  			return plan.PlanList(resources)
   654  		}
   655  	}
   656  	return (plan.PlanList)(nil)
   657  }
   658  
   659  func GetListPlansDescriptor() *ListPlansDescriptor {
   660  	return listPlansDescriptor
   661  }
   662  
   663  type WatchPlanDescriptor struct{}
   664  
   665  type WatchPlanDescriptorClientMsgHandle struct{}
   666  
   667  type WatchPlanDescriptorServerMsgHandle struct{}
   668  
   669  func (d *WatchPlanDescriptor) NewEmptyClientMsg() proto.Message {
   670  	return &WatchPlanRequest{}
   671  }
   672  
   673  func (d *WatchPlanDescriptor) NewEmptyServerMsg() proto.Message {
   674  	return &WatchPlanResponse{}
   675  }
   676  
   677  func (d *WatchPlanDescriptor) IsUnary() bool {
   678  	return false
   679  }
   680  
   681  func (d *WatchPlanDescriptor) IsClientStream() bool {
   682  	return false
   683  }
   684  
   685  func (d *WatchPlanDescriptor) IsServerStream() bool {
   686  	return true
   687  }
   688  
   689  func (d *WatchPlanDescriptor) IsCollection() bool {
   690  	return false
   691  }
   692  
   693  func (d *WatchPlanDescriptor) IsPlural() bool {
   694  	return false
   695  }
   696  
   697  func (d *WatchPlanDescriptor) HasResource() bool {
   698  	return true
   699  }
   700  
   701  func (d *WatchPlanDescriptor) RequestHasResourceBody() bool {
   702  	return false
   703  }
   704  
   705  func (d *WatchPlanDescriptor) GetVerb() string {
   706  	return "watch"
   707  }
   708  
   709  func (d *WatchPlanDescriptor) GetMethodName() string {
   710  	return "WatchPlan"
   711  }
   712  
   713  func (d *WatchPlanDescriptor) GetFullMethodName() string {
   714  	return "/ntt.limits.v1alpha2.PlanService/WatchPlan"
   715  }
   716  
   717  func (d *WatchPlanDescriptor) GetProtoPkgName() string {
   718  	return "ntt.limits.v1alpha2"
   719  }
   720  
   721  func (d *WatchPlanDescriptor) GetApiName() string {
   722  	return "PlanService"
   723  }
   724  
   725  func (d *WatchPlanDescriptor) GetServiceDomain() string {
   726  	return "limits.edgelq.com"
   727  }
   728  
   729  func (d *WatchPlanDescriptor) GetServiceVersion() string {
   730  	return "v1alpha2"
   731  }
   732  
   733  func (d *WatchPlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   734  	return planServiceDescriptor
   735  }
   736  
   737  func (d *WatchPlanDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   738  	return plan.GetDescriptor()
   739  }
   740  
   741  func (d *WatchPlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   742  	return &WatchPlanDescriptorClientMsgHandle{}
   743  }
   744  
   745  func (d *WatchPlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   746  	return &WatchPlanDescriptorServerMsgHandle{}
   747  }
   748  
   749  func (h *WatchPlanDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   750  	typedMsg := msg.(*WatchPlanRequest)
   751  	var asInterface interface{} = h
   752  	override, ok := asInterface.(interface {
   753  		OverrideExtractResourceName(*WatchPlanRequest) *plan.Name
   754  	})
   755  	if ok {
   756  		return override.OverrideExtractResourceName(typedMsg)
   757  	}
   758  	{
   759  		if name := typedMsg.GetName(); name != nil {
   760  			return name
   761  		}
   762  	}
   763  	return (*plan.Name)(nil)
   764  }
   765  
   766  func (h *WatchPlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   767  	typedMsg := msg.(*WatchPlanRequest)
   768  	var asInterface interface{} = h
   769  	override, ok := asInterface.(interface {
   770  		OverrideExtractResourceNames(*WatchPlanRequest) []*plan.Name
   771  	})
   772  	if ok {
   773  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   774  	}
   775  	return nil
   776  }
   777  
   778  func (h *WatchPlanDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   779  	return nil
   780  }
   781  
   782  func (h *WatchPlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   783  	typedMsg := msg.(*WatchPlanRequest)
   784  	var asInterface interface{} = h
   785  	override, ok := asInterface.(interface {
   786  		OverrideExtractResourceBody(*WatchPlanRequest) *plan.Plan
   787  	})
   788  	if ok {
   789  		return override.OverrideExtractResourceBody(typedMsg)
   790  	}
   791  	return nil
   792  }
   793  
   794  func (h *WatchPlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   795  	typedMsg := msg.(*WatchPlanRequest)
   796  	var asInterface interface{} = h
   797  	override, ok := asInterface.(interface {
   798  		OverrideExtractResourceBodies(*WatchPlanRequest) []*plan.Plan
   799  	})
   800  	if ok {
   801  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   802  	}
   803  	return nil
   804  }
   805  
   806  func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   807  	typedMsg := msg.(*WatchPlanResponse)
   808  	var asInterface interface{} = h
   809  	override, ok := asInterface.(interface {
   810  		OverrideExtractResourceName(*WatchPlanResponse) *plan.Name
   811  	})
   812  	if ok {
   813  		return override.OverrideExtractResourceName(typedMsg)
   814  	}
   815  	{
   816  		if resChange := typedMsg.GetChange(); resChange != nil {
   817  			switch tResChange := resChange.ChangeType.(type) {
   818  			case *plan.PlanChange_Added_:
   819  				return tResChange.Added.GetPlan().GetName()
   820  			case *plan.PlanChange_Modified_:
   821  				return tResChange.Modified.GetName()
   822  			case *plan.PlanChange_Removed_:
   823  				return tResChange.Removed.GetName()
   824  			case *plan.PlanChange_Current_:
   825  				return tResChange.Current.GetPlan().GetName()
   826  			}
   827  		}
   828  	}
   829  	return (*plan.Name)(nil)
   830  }
   831  
   832  func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   833  	typedMsg := msg.(*WatchPlanResponse)
   834  	var asInterface interface{} = h
   835  	override, ok := asInterface.(interface {
   836  		OverrideExtractResourceNames(*WatchPlanResponse) []*plan.Name
   837  	})
   838  	if ok {
   839  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   840  	}
   841  	return nil
   842  }
   843  
   844  func (h *WatchPlanDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   845  	return nil
   846  }
   847  
   848  func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   849  	typedMsg := msg.(*WatchPlanResponse)
   850  	var asInterface interface{} = h
   851  	override, ok := asInterface.(interface {
   852  		OverrideExtractResourceBody(*WatchPlanResponse) *plan.Plan
   853  	})
   854  	if ok {
   855  		return override.OverrideExtractResourceBody(typedMsg)
   856  	}
   857  	{
   858  		if resChange := typedMsg.GetChange(); resChange != nil {
   859  			switch tResChange := resChange.ChangeType.(type) {
   860  			case *plan.PlanChange_Added_:
   861  				return tResChange.Added.GetPlan()
   862  			case *plan.PlanChange_Modified_:
   863  				return tResChange.Modified.GetPlan()
   864  			case *plan.PlanChange_Current_:
   865  				return tResChange.Current.GetPlan()
   866  			}
   867  		}
   868  	}
   869  	return (*plan.Plan)(nil)
   870  }
   871  
   872  func (h *WatchPlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   873  	typedMsg := msg.(*WatchPlanResponse)
   874  	var asInterface interface{} = h
   875  	override, ok := asInterface.(interface {
   876  		OverrideExtractResourceBodies(*WatchPlanResponse) []*plan.Plan
   877  	})
   878  	if ok {
   879  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
   880  	}
   881  	return nil
   882  }
   883  
   884  func GetWatchPlanDescriptor() *WatchPlanDescriptor {
   885  	return watchPlanDescriptor
   886  }
   887  
   888  type WatchPlansDescriptor struct{}
   889  
   890  type WatchPlansDescriptorClientMsgHandle struct{}
   891  
   892  type WatchPlansDescriptorServerMsgHandle struct{}
   893  
   894  func (d *WatchPlansDescriptor) NewEmptyClientMsg() proto.Message {
   895  	return &WatchPlansRequest{}
   896  }
   897  
   898  func (d *WatchPlansDescriptor) NewEmptyServerMsg() proto.Message {
   899  	return &WatchPlansResponse{}
   900  }
   901  
   902  func (d *WatchPlansDescriptor) IsUnary() bool {
   903  	return false
   904  }
   905  
   906  func (d *WatchPlansDescriptor) IsClientStream() bool {
   907  	return false
   908  }
   909  
   910  func (d *WatchPlansDescriptor) IsServerStream() bool {
   911  	return true
   912  }
   913  
   914  func (d *WatchPlansDescriptor) IsCollection() bool {
   915  	return true
   916  }
   917  
   918  func (d *WatchPlansDescriptor) IsPlural() bool {
   919  	return true
   920  }
   921  
   922  func (d *WatchPlansDescriptor) HasResource() bool {
   923  	return true
   924  }
   925  
   926  func (d *WatchPlansDescriptor) RequestHasResourceBody() bool {
   927  	return false
   928  }
   929  
   930  func (d *WatchPlansDescriptor) GetVerb() string {
   931  	return "watch"
   932  }
   933  
   934  func (d *WatchPlansDescriptor) GetMethodName() string {
   935  	return "WatchPlans"
   936  }
   937  
   938  func (d *WatchPlansDescriptor) GetFullMethodName() string {
   939  	return "/ntt.limits.v1alpha2.PlanService/WatchPlans"
   940  }
   941  
   942  func (d *WatchPlansDescriptor) GetProtoPkgName() string {
   943  	return "ntt.limits.v1alpha2"
   944  }
   945  
   946  func (d *WatchPlansDescriptor) GetApiName() string {
   947  	return "PlanService"
   948  }
   949  
   950  func (d *WatchPlansDescriptor) GetServiceDomain() string {
   951  	return "limits.edgelq.com"
   952  }
   953  
   954  func (d *WatchPlansDescriptor) GetServiceVersion() string {
   955  	return "v1alpha2"
   956  }
   957  
   958  func (d *WatchPlansDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   959  	return planServiceDescriptor
   960  }
   961  
   962  func (d *WatchPlansDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   963  	return plan.GetDescriptor()
   964  }
   965  
   966  func (d *WatchPlansDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   967  	return &WatchPlansDescriptorClientMsgHandle{}
   968  }
   969  
   970  func (d *WatchPlansDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   971  	return &WatchPlansDescriptorServerMsgHandle{}
   972  }
   973  
   974  func (h *WatchPlansDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   975  	typedMsg := msg.(*WatchPlansRequest)
   976  	var asInterface interface{} = h
   977  	override, ok := asInterface.(interface {
   978  		OverrideExtractResourceName(*WatchPlansRequest) *plan.Name
   979  	})
   980  	if ok {
   981  		return override.OverrideExtractResourceName(typedMsg)
   982  	}
   983  	return nil
   984  }
   985  
   986  func (h *WatchPlansDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   987  	typedMsg := msg.(*WatchPlansRequest)
   988  	var asInterface interface{} = h
   989  	override, ok := asInterface.(interface {
   990  		OverrideExtractResourceNames(*WatchPlansRequest) []*plan.Name
   991  	})
   992  	if ok {
   993  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
   994  	}
   995  	return nil
   996  }
   997  
   998  func (h *WatchPlansDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   999  	return nil
  1000  }
  1001  
  1002  func (h *WatchPlansDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1003  	typedMsg := msg.(*WatchPlansRequest)
  1004  	var asInterface interface{} = h
  1005  	override, ok := asInterface.(interface {
  1006  		OverrideExtractResourceBody(*WatchPlansRequest) *plan.Plan
  1007  	})
  1008  	if ok {
  1009  		return override.OverrideExtractResourceBody(typedMsg)
  1010  	}
  1011  	return nil
  1012  }
  1013  
  1014  func (h *WatchPlansDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1015  	typedMsg := msg.(*WatchPlansRequest)
  1016  	var asInterface interface{} = h
  1017  	override, ok := asInterface.(interface {
  1018  		OverrideExtractResourceBodies(*WatchPlansRequest) []*plan.Plan
  1019  	})
  1020  	if ok {
  1021  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1022  	}
  1023  	return nil
  1024  }
  1025  
  1026  func (h *WatchPlansDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1027  	typedMsg := msg.(*WatchPlansResponse)
  1028  	var asInterface interface{} = h
  1029  	override, ok := asInterface.(interface {
  1030  		OverrideExtractResourceName(*WatchPlansResponse) *plan.Name
  1031  	})
  1032  	if ok {
  1033  		return override.OverrideExtractResourceName(typedMsg)
  1034  	}
  1035  	return nil
  1036  }
  1037  
  1038  func (h *WatchPlansDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1039  	typedMsg := msg.(*WatchPlansResponse)
  1040  	var asInterface interface{} = h
  1041  	override, ok := asInterface.(interface {
  1042  		OverrideExtractResourceNames(*WatchPlansResponse) []*plan.Name
  1043  	})
  1044  	if ok {
  1045  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
  1046  	}
  1047  	{
  1048  		if resChanges := typedMsg.GetPlanChanges(); len(resChanges) > 0 {
  1049  			list := make(plan.PlanNameList, 0, len(resChanges))
  1050  			for _, resChange := range resChanges {
  1051  				switch tResChange := resChange.ChangeType.(type) {
  1052  				case *plan.PlanChange_Added_:
  1053  					list = append(list, tResChange.Added.GetPlan().GetName())
  1054  				case *plan.PlanChange_Modified_:
  1055  					list = append(list, tResChange.Modified.GetName())
  1056  				case *plan.PlanChange_Removed_:
  1057  					list = append(list, tResChange.Removed.GetName())
  1058  				case *plan.PlanChange_Current_:
  1059  					list = append(list, tResChange.Current.GetPlan().GetName())
  1060  				}
  1061  			}
  1062  			return list
  1063  		}
  1064  	}
  1065  	return (plan.PlanNameList)(nil)
  1066  }
  1067  
  1068  func (h *WatchPlansDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1069  	return nil
  1070  }
  1071  
  1072  func (h *WatchPlansDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1073  	typedMsg := msg.(*WatchPlansResponse)
  1074  	var asInterface interface{} = h
  1075  	override, ok := asInterface.(interface {
  1076  		OverrideExtractResourceBody(*WatchPlansResponse) *plan.Plan
  1077  	})
  1078  	if ok {
  1079  		return override.OverrideExtractResourceBody(typedMsg)
  1080  	}
  1081  	return nil
  1082  }
  1083  
  1084  func (h *WatchPlansDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1085  	typedMsg := msg.(*WatchPlansResponse)
  1086  	var asInterface interface{} = h
  1087  	override, ok := asInterface.(interface {
  1088  		OverrideExtractResourceBodies(*WatchPlansResponse) []*plan.Plan
  1089  	})
  1090  	if ok {
  1091  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1092  	}
  1093  	{
  1094  		if resChanges := typedMsg.GetPlanChanges(); len(resChanges) > 0 {
  1095  			list := make(plan.PlanList, 0, len(resChanges))
  1096  			for _, resChange := range resChanges {
  1097  				switch tResChange := resChange.ChangeType.(type) {
  1098  				case *plan.PlanChange_Added_:
  1099  					list = append(list, tResChange.Added.GetPlan())
  1100  				case *plan.PlanChange_Modified_:
  1101  					list = append(list, tResChange.Modified.GetPlan())
  1102  				case *plan.PlanChange_Current_:
  1103  					list = append(list, tResChange.Current.GetPlan())
  1104  				}
  1105  			}
  1106  			return list
  1107  		}
  1108  	}
  1109  	return (plan.PlanList)(nil)
  1110  }
  1111  
  1112  func GetWatchPlansDescriptor() *WatchPlansDescriptor {
  1113  	return watchPlansDescriptor
  1114  }
  1115  
  1116  type CreatePlanDescriptor struct{}
  1117  
  1118  type CreatePlanDescriptorClientMsgHandle struct{}
  1119  
  1120  type CreatePlanDescriptorServerMsgHandle struct{}
  1121  
  1122  func (d *CreatePlanDescriptor) NewEmptyClientMsg() proto.Message {
  1123  	return &CreatePlanRequest{}
  1124  }
  1125  
  1126  func (d *CreatePlanDescriptor) NewEmptyServerMsg() proto.Message {
  1127  	return &plan.Plan{}
  1128  }
  1129  
  1130  func (d *CreatePlanDescriptor) IsUnary() bool {
  1131  	return true
  1132  }
  1133  
  1134  func (d *CreatePlanDescriptor) IsClientStream() bool {
  1135  	return false
  1136  }
  1137  
  1138  func (d *CreatePlanDescriptor) IsServerStream() bool {
  1139  	return false
  1140  }
  1141  
  1142  func (d *CreatePlanDescriptor) IsCollection() bool {
  1143  	return true
  1144  }
  1145  
  1146  func (d *CreatePlanDescriptor) IsPlural() bool {
  1147  	return false
  1148  }
  1149  
  1150  func (d *CreatePlanDescriptor) HasResource() bool {
  1151  	return true
  1152  }
  1153  
  1154  func (d *CreatePlanDescriptor) RequestHasResourceBody() bool {
  1155  	return true
  1156  }
  1157  
  1158  func (d *CreatePlanDescriptor) GetVerb() string {
  1159  	return "create"
  1160  }
  1161  
  1162  func (d *CreatePlanDescriptor) GetMethodName() string {
  1163  	return "CreatePlan"
  1164  }
  1165  
  1166  func (d *CreatePlanDescriptor) GetFullMethodName() string {
  1167  	return "/ntt.limits.v1alpha2.PlanService/CreatePlan"
  1168  }
  1169  
  1170  func (d *CreatePlanDescriptor) GetProtoPkgName() string {
  1171  	return "ntt.limits.v1alpha2"
  1172  }
  1173  
  1174  func (d *CreatePlanDescriptor) GetApiName() string {
  1175  	return "PlanService"
  1176  }
  1177  
  1178  func (d *CreatePlanDescriptor) GetServiceDomain() string {
  1179  	return "limits.edgelq.com"
  1180  }
  1181  
  1182  func (d *CreatePlanDescriptor) GetServiceVersion() string {
  1183  	return "v1alpha2"
  1184  }
  1185  
  1186  func (d *CreatePlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1187  	return planServiceDescriptor
  1188  }
  1189  
  1190  func (d *CreatePlanDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1191  	return plan.GetDescriptor()
  1192  }
  1193  
  1194  func (d *CreatePlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1195  	return &CreatePlanDescriptorClientMsgHandle{}
  1196  }
  1197  
  1198  func (d *CreatePlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1199  	return &CreatePlanDescriptorServerMsgHandle{}
  1200  }
  1201  
  1202  func (h *CreatePlanDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1203  	typedMsg := msg.(*CreatePlanRequest)
  1204  	var asInterface interface{} = h
  1205  	override, ok := asInterface.(interface {
  1206  		OverrideExtractResourceName(*CreatePlanRequest) *plan.Name
  1207  	})
  1208  	if ok {
  1209  		return override.OverrideExtractResourceName(typedMsg)
  1210  	}
  1211  	{
  1212  		res := typedMsg.GetPlan()
  1213  		if name := res.GetName(); name != nil {
  1214  			return name
  1215  		}
  1216  	}
  1217  	return (*plan.Name)(nil)
  1218  }
  1219  
  1220  func (h *CreatePlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1221  	typedMsg := msg.(*CreatePlanRequest)
  1222  	var asInterface interface{} = h
  1223  	override, ok := asInterface.(interface {
  1224  		OverrideExtractResourceNames(*CreatePlanRequest) []*plan.Name
  1225  	})
  1226  	if ok {
  1227  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
  1228  	}
  1229  	return nil
  1230  }
  1231  
  1232  func (h *CreatePlanDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1233  	return nil
  1234  }
  1235  
  1236  func (h *CreatePlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1237  	typedMsg := msg.(*CreatePlanRequest)
  1238  	var asInterface interface{} = h
  1239  	override, ok := asInterface.(interface {
  1240  		OverrideExtractResourceBody(*CreatePlanRequest) *plan.Plan
  1241  	})
  1242  	if ok {
  1243  		return override.OverrideExtractResourceBody(typedMsg)
  1244  	}
  1245  	{
  1246  		return typedMsg.GetPlan()
  1247  	}
  1248  	return (*plan.Plan)(nil)
  1249  }
  1250  
  1251  func (h *CreatePlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1252  	typedMsg := msg.(*CreatePlanRequest)
  1253  	var asInterface interface{} = h
  1254  	override, ok := asInterface.(interface {
  1255  		OverrideExtractResourceBodies(*CreatePlanRequest) []*plan.Plan
  1256  	})
  1257  	if ok {
  1258  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1259  	}
  1260  	return nil
  1261  }
  1262  
  1263  func (h *CreatePlanDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1264  	typedMsg := msg.(*plan.Plan)
  1265  	var asInterface interface{} = h
  1266  	override, ok := asInterface.(interface {
  1267  		OverrideExtractResourceName(*plan.Plan) *plan.Name
  1268  	})
  1269  	if ok {
  1270  		return override.OverrideExtractResourceName(typedMsg)
  1271  	}
  1272  	{
  1273  		if name := typedMsg.GetName(); name != nil {
  1274  			return name
  1275  		}
  1276  	}
  1277  	return (*plan.Name)(nil)
  1278  }
  1279  
  1280  func (h *CreatePlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1281  	typedMsg := msg.(*plan.Plan)
  1282  	var asInterface interface{} = h
  1283  	override, ok := asInterface.(interface {
  1284  		OverrideExtractResourceNames(*plan.Plan) []*plan.Name
  1285  	})
  1286  	if ok {
  1287  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
  1288  	}
  1289  	return nil
  1290  }
  1291  
  1292  func (h *CreatePlanDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1293  	return nil
  1294  }
  1295  
  1296  func (h *CreatePlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1297  	return msg.(*plan.Plan)
  1298  }
  1299  
  1300  func (h *CreatePlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1301  	typedMsg := msg.(*plan.Plan)
  1302  	var asInterface interface{} = h
  1303  	override, ok := asInterface.(interface {
  1304  		OverrideExtractResourceBodies(*plan.Plan) []*plan.Plan
  1305  	})
  1306  	if ok {
  1307  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1308  	}
  1309  	return nil
  1310  }
  1311  
  1312  func GetCreatePlanDescriptor() *CreatePlanDescriptor {
  1313  	return createPlanDescriptor
  1314  }
  1315  
  1316  type UpdatePlanDescriptor struct{}
  1317  
  1318  type UpdatePlanDescriptorClientMsgHandle struct{}
  1319  
  1320  type UpdatePlanDescriptorServerMsgHandle struct{}
  1321  
  1322  func (d *UpdatePlanDescriptor) NewEmptyClientMsg() proto.Message {
  1323  	return &UpdatePlanRequest{}
  1324  }
  1325  
  1326  func (d *UpdatePlanDescriptor) NewEmptyServerMsg() proto.Message {
  1327  	return &plan.Plan{}
  1328  }
  1329  
  1330  func (d *UpdatePlanDescriptor) IsUnary() bool {
  1331  	return true
  1332  }
  1333  
  1334  func (d *UpdatePlanDescriptor) IsClientStream() bool {
  1335  	return false
  1336  }
  1337  
  1338  func (d *UpdatePlanDescriptor) IsServerStream() bool {
  1339  	return false
  1340  }
  1341  
  1342  func (d *UpdatePlanDescriptor) IsCollection() bool {
  1343  	return false
  1344  }
  1345  
  1346  func (d *UpdatePlanDescriptor) IsPlural() bool {
  1347  	return false
  1348  }
  1349  
  1350  func (d *UpdatePlanDescriptor) HasResource() bool {
  1351  	return true
  1352  }
  1353  
  1354  func (d *UpdatePlanDescriptor) RequestHasResourceBody() bool {
  1355  	return true
  1356  }
  1357  
  1358  func (d *UpdatePlanDescriptor) GetVerb() string {
  1359  	return "update"
  1360  }
  1361  
  1362  func (d *UpdatePlanDescriptor) GetMethodName() string {
  1363  	return "UpdatePlan"
  1364  }
  1365  
  1366  func (d *UpdatePlanDescriptor) GetFullMethodName() string {
  1367  	return "/ntt.limits.v1alpha2.PlanService/UpdatePlan"
  1368  }
  1369  
  1370  func (d *UpdatePlanDescriptor) GetProtoPkgName() string {
  1371  	return "ntt.limits.v1alpha2"
  1372  }
  1373  
  1374  func (d *UpdatePlanDescriptor) GetApiName() string {
  1375  	return "PlanService"
  1376  }
  1377  
  1378  func (d *UpdatePlanDescriptor) GetServiceDomain() string {
  1379  	return "limits.edgelq.com"
  1380  }
  1381  
  1382  func (d *UpdatePlanDescriptor) GetServiceVersion() string {
  1383  	return "v1alpha2"
  1384  }
  1385  
  1386  func (d *UpdatePlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1387  	return planServiceDescriptor
  1388  }
  1389  
  1390  func (d *UpdatePlanDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1391  	return plan.GetDescriptor()
  1392  }
  1393  
  1394  func (d *UpdatePlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1395  	return &UpdatePlanDescriptorClientMsgHandle{}
  1396  }
  1397  
  1398  func (d *UpdatePlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1399  	return &UpdatePlanDescriptorServerMsgHandle{}
  1400  }
  1401  
  1402  func (h *UpdatePlanDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1403  	typedMsg := msg.(*UpdatePlanRequest)
  1404  	var asInterface interface{} = h
  1405  	override, ok := asInterface.(interface {
  1406  		OverrideExtractResourceName(*UpdatePlanRequest) *plan.Name
  1407  	})
  1408  	if ok {
  1409  		return override.OverrideExtractResourceName(typedMsg)
  1410  	}
  1411  	{
  1412  		res := typedMsg.GetPlan()
  1413  		if name := res.GetName(); name != nil {
  1414  			return name
  1415  		}
  1416  	}
  1417  	return (*plan.Name)(nil)
  1418  }
  1419  
  1420  func (h *UpdatePlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1421  	typedMsg := msg.(*UpdatePlanRequest)
  1422  	var asInterface interface{} = h
  1423  	override, ok := asInterface.(interface {
  1424  		OverrideExtractResourceNames(*UpdatePlanRequest) []*plan.Name
  1425  	})
  1426  	if ok {
  1427  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
  1428  	}
  1429  	return nil
  1430  }
  1431  
  1432  func (h *UpdatePlanDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1433  	return nil
  1434  }
  1435  
  1436  func (h *UpdatePlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1437  	typedMsg := msg.(*UpdatePlanRequest)
  1438  	var asInterface interface{} = h
  1439  	override, ok := asInterface.(interface {
  1440  		OverrideExtractResourceBody(*UpdatePlanRequest) *plan.Plan
  1441  	})
  1442  	if ok {
  1443  		return override.OverrideExtractResourceBody(typedMsg)
  1444  	}
  1445  	{
  1446  		return typedMsg.GetPlan()
  1447  	}
  1448  	return (*plan.Plan)(nil)
  1449  }
  1450  
  1451  func (h *UpdatePlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1452  	typedMsg := msg.(*UpdatePlanRequest)
  1453  	var asInterface interface{} = h
  1454  	override, ok := asInterface.(interface {
  1455  		OverrideExtractResourceBodies(*UpdatePlanRequest) []*plan.Plan
  1456  	})
  1457  	if ok {
  1458  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1459  	}
  1460  	return nil
  1461  }
  1462  
  1463  func (h *UpdatePlanDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1464  	typedMsg := msg.(*plan.Plan)
  1465  	var asInterface interface{} = h
  1466  	override, ok := asInterface.(interface {
  1467  		OverrideExtractResourceName(*plan.Plan) *plan.Name
  1468  	})
  1469  	if ok {
  1470  		return override.OverrideExtractResourceName(typedMsg)
  1471  	}
  1472  	{
  1473  		if name := typedMsg.GetName(); name != nil {
  1474  			return name
  1475  		}
  1476  	}
  1477  	return (*plan.Name)(nil)
  1478  }
  1479  
  1480  func (h *UpdatePlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1481  	typedMsg := msg.(*plan.Plan)
  1482  	var asInterface interface{} = h
  1483  	override, ok := asInterface.(interface {
  1484  		OverrideExtractResourceNames(*plan.Plan) []*plan.Name
  1485  	})
  1486  	if ok {
  1487  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
  1488  	}
  1489  	return nil
  1490  }
  1491  
  1492  func (h *UpdatePlanDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1493  	return nil
  1494  }
  1495  
  1496  func (h *UpdatePlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1497  	return msg.(*plan.Plan)
  1498  }
  1499  
  1500  func (h *UpdatePlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1501  	typedMsg := msg.(*plan.Plan)
  1502  	var asInterface interface{} = h
  1503  	override, ok := asInterface.(interface {
  1504  		OverrideExtractResourceBodies(*plan.Plan) []*plan.Plan
  1505  	})
  1506  	if ok {
  1507  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1508  	}
  1509  	return nil
  1510  }
  1511  
  1512  func GetUpdatePlanDescriptor() *UpdatePlanDescriptor {
  1513  	return updatePlanDescriptor
  1514  }
  1515  
  1516  type DeletePlanDescriptor struct{}
  1517  
  1518  type DeletePlanDescriptorClientMsgHandle struct{}
  1519  
  1520  type DeletePlanDescriptorServerMsgHandle struct{}
  1521  
  1522  func (d *DeletePlanDescriptor) NewEmptyClientMsg() proto.Message {
  1523  	return &DeletePlanRequest{}
  1524  }
  1525  
  1526  func (d *DeletePlanDescriptor) NewEmptyServerMsg() proto.Message {
  1527  	return &emptypb.Empty{}
  1528  }
  1529  
  1530  func (d *DeletePlanDescriptor) IsUnary() bool {
  1531  	return true
  1532  }
  1533  
  1534  func (d *DeletePlanDescriptor) IsClientStream() bool {
  1535  	return false
  1536  }
  1537  
  1538  func (d *DeletePlanDescriptor) IsServerStream() bool {
  1539  	return false
  1540  }
  1541  
  1542  func (d *DeletePlanDescriptor) IsCollection() bool {
  1543  	return false
  1544  }
  1545  
  1546  func (d *DeletePlanDescriptor) IsPlural() bool {
  1547  	return false
  1548  }
  1549  
  1550  func (d *DeletePlanDescriptor) HasResource() bool {
  1551  	return true
  1552  }
  1553  
  1554  func (d *DeletePlanDescriptor) RequestHasResourceBody() bool {
  1555  	return false
  1556  }
  1557  
  1558  func (d *DeletePlanDescriptor) GetVerb() string {
  1559  	return "delete"
  1560  }
  1561  
  1562  func (d *DeletePlanDescriptor) GetMethodName() string {
  1563  	return "DeletePlan"
  1564  }
  1565  
  1566  func (d *DeletePlanDescriptor) GetFullMethodName() string {
  1567  	return "/ntt.limits.v1alpha2.PlanService/DeletePlan"
  1568  }
  1569  
  1570  func (d *DeletePlanDescriptor) GetProtoPkgName() string {
  1571  	return "ntt.limits.v1alpha2"
  1572  }
  1573  
  1574  func (d *DeletePlanDescriptor) GetApiName() string {
  1575  	return "PlanService"
  1576  }
  1577  
  1578  func (d *DeletePlanDescriptor) GetServiceDomain() string {
  1579  	return "limits.edgelq.com"
  1580  }
  1581  
  1582  func (d *DeletePlanDescriptor) GetServiceVersion() string {
  1583  	return "v1alpha2"
  1584  }
  1585  
  1586  func (d *DeletePlanDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1587  	return planServiceDescriptor
  1588  }
  1589  
  1590  func (d *DeletePlanDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1591  	return plan.GetDescriptor()
  1592  }
  1593  
  1594  func (d *DeletePlanDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1595  	return &DeletePlanDescriptorClientMsgHandle{}
  1596  }
  1597  
  1598  func (d *DeletePlanDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1599  	return &DeletePlanDescriptorServerMsgHandle{}
  1600  }
  1601  
  1602  func (h *DeletePlanDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1603  	typedMsg := msg.(*DeletePlanRequest)
  1604  	var asInterface interface{} = h
  1605  	override, ok := asInterface.(interface {
  1606  		OverrideExtractResourceName(*DeletePlanRequest) *plan.Name
  1607  	})
  1608  	if ok {
  1609  		return override.OverrideExtractResourceName(typedMsg)
  1610  	}
  1611  	{
  1612  		if name := typedMsg.GetName(); name != nil {
  1613  			return name
  1614  		}
  1615  	}
  1616  	return (*plan.Name)(nil)
  1617  }
  1618  
  1619  func (h *DeletePlanDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1620  	typedMsg := msg.(*DeletePlanRequest)
  1621  	var asInterface interface{} = h
  1622  	override, ok := asInterface.(interface {
  1623  		OverrideExtractResourceNames(*DeletePlanRequest) []*plan.Name
  1624  	})
  1625  	if ok {
  1626  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
  1627  	}
  1628  	return nil
  1629  }
  1630  
  1631  func (h *DeletePlanDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1632  	return nil
  1633  }
  1634  
  1635  func (h *DeletePlanDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1636  	typedMsg := msg.(*DeletePlanRequest)
  1637  	var asInterface interface{} = h
  1638  	override, ok := asInterface.(interface {
  1639  		OverrideExtractResourceBody(*DeletePlanRequest) *plan.Plan
  1640  	})
  1641  	if ok {
  1642  		return override.OverrideExtractResourceBody(typedMsg)
  1643  	}
  1644  	return nil
  1645  }
  1646  
  1647  func (h *DeletePlanDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1648  	typedMsg := msg.(*DeletePlanRequest)
  1649  	var asInterface interface{} = h
  1650  	override, ok := asInterface.(interface {
  1651  		OverrideExtractResourceBodies(*DeletePlanRequest) []*plan.Plan
  1652  	})
  1653  	if ok {
  1654  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1655  	}
  1656  	return nil
  1657  }
  1658  
  1659  func (h *DeletePlanDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1660  	typedMsg := msg.(*emptypb.Empty)
  1661  	var asInterface interface{} = h
  1662  	override, ok := asInterface.(interface {
  1663  		OverrideExtractResourceName(*emptypb.Empty) *plan.Name
  1664  	})
  1665  	if ok {
  1666  		return override.OverrideExtractResourceName(typedMsg)
  1667  	}
  1668  	return nil
  1669  }
  1670  
  1671  func (h *DeletePlanDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1672  	typedMsg := msg.(*emptypb.Empty)
  1673  	var asInterface interface{} = h
  1674  	override, ok := asInterface.(interface {
  1675  		OverrideExtractResourceNames(*emptypb.Empty) []*plan.Name
  1676  	})
  1677  	if ok {
  1678  		return plan.PlanNameList(override.OverrideExtractResourceNames(typedMsg))
  1679  	}
  1680  	return nil
  1681  }
  1682  
  1683  func (h *DeletePlanDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1684  	return nil
  1685  }
  1686  
  1687  func (h *DeletePlanDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1688  	typedMsg := msg.(*emptypb.Empty)
  1689  	var asInterface interface{} = h
  1690  	override, ok := asInterface.(interface {
  1691  		OverrideExtractResourceBody(*emptypb.Empty) *plan.Plan
  1692  	})
  1693  	if ok {
  1694  		return override.OverrideExtractResourceBody(typedMsg)
  1695  	}
  1696  	return nil
  1697  }
  1698  
  1699  func (h *DeletePlanDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1700  	typedMsg := msg.(*emptypb.Empty)
  1701  	var asInterface interface{} = h
  1702  	override, ok := asInterface.(interface {
  1703  		OverrideExtractResourceBodies(*emptypb.Empty) []*plan.Plan
  1704  	})
  1705  	if ok {
  1706  		return plan.PlanList(override.OverrideExtractResourceBodies(typedMsg))
  1707  	}
  1708  	return nil
  1709  }
  1710  
  1711  func GetDeletePlanDescriptor() *DeletePlanDescriptor {
  1712  	return deletePlanDescriptor
  1713  }
  1714  
  1715  type PlanServiceDescriptor struct{}
  1716  
  1717  func (d *PlanServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
  1718  	return []gotenclient.MethodDescriptor{
  1719  		getPlanDescriptor,
  1720  		batchGetPlansDescriptor,
  1721  		listPlansDescriptor,
  1722  		watchPlanDescriptor,
  1723  		watchPlansDescriptor,
  1724  		createPlanDescriptor,
  1725  		updatePlanDescriptor,
  1726  		deletePlanDescriptor,
  1727  	}
  1728  }
  1729  
  1730  func (d *PlanServiceDescriptor) GetFullAPIName() string {
  1731  	return "/ntt.limits.v1alpha2.PlanService"
  1732  }
  1733  
  1734  func (d *PlanServiceDescriptor) GetProtoPkgName() string {
  1735  	return "ntt.limits.v1alpha2"
  1736  }
  1737  
  1738  func (d *PlanServiceDescriptor) GetApiName() string {
  1739  	return "PlanService"
  1740  }
  1741  
  1742  func (d *PlanServiceDescriptor) GetServiceDomain() string {
  1743  	return "limits.edgelq.com"
  1744  }
  1745  
  1746  func (d *PlanServiceDescriptor) GetServiceVersion() string {
  1747  	return "v1alpha2"
  1748  }
  1749  
  1750  func GetPlanServiceDescriptor() *PlanServiceDescriptor {
  1751  	return planServiceDescriptor
  1752  }
  1753  
  1754  func initDescriptors() {
  1755  	planServiceDescriptor = &PlanServiceDescriptor{}
  1756  	getPlanDescriptor = &GetPlanDescriptor{}
  1757  	batchGetPlansDescriptor = &BatchGetPlansDescriptor{}
  1758  	listPlansDescriptor = &ListPlansDescriptor{}
  1759  	watchPlanDescriptor = &WatchPlanDescriptor{}
  1760  	watchPlansDescriptor = &WatchPlansDescriptor{}
  1761  	createPlanDescriptor = &CreatePlanDescriptor{}
  1762  	updatePlanDescriptor = &UpdatePlanDescriptor{}
  1763  	deletePlanDescriptor = &DeletePlanDescriptor{}
  1764  	gotenclient.GetRegistry().RegisterApiDescriptor(planServiceDescriptor)
  1765  	gotenclient.GetRegistry().RegisterMethodDescriptor(getPlanDescriptor)
  1766  	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetPlansDescriptor)
  1767  	gotenclient.GetRegistry().RegisterMethodDescriptor(listPlansDescriptor)
  1768  	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPlanDescriptor)
  1769  	gotenclient.GetRegistry().RegisterMethodDescriptor(watchPlansDescriptor)
  1770  	gotenclient.GetRegistry().RegisterMethodDescriptor(createPlanDescriptor)
  1771  	gotenclient.GetRegistry().RegisterMethodDescriptor(updatePlanDescriptor)
  1772  	gotenclient.GetRegistry().RegisterMethodDescriptor(deletePlanDescriptor)
  1773  }
  1774  
  1775  func init() {
  1776  	if !descriptorsInitialized {
  1777  		initDescriptors()
  1778  		descriptorsInitialized = true
  1779  	}
  1780  }