github.com/cloudwan/edgelq-sdk@v1.15.4/alerting/client/v1/ts_condition_template/ts_condition_template_service.pb.descriptors.go (about)

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