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

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