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