github.com/cloudwan/edgelq-sdk@v1.15.4/audit/client/v1alpha2/method_descriptor/method_descriptor_service.pb.descriptors.go (about)

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