github.com/cloudwan/edgelq-sdk@v1.15.4/cellular-api/client/v1/contract/contract_service.pb.descriptors.go (about)

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