github.com/cloudwan/edgelq-sdk@v1.15.4/iam/client/v1/user/user_service.pb.descriptors.go (about)

     1  // Code generated by protoc-gen-goten-client
     2  // API: UserService
     3  // DO NOT EDIT!!!
     4  
     5  package user_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  	user "github.com/cloudwan/edgelq-sdk/iam/resources/v1/user"
    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  	_ = &user.User{}
    30  	_ = &emptypb.Empty{}
    31  )
    32  
    33  var (
    34  	descriptorsInitialized              bool
    35  	userServiceDescriptor               *UserServiceDescriptor
    36  	getUserDescriptor                   *GetUserDescriptor
    37  	batchGetUsersDescriptor             *BatchGetUsersDescriptor
    38  	listUsersDescriptor                 *ListUsersDescriptor
    39  	watchUserDescriptor                 *WatchUserDescriptor
    40  	watchUsersDescriptor                *WatchUsersDescriptor
    41  	createUserDescriptor                *CreateUserDescriptor
    42  	updateUserDescriptor                *UpdateUserDescriptor
    43  	deleteUserDescriptor                *DeleteUserDescriptor
    44  	getUserByEmailDescriptor            *GetUserByEmailDescriptor
    45  	batchGetUsersByEmailDescriptor      *BatchGetUsersByEmailDescriptor
    46  	getMySettingsDescriptor             *GetMySettingsDescriptor
    47  	setMySettingsDescriptor             *SetMySettingsDescriptor
    48  	refreshUserFromIdTokenDescriptor    *RefreshUserFromIdTokenDescriptor
    49  	resendVerificationEmailDescriptor   *ResendVerificationEmailDescriptor
    50  	isUserVerifiedDescriptor            *IsUserVerifiedDescriptor
    51  	resetMFAIfRecoveryKeyUsedDescriptor *ResetMFAIfRecoveryKeyUsedDescriptor
    52  	setUsersNameInAuth0Descriptor       *SetUsersNameInAuth0Descriptor
    53  	deleteUsersByCriteriaDescriptor     *DeleteUsersByCriteriaDescriptor
    54  )
    55  
    56  type GetUserDescriptor struct{}
    57  
    58  type GetUserDescriptorClientMsgHandle struct{}
    59  
    60  type GetUserDescriptorServerMsgHandle struct{}
    61  
    62  func (d *GetUserDescriptor) NewEmptyClientMsg() proto.Message {
    63  	return &GetUserRequest{}
    64  }
    65  
    66  func (d *GetUserDescriptor) NewEmptyServerMsg() proto.Message {
    67  	return &user.User{}
    68  }
    69  
    70  func (d *GetUserDescriptor) IsUnary() bool {
    71  	return true
    72  }
    73  
    74  func (d *GetUserDescriptor) IsClientStream() bool {
    75  	return false
    76  }
    77  
    78  func (d *GetUserDescriptor) IsServerStream() bool {
    79  	return false
    80  }
    81  
    82  func (d *GetUserDescriptor) IsCollection() bool {
    83  	return false
    84  }
    85  
    86  func (d *GetUserDescriptor) IsPlural() bool {
    87  	return false
    88  }
    89  
    90  func (d *GetUserDescriptor) HasResource() bool {
    91  	return true
    92  }
    93  
    94  func (d *GetUserDescriptor) RequestHasResourceBody() bool {
    95  	return false
    96  }
    97  
    98  func (d *GetUserDescriptor) GetVerb() string {
    99  	return "get"
   100  }
   101  
   102  func (d *GetUserDescriptor) GetMethodName() string {
   103  	return "GetUser"
   104  }
   105  
   106  func (d *GetUserDescriptor) GetFullMethodName() string {
   107  	return "/ntt.iam.v1.UserService/GetUser"
   108  }
   109  
   110  func (d *GetUserDescriptor) GetProtoPkgName() string {
   111  	return "ntt.iam.v1"
   112  }
   113  
   114  func (d *GetUserDescriptor) GetApiName() string {
   115  	return "UserService"
   116  }
   117  
   118  func (d *GetUserDescriptor) GetServiceDomain() string {
   119  	return "iam.edgelq.com"
   120  }
   121  
   122  func (d *GetUserDescriptor) GetServiceVersion() string {
   123  	return "v1"
   124  }
   125  
   126  func (d *GetUserDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   127  	return userServiceDescriptor
   128  }
   129  
   130  func (d *GetUserDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   131  	return user.GetDescriptor()
   132  }
   133  
   134  func (d *GetUserDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   135  	return &GetUserDescriptorClientMsgHandle{}
   136  }
   137  
   138  func (d *GetUserDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   139  	return &GetUserDescriptorServerMsgHandle{}
   140  }
   141  
   142  func (h *GetUserDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   143  	typedMsg := msg.(*GetUserRequest)
   144  	var asInterface interface{} = h
   145  	override, ok := asInterface.(interface {
   146  		OverrideExtractResourceName(*GetUserRequest) *user.Name
   147  	})
   148  	if ok {
   149  		return override.OverrideExtractResourceName(typedMsg)
   150  	}
   151  	{
   152  		if name := typedMsg.GetName(); name != nil {
   153  			return name
   154  		}
   155  	}
   156  	return (*user.Name)(nil)
   157  }
   158  
   159  func (h *GetUserDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   160  	typedMsg := msg.(*GetUserRequest)
   161  	var asInterface interface{} = h
   162  	override, ok := asInterface.(interface {
   163  		OverrideExtractResourceNames(*GetUserRequest) []*user.Name
   164  	})
   165  	if ok {
   166  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   167  	}
   168  	return nil
   169  }
   170  
   171  func (h *GetUserDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   172  	return nil
   173  }
   174  
   175  func (h *GetUserDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   176  	typedMsg := msg.(*GetUserRequest)
   177  	var asInterface interface{} = h
   178  	override, ok := asInterface.(interface {
   179  		OverrideExtractResourceBody(*GetUserRequest) *user.User
   180  	})
   181  	if ok {
   182  		return override.OverrideExtractResourceBody(typedMsg)
   183  	}
   184  	return nil
   185  }
   186  
   187  func (h *GetUserDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   188  	typedMsg := msg.(*GetUserRequest)
   189  	var asInterface interface{} = h
   190  	override, ok := asInterface.(interface {
   191  		OverrideExtractResourceBodies(*GetUserRequest) []*user.User
   192  	})
   193  	if ok {
   194  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   195  	}
   196  	return nil
   197  }
   198  
   199  func (h *GetUserDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   200  	typedMsg := msg.(*user.User)
   201  	var asInterface interface{} = h
   202  	override, ok := asInterface.(interface {
   203  		OverrideExtractResourceName(*user.User) *user.Name
   204  	})
   205  	if ok {
   206  		return override.OverrideExtractResourceName(typedMsg)
   207  	}
   208  	{
   209  		if name := typedMsg.GetName(); name != nil {
   210  			return name
   211  		}
   212  	}
   213  	return (*user.Name)(nil)
   214  }
   215  
   216  func (h *GetUserDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   217  	typedMsg := msg.(*user.User)
   218  	var asInterface interface{} = h
   219  	override, ok := asInterface.(interface {
   220  		OverrideExtractResourceNames(*user.User) []*user.Name
   221  	})
   222  	if ok {
   223  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   224  	}
   225  	return nil
   226  }
   227  
   228  func (h *GetUserDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   229  	return nil
   230  }
   231  
   232  func (h *GetUserDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   233  	return msg.(*user.User)
   234  }
   235  
   236  func (h *GetUserDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   237  	typedMsg := msg.(*user.User)
   238  	var asInterface interface{} = h
   239  	override, ok := asInterface.(interface {
   240  		OverrideExtractResourceBodies(*user.User) []*user.User
   241  	})
   242  	if ok {
   243  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   244  	}
   245  	return nil
   246  }
   247  
   248  func GetGetUserDescriptor() *GetUserDescriptor {
   249  	return getUserDescriptor
   250  }
   251  
   252  type BatchGetUsersDescriptor struct{}
   253  
   254  type BatchGetUsersDescriptorClientMsgHandle struct{}
   255  
   256  type BatchGetUsersDescriptorServerMsgHandle struct{}
   257  
   258  func (d *BatchGetUsersDescriptor) NewEmptyClientMsg() proto.Message {
   259  	return &BatchGetUsersRequest{}
   260  }
   261  
   262  func (d *BatchGetUsersDescriptor) NewEmptyServerMsg() proto.Message {
   263  	return &BatchGetUsersResponse{}
   264  }
   265  
   266  func (d *BatchGetUsersDescriptor) IsUnary() bool {
   267  	return true
   268  }
   269  
   270  func (d *BatchGetUsersDescriptor) IsClientStream() bool {
   271  	return false
   272  }
   273  
   274  func (d *BatchGetUsersDescriptor) IsServerStream() bool {
   275  	return false
   276  }
   277  
   278  func (d *BatchGetUsersDescriptor) IsCollection() bool {
   279  	return false
   280  }
   281  
   282  func (d *BatchGetUsersDescriptor) IsPlural() bool {
   283  	return true
   284  }
   285  
   286  func (d *BatchGetUsersDescriptor) HasResource() bool {
   287  	return true
   288  }
   289  
   290  func (d *BatchGetUsersDescriptor) RequestHasResourceBody() bool {
   291  	return false
   292  }
   293  
   294  func (d *BatchGetUsersDescriptor) GetVerb() string {
   295  	return "batchGet"
   296  }
   297  
   298  func (d *BatchGetUsersDescriptor) GetMethodName() string {
   299  	return "BatchGetUsers"
   300  }
   301  
   302  func (d *BatchGetUsersDescriptor) GetFullMethodName() string {
   303  	return "/ntt.iam.v1.UserService/BatchGetUsers"
   304  }
   305  
   306  func (d *BatchGetUsersDescriptor) GetProtoPkgName() string {
   307  	return "ntt.iam.v1"
   308  }
   309  
   310  func (d *BatchGetUsersDescriptor) GetApiName() string {
   311  	return "UserService"
   312  }
   313  
   314  func (d *BatchGetUsersDescriptor) GetServiceDomain() string {
   315  	return "iam.edgelq.com"
   316  }
   317  
   318  func (d *BatchGetUsersDescriptor) GetServiceVersion() string {
   319  	return "v1"
   320  }
   321  
   322  func (d *BatchGetUsersDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   323  	return userServiceDescriptor
   324  }
   325  
   326  func (d *BatchGetUsersDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   327  	return user.GetDescriptor()
   328  }
   329  
   330  func (d *BatchGetUsersDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   331  	return &BatchGetUsersDescriptorClientMsgHandle{}
   332  }
   333  
   334  func (d *BatchGetUsersDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   335  	return &BatchGetUsersDescriptorServerMsgHandle{}
   336  }
   337  
   338  func (h *BatchGetUsersDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   339  	typedMsg := msg.(*BatchGetUsersRequest)
   340  	var asInterface interface{} = h
   341  	override, ok := asInterface.(interface {
   342  		OverrideExtractResourceName(*BatchGetUsersRequest) *user.Name
   343  	})
   344  	if ok {
   345  		return override.OverrideExtractResourceName(typedMsg)
   346  	}
   347  	return nil
   348  }
   349  
   350  func (h *BatchGetUsersDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   351  	typedMsg := msg.(*BatchGetUsersRequest)
   352  	var asInterface interface{} = h
   353  	override, ok := asInterface.(interface {
   354  		OverrideExtractResourceNames(*BatchGetUsersRequest) []*user.Name
   355  	})
   356  	if ok {
   357  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   358  	}
   359  	{
   360  		if names := typedMsg.GetNames(); len(names) > 0 {
   361  			return user.UserNameList(names)
   362  		}
   363  	}
   364  	return (user.UserNameList)(nil)
   365  }
   366  
   367  func (h *BatchGetUsersDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   368  	return nil
   369  }
   370  
   371  func (h *BatchGetUsersDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   372  	typedMsg := msg.(*BatchGetUsersRequest)
   373  	var asInterface interface{} = h
   374  	override, ok := asInterface.(interface {
   375  		OverrideExtractResourceBody(*BatchGetUsersRequest) *user.User
   376  	})
   377  	if ok {
   378  		return override.OverrideExtractResourceBody(typedMsg)
   379  	}
   380  	return nil
   381  }
   382  
   383  func (h *BatchGetUsersDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   384  	typedMsg := msg.(*BatchGetUsersRequest)
   385  	var asInterface interface{} = h
   386  	override, ok := asInterface.(interface {
   387  		OverrideExtractResourceBodies(*BatchGetUsersRequest) []*user.User
   388  	})
   389  	if ok {
   390  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   391  	}
   392  	return nil
   393  }
   394  
   395  func (h *BatchGetUsersDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   396  	typedMsg := msg.(*BatchGetUsersResponse)
   397  	var asInterface interface{} = h
   398  	override, ok := asInterface.(interface {
   399  		OverrideExtractResourceName(*BatchGetUsersResponse) *user.Name
   400  	})
   401  	if ok {
   402  		return override.OverrideExtractResourceName(typedMsg)
   403  	}
   404  	return nil
   405  }
   406  
   407  func (h *BatchGetUsersDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   408  	typedMsg := msg.(*BatchGetUsersResponse)
   409  	var asInterface interface{} = h
   410  	override, ok := asInterface.(interface {
   411  		OverrideExtractResourceNames(*BatchGetUsersResponse) []*user.Name
   412  	})
   413  	if ok {
   414  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   415  	}
   416  	{
   417  		if resources := typedMsg.GetUsers(); len(resources) > 0 {
   418  			list := make(user.UserNameList, 0, len(resources))
   419  			for _, res := range resources {
   420  				list = append(list, res.GetName())
   421  			}
   422  			return list
   423  		}
   424  	}
   425  	return (user.UserNameList)(nil)
   426  }
   427  
   428  func (h *BatchGetUsersDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   429  	return nil
   430  }
   431  
   432  func (h *BatchGetUsersDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   433  	typedMsg := msg.(*BatchGetUsersResponse)
   434  	var asInterface interface{} = h
   435  	override, ok := asInterface.(interface {
   436  		OverrideExtractResourceBody(*BatchGetUsersResponse) *user.User
   437  	})
   438  	if ok {
   439  		return override.OverrideExtractResourceBody(typedMsg)
   440  	}
   441  	return nil
   442  }
   443  
   444  func (h *BatchGetUsersDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   445  	typedMsg := msg.(*BatchGetUsersResponse)
   446  	var asInterface interface{} = h
   447  	override, ok := asInterface.(interface {
   448  		OverrideExtractResourceBodies(*BatchGetUsersResponse) []*user.User
   449  	})
   450  	if ok {
   451  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   452  	}
   453  	{
   454  		if resources := typedMsg.GetUsers(); len(resources) > 0 {
   455  			return user.UserList(resources)
   456  		}
   457  	}
   458  	return (user.UserList)(nil)
   459  }
   460  
   461  func GetBatchGetUsersDescriptor() *BatchGetUsersDescriptor {
   462  	return batchGetUsersDescriptor
   463  }
   464  
   465  type ListUsersDescriptor struct{}
   466  
   467  type ListUsersDescriptorClientMsgHandle struct{}
   468  
   469  type ListUsersDescriptorServerMsgHandle struct{}
   470  
   471  func (d *ListUsersDescriptor) NewEmptyClientMsg() proto.Message {
   472  	return &ListUsersRequest{}
   473  }
   474  
   475  func (d *ListUsersDescriptor) NewEmptyServerMsg() proto.Message {
   476  	return &ListUsersResponse{}
   477  }
   478  
   479  func (d *ListUsersDescriptor) IsUnary() bool {
   480  	return true
   481  }
   482  
   483  func (d *ListUsersDescriptor) IsClientStream() bool {
   484  	return false
   485  }
   486  
   487  func (d *ListUsersDescriptor) IsServerStream() bool {
   488  	return false
   489  }
   490  
   491  func (d *ListUsersDescriptor) IsCollection() bool {
   492  	return true
   493  }
   494  
   495  func (d *ListUsersDescriptor) IsPlural() bool {
   496  	return true
   497  }
   498  
   499  func (d *ListUsersDescriptor) HasResource() bool {
   500  	return true
   501  }
   502  
   503  func (d *ListUsersDescriptor) RequestHasResourceBody() bool {
   504  	return false
   505  }
   506  
   507  func (d *ListUsersDescriptor) GetVerb() string {
   508  	return "list"
   509  }
   510  
   511  func (d *ListUsersDescriptor) GetMethodName() string {
   512  	return "ListUsers"
   513  }
   514  
   515  func (d *ListUsersDescriptor) GetFullMethodName() string {
   516  	return "/ntt.iam.v1.UserService/ListUsers"
   517  }
   518  
   519  func (d *ListUsersDescriptor) GetProtoPkgName() string {
   520  	return "ntt.iam.v1"
   521  }
   522  
   523  func (d *ListUsersDescriptor) GetApiName() string {
   524  	return "UserService"
   525  }
   526  
   527  func (d *ListUsersDescriptor) GetServiceDomain() string {
   528  	return "iam.edgelq.com"
   529  }
   530  
   531  func (d *ListUsersDescriptor) GetServiceVersion() string {
   532  	return "v1"
   533  }
   534  
   535  func (d *ListUsersDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   536  	return userServiceDescriptor
   537  }
   538  
   539  func (d *ListUsersDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   540  	return user.GetDescriptor()
   541  }
   542  
   543  func (d *ListUsersDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   544  	return &ListUsersDescriptorClientMsgHandle{}
   545  }
   546  
   547  func (d *ListUsersDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   548  	return &ListUsersDescriptorServerMsgHandle{}
   549  }
   550  
   551  func (h *ListUsersDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   552  	typedMsg := msg.(*ListUsersRequest)
   553  	var asInterface interface{} = h
   554  	override, ok := asInterface.(interface {
   555  		OverrideExtractResourceName(*ListUsersRequest) *user.Name
   556  	})
   557  	if ok {
   558  		return override.OverrideExtractResourceName(typedMsg)
   559  	}
   560  	return nil
   561  }
   562  
   563  func (h *ListUsersDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   564  	typedMsg := msg.(*ListUsersRequest)
   565  	var asInterface interface{} = h
   566  	override, ok := asInterface.(interface {
   567  		OverrideExtractResourceNames(*ListUsersRequest) []*user.Name
   568  	})
   569  	if ok {
   570  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   571  	}
   572  	return nil
   573  }
   574  
   575  func (h *ListUsersDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   576  	return nil
   577  }
   578  
   579  func (h *ListUsersDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   580  	typedMsg := msg.(*ListUsersRequest)
   581  	var asInterface interface{} = h
   582  	override, ok := asInterface.(interface {
   583  		OverrideExtractResourceBody(*ListUsersRequest) *user.User
   584  	})
   585  	if ok {
   586  		return override.OverrideExtractResourceBody(typedMsg)
   587  	}
   588  	return nil
   589  }
   590  
   591  func (h *ListUsersDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   592  	typedMsg := msg.(*ListUsersRequest)
   593  	var asInterface interface{} = h
   594  	override, ok := asInterface.(interface {
   595  		OverrideExtractResourceBodies(*ListUsersRequest) []*user.User
   596  	})
   597  	if ok {
   598  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   599  	}
   600  	return nil
   601  }
   602  
   603  func (h *ListUsersDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   604  	typedMsg := msg.(*ListUsersResponse)
   605  	var asInterface interface{} = h
   606  	override, ok := asInterface.(interface {
   607  		OverrideExtractResourceName(*ListUsersResponse) *user.Name
   608  	})
   609  	if ok {
   610  		return override.OverrideExtractResourceName(typedMsg)
   611  	}
   612  	return nil
   613  }
   614  
   615  func (h *ListUsersDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   616  	typedMsg := msg.(*ListUsersResponse)
   617  	var asInterface interface{} = h
   618  	override, ok := asInterface.(interface {
   619  		OverrideExtractResourceNames(*ListUsersResponse) []*user.Name
   620  	})
   621  	if ok {
   622  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   623  	}
   624  	{
   625  		if resources := typedMsg.GetUsers(); len(resources) > 0 {
   626  			list := make(user.UserNameList, 0, len(resources))
   627  			for _, res := range resources {
   628  				list = append(list, res.GetName())
   629  			}
   630  			return list
   631  		}
   632  	}
   633  	return (user.UserNameList)(nil)
   634  }
   635  
   636  func (h *ListUsersDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   637  	return nil
   638  }
   639  
   640  func (h *ListUsersDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   641  	typedMsg := msg.(*ListUsersResponse)
   642  	var asInterface interface{} = h
   643  	override, ok := asInterface.(interface {
   644  		OverrideExtractResourceBody(*ListUsersResponse) *user.User
   645  	})
   646  	if ok {
   647  		return override.OverrideExtractResourceBody(typedMsg)
   648  	}
   649  	return nil
   650  }
   651  
   652  func (h *ListUsersDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   653  	typedMsg := msg.(*ListUsersResponse)
   654  	var asInterface interface{} = h
   655  	override, ok := asInterface.(interface {
   656  		OverrideExtractResourceBodies(*ListUsersResponse) []*user.User
   657  	})
   658  	if ok {
   659  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   660  	}
   661  	{
   662  		if resources := typedMsg.GetUsers(); len(resources) > 0 {
   663  			return user.UserList(resources)
   664  		}
   665  	}
   666  	return (user.UserList)(nil)
   667  }
   668  
   669  func GetListUsersDescriptor() *ListUsersDescriptor {
   670  	return listUsersDescriptor
   671  }
   672  
   673  type WatchUserDescriptor struct{}
   674  
   675  type WatchUserDescriptorClientMsgHandle struct{}
   676  
   677  type WatchUserDescriptorServerMsgHandle struct{}
   678  
   679  func (d *WatchUserDescriptor) NewEmptyClientMsg() proto.Message {
   680  	return &WatchUserRequest{}
   681  }
   682  
   683  func (d *WatchUserDescriptor) NewEmptyServerMsg() proto.Message {
   684  	return &WatchUserResponse{}
   685  }
   686  
   687  func (d *WatchUserDescriptor) IsUnary() bool {
   688  	return false
   689  }
   690  
   691  func (d *WatchUserDescriptor) IsClientStream() bool {
   692  	return false
   693  }
   694  
   695  func (d *WatchUserDescriptor) IsServerStream() bool {
   696  	return true
   697  }
   698  
   699  func (d *WatchUserDescriptor) IsCollection() bool {
   700  	return false
   701  }
   702  
   703  func (d *WatchUserDescriptor) IsPlural() bool {
   704  	return false
   705  }
   706  
   707  func (d *WatchUserDescriptor) HasResource() bool {
   708  	return true
   709  }
   710  
   711  func (d *WatchUserDescriptor) RequestHasResourceBody() bool {
   712  	return false
   713  }
   714  
   715  func (d *WatchUserDescriptor) GetVerb() string {
   716  	return "watch"
   717  }
   718  
   719  func (d *WatchUserDescriptor) GetMethodName() string {
   720  	return "WatchUser"
   721  }
   722  
   723  func (d *WatchUserDescriptor) GetFullMethodName() string {
   724  	return "/ntt.iam.v1.UserService/WatchUser"
   725  }
   726  
   727  func (d *WatchUserDescriptor) GetProtoPkgName() string {
   728  	return "ntt.iam.v1"
   729  }
   730  
   731  func (d *WatchUserDescriptor) GetApiName() string {
   732  	return "UserService"
   733  }
   734  
   735  func (d *WatchUserDescriptor) GetServiceDomain() string {
   736  	return "iam.edgelq.com"
   737  }
   738  
   739  func (d *WatchUserDescriptor) GetServiceVersion() string {
   740  	return "v1"
   741  }
   742  
   743  func (d *WatchUserDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   744  	return userServiceDescriptor
   745  }
   746  
   747  func (d *WatchUserDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   748  	return user.GetDescriptor()
   749  }
   750  
   751  func (d *WatchUserDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   752  	return &WatchUserDescriptorClientMsgHandle{}
   753  }
   754  
   755  func (d *WatchUserDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   756  	return &WatchUserDescriptorServerMsgHandle{}
   757  }
   758  
   759  func (h *WatchUserDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   760  	typedMsg := msg.(*WatchUserRequest)
   761  	var asInterface interface{} = h
   762  	override, ok := asInterface.(interface {
   763  		OverrideExtractResourceName(*WatchUserRequest) *user.Name
   764  	})
   765  	if ok {
   766  		return override.OverrideExtractResourceName(typedMsg)
   767  	}
   768  	{
   769  		if name := typedMsg.GetName(); name != nil {
   770  			return name
   771  		}
   772  	}
   773  	return (*user.Name)(nil)
   774  }
   775  
   776  func (h *WatchUserDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   777  	typedMsg := msg.(*WatchUserRequest)
   778  	var asInterface interface{} = h
   779  	override, ok := asInterface.(interface {
   780  		OverrideExtractResourceNames(*WatchUserRequest) []*user.Name
   781  	})
   782  	if ok {
   783  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   784  	}
   785  	return nil
   786  }
   787  
   788  func (h *WatchUserDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   789  	return nil
   790  }
   791  
   792  func (h *WatchUserDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   793  	typedMsg := msg.(*WatchUserRequest)
   794  	var asInterface interface{} = h
   795  	override, ok := asInterface.(interface {
   796  		OverrideExtractResourceBody(*WatchUserRequest) *user.User
   797  	})
   798  	if ok {
   799  		return override.OverrideExtractResourceBody(typedMsg)
   800  	}
   801  	return nil
   802  }
   803  
   804  func (h *WatchUserDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   805  	typedMsg := msg.(*WatchUserRequest)
   806  	var asInterface interface{} = h
   807  	override, ok := asInterface.(interface {
   808  		OverrideExtractResourceBodies(*WatchUserRequest) []*user.User
   809  	})
   810  	if ok {
   811  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   812  	}
   813  	return nil
   814  }
   815  
   816  func (h *WatchUserDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   817  	typedMsg := msg.(*WatchUserResponse)
   818  	var asInterface interface{} = h
   819  	override, ok := asInterface.(interface {
   820  		OverrideExtractResourceName(*WatchUserResponse) *user.Name
   821  	})
   822  	if ok {
   823  		return override.OverrideExtractResourceName(typedMsg)
   824  	}
   825  	{
   826  		if resChange := typedMsg.GetChange(); resChange != nil {
   827  			switch tResChange := resChange.ChangeType.(type) {
   828  			case *user.UserChange_Added_:
   829  				return tResChange.Added.GetUser().GetName()
   830  			case *user.UserChange_Modified_:
   831  				return tResChange.Modified.GetName()
   832  			case *user.UserChange_Removed_:
   833  				return tResChange.Removed.GetName()
   834  			case *user.UserChange_Current_:
   835  				return tResChange.Current.GetUser().GetName()
   836  			}
   837  		}
   838  	}
   839  	return (*user.Name)(nil)
   840  }
   841  
   842  func (h *WatchUserDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   843  	typedMsg := msg.(*WatchUserResponse)
   844  	var asInterface interface{} = h
   845  	override, ok := asInterface.(interface {
   846  		OverrideExtractResourceNames(*WatchUserResponse) []*user.Name
   847  	})
   848  	if ok {
   849  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
   850  	}
   851  	return nil
   852  }
   853  
   854  func (h *WatchUserDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
   855  	return nil
   856  }
   857  
   858  func (h *WatchUserDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
   859  	typedMsg := msg.(*WatchUserResponse)
   860  	var asInterface interface{} = h
   861  	override, ok := asInterface.(interface {
   862  		OverrideExtractResourceBody(*WatchUserResponse) *user.User
   863  	})
   864  	if ok {
   865  		return override.OverrideExtractResourceBody(typedMsg)
   866  	}
   867  	{
   868  		if resChange := typedMsg.GetChange(); resChange != nil {
   869  			switch tResChange := resChange.ChangeType.(type) {
   870  			case *user.UserChange_Added_:
   871  				return tResChange.Added.GetUser()
   872  			case *user.UserChange_Modified_:
   873  				return tResChange.Modified.GetUser()
   874  			case *user.UserChange_Current_:
   875  				return tResChange.Current.GetUser()
   876  			}
   877  		}
   878  	}
   879  	return (*user.User)(nil)
   880  }
   881  
   882  func (h *WatchUserDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
   883  	typedMsg := msg.(*WatchUserResponse)
   884  	var asInterface interface{} = h
   885  	override, ok := asInterface.(interface {
   886  		OverrideExtractResourceBodies(*WatchUserResponse) []*user.User
   887  	})
   888  	if ok {
   889  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
   890  	}
   891  	return nil
   892  }
   893  
   894  func GetWatchUserDescriptor() *WatchUserDescriptor {
   895  	return watchUserDescriptor
   896  }
   897  
   898  type WatchUsersDescriptor struct{}
   899  
   900  type WatchUsersDescriptorClientMsgHandle struct{}
   901  
   902  type WatchUsersDescriptorServerMsgHandle struct{}
   903  
   904  func (d *WatchUsersDescriptor) NewEmptyClientMsg() proto.Message {
   905  	return &WatchUsersRequest{}
   906  }
   907  
   908  func (d *WatchUsersDescriptor) NewEmptyServerMsg() proto.Message {
   909  	return &WatchUsersResponse{}
   910  }
   911  
   912  func (d *WatchUsersDescriptor) IsUnary() bool {
   913  	return false
   914  }
   915  
   916  func (d *WatchUsersDescriptor) IsClientStream() bool {
   917  	return false
   918  }
   919  
   920  func (d *WatchUsersDescriptor) IsServerStream() bool {
   921  	return true
   922  }
   923  
   924  func (d *WatchUsersDescriptor) IsCollection() bool {
   925  	return true
   926  }
   927  
   928  func (d *WatchUsersDescriptor) IsPlural() bool {
   929  	return true
   930  }
   931  
   932  func (d *WatchUsersDescriptor) HasResource() bool {
   933  	return true
   934  }
   935  
   936  func (d *WatchUsersDescriptor) RequestHasResourceBody() bool {
   937  	return false
   938  }
   939  
   940  func (d *WatchUsersDescriptor) GetVerb() string {
   941  	return "watch"
   942  }
   943  
   944  func (d *WatchUsersDescriptor) GetMethodName() string {
   945  	return "WatchUsers"
   946  }
   947  
   948  func (d *WatchUsersDescriptor) GetFullMethodName() string {
   949  	return "/ntt.iam.v1.UserService/WatchUsers"
   950  }
   951  
   952  func (d *WatchUsersDescriptor) GetProtoPkgName() string {
   953  	return "ntt.iam.v1"
   954  }
   955  
   956  func (d *WatchUsersDescriptor) GetApiName() string {
   957  	return "UserService"
   958  }
   959  
   960  func (d *WatchUsersDescriptor) GetServiceDomain() string {
   961  	return "iam.edgelq.com"
   962  }
   963  
   964  func (d *WatchUsersDescriptor) GetServiceVersion() string {
   965  	return "v1"
   966  }
   967  
   968  func (d *WatchUsersDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
   969  	return userServiceDescriptor
   970  }
   971  
   972  func (d *WatchUsersDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
   973  	return user.GetDescriptor()
   974  }
   975  
   976  func (d *WatchUsersDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
   977  	return &WatchUsersDescriptorClientMsgHandle{}
   978  }
   979  
   980  func (d *WatchUsersDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
   981  	return &WatchUsersDescriptorServerMsgHandle{}
   982  }
   983  
   984  func (h *WatchUsersDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
   985  	typedMsg := msg.(*WatchUsersRequest)
   986  	var asInterface interface{} = h
   987  	override, ok := asInterface.(interface {
   988  		OverrideExtractResourceName(*WatchUsersRequest) *user.Name
   989  	})
   990  	if ok {
   991  		return override.OverrideExtractResourceName(typedMsg)
   992  	}
   993  	return nil
   994  }
   995  
   996  func (h *WatchUsersDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
   997  	typedMsg := msg.(*WatchUsersRequest)
   998  	var asInterface interface{} = h
   999  	override, ok := asInterface.(interface {
  1000  		OverrideExtractResourceNames(*WatchUsersRequest) []*user.Name
  1001  	})
  1002  	if ok {
  1003  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1004  	}
  1005  	return nil
  1006  }
  1007  
  1008  func (h *WatchUsersDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1009  	return nil
  1010  }
  1011  
  1012  func (h *WatchUsersDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1013  	typedMsg := msg.(*WatchUsersRequest)
  1014  	var asInterface interface{} = h
  1015  	override, ok := asInterface.(interface {
  1016  		OverrideExtractResourceBody(*WatchUsersRequest) *user.User
  1017  	})
  1018  	if ok {
  1019  		return override.OverrideExtractResourceBody(typedMsg)
  1020  	}
  1021  	return nil
  1022  }
  1023  
  1024  func (h *WatchUsersDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1025  	typedMsg := msg.(*WatchUsersRequest)
  1026  	var asInterface interface{} = h
  1027  	override, ok := asInterface.(interface {
  1028  		OverrideExtractResourceBodies(*WatchUsersRequest) []*user.User
  1029  	})
  1030  	if ok {
  1031  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1032  	}
  1033  	return nil
  1034  }
  1035  
  1036  func (h *WatchUsersDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1037  	typedMsg := msg.(*WatchUsersResponse)
  1038  	var asInterface interface{} = h
  1039  	override, ok := asInterface.(interface {
  1040  		OverrideExtractResourceName(*WatchUsersResponse) *user.Name
  1041  	})
  1042  	if ok {
  1043  		return override.OverrideExtractResourceName(typedMsg)
  1044  	}
  1045  	return nil
  1046  }
  1047  
  1048  func (h *WatchUsersDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1049  	typedMsg := msg.(*WatchUsersResponse)
  1050  	var asInterface interface{} = h
  1051  	override, ok := asInterface.(interface {
  1052  		OverrideExtractResourceNames(*WatchUsersResponse) []*user.Name
  1053  	})
  1054  	if ok {
  1055  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1056  	}
  1057  	{
  1058  		if resChanges := typedMsg.GetUserChanges(); len(resChanges) > 0 {
  1059  			list := make(user.UserNameList, 0, len(resChanges))
  1060  			for _, resChange := range resChanges {
  1061  				switch tResChange := resChange.ChangeType.(type) {
  1062  				case *user.UserChange_Added_:
  1063  					list = append(list, tResChange.Added.GetUser().GetName())
  1064  				case *user.UserChange_Modified_:
  1065  					list = append(list, tResChange.Modified.GetName())
  1066  				case *user.UserChange_Removed_:
  1067  					list = append(list, tResChange.Removed.GetName())
  1068  				case *user.UserChange_Current_:
  1069  					list = append(list, tResChange.Current.GetUser().GetName())
  1070  				}
  1071  			}
  1072  			return list
  1073  		}
  1074  	}
  1075  	return (user.UserNameList)(nil)
  1076  }
  1077  
  1078  func (h *WatchUsersDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1079  	return nil
  1080  }
  1081  
  1082  func (h *WatchUsersDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1083  	typedMsg := msg.(*WatchUsersResponse)
  1084  	var asInterface interface{} = h
  1085  	override, ok := asInterface.(interface {
  1086  		OverrideExtractResourceBody(*WatchUsersResponse) *user.User
  1087  	})
  1088  	if ok {
  1089  		return override.OverrideExtractResourceBody(typedMsg)
  1090  	}
  1091  	return nil
  1092  }
  1093  
  1094  func (h *WatchUsersDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1095  	typedMsg := msg.(*WatchUsersResponse)
  1096  	var asInterface interface{} = h
  1097  	override, ok := asInterface.(interface {
  1098  		OverrideExtractResourceBodies(*WatchUsersResponse) []*user.User
  1099  	})
  1100  	if ok {
  1101  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1102  	}
  1103  	{
  1104  		if resChanges := typedMsg.GetUserChanges(); len(resChanges) > 0 {
  1105  			list := make(user.UserList, 0, len(resChanges))
  1106  			for _, resChange := range resChanges {
  1107  				switch tResChange := resChange.ChangeType.(type) {
  1108  				case *user.UserChange_Added_:
  1109  					list = append(list, tResChange.Added.GetUser())
  1110  				case *user.UserChange_Modified_:
  1111  					list = append(list, tResChange.Modified.GetUser())
  1112  				case *user.UserChange_Current_:
  1113  					list = append(list, tResChange.Current.GetUser())
  1114  				}
  1115  			}
  1116  			return list
  1117  		}
  1118  	}
  1119  	return (user.UserList)(nil)
  1120  }
  1121  
  1122  func GetWatchUsersDescriptor() *WatchUsersDescriptor {
  1123  	return watchUsersDescriptor
  1124  }
  1125  
  1126  type CreateUserDescriptor struct{}
  1127  
  1128  type CreateUserDescriptorClientMsgHandle struct{}
  1129  
  1130  type CreateUserDescriptorServerMsgHandle struct{}
  1131  
  1132  func (d *CreateUserDescriptor) NewEmptyClientMsg() proto.Message {
  1133  	return &CreateUserRequest{}
  1134  }
  1135  
  1136  func (d *CreateUserDescriptor) NewEmptyServerMsg() proto.Message {
  1137  	return &user.User{}
  1138  }
  1139  
  1140  func (d *CreateUserDescriptor) IsUnary() bool {
  1141  	return true
  1142  }
  1143  
  1144  func (d *CreateUserDescriptor) IsClientStream() bool {
  1145  	return false
  1146  }
  1147  
  1148  func (d *CreateUserDescriptor) IsServerStream() bool {
  1149  	return false
  1150  }
  1151  
  1152  func (d *CreateUserDescriptor) IsCollection() bool {
  1153  	return true
  1154  }
  1155  
  1156  func (d *CreateUserDescriptor) IsPlural() bool {
  1157  	return false
  1158  }
  1159  
  1160  func (d *CreateUserDescriptor) HasResource() bool {
  1161  	return true
  1162  }
  1163  
  1164  func (d *CreateUserDescriptor) RequestHasResourceBody() bool {
  1165  	return true
  1166  }
  1167  
  1168  func (d *CreateUserDescriptor) GetVerb() string {
  1169  	return "create"
  1170  }
  1171  
  1172  func (d *CreateUserDescriptor) GetMethodName() string {
  1173  	return "CreateUser"
  1174  }
  1175  
  1176  func (d *CreateUserDescriptor) GetFullMethodName() string {
  1177  	return "/ntt.iam.v1.UserService/CreateUser"
  1178  }
  1179  
  1180  func (d *CreateUserDescriptor) GetProtoPkgName() string {
  1181  	return "ntt.iam.v1"
  1182  }
  1183  
  1184  func (d *CreateUserDescriptor) GetApiName() string {
  1185  	return "UserService"
  1186  }
  1187  
  1188  func (d *CreateUserDescriptor) GetServiceDomain() string {
  1189  	return "iam.edgelq.com"
  1190  }
  1191  
  1192  func (d *CreateUserDescriptor) GetServiceVersion() string {
  1193  	return "v1"
  1194  }
  1195  
  1196  func (d *CreateUserDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1197  	return userServiceDescriptor
  1198  }
  1199  
  1200  func (d *CreateUserDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1201  	return user.GetDescriptor()
  1202  }
  1203  
  1204  func (d *CreateUserDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1205  	return &CreateUserDescriptorClientMsgHandle{}
  1206  }
  1207  
  1208  func (d *CreateUserDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1209  	return &CreateUserDescriptorServerMsgHandle{}
  1210  }
  1211  
  1212  func (h *CreateUserDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1213  	typedMsg := msg.(*CreateUserRequest)
  1214  	var asInterface interface{} = h
  1215  	override, ok := asInterface.(interface {
  1216  		OverrideExtractResourceName(*CreateUserRequest) *user.Name
  1217  	})
  1218  	if ok {
  1219  		return override.OverrideExtractResourceName(typedMsg)
  1220  	}
  1221  	{
  1222  		res := typedMsg.GetUser()
  1223  		if name := res.GetName(); name != nil {
  1224  			return name
  1225  		}
  1226  	}
  1227  	return (*user.Name)(nil)
  1228  }
  1229  
  1230  func (h *CreateUserDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1231  	typedMsg := msg.(*CreateUserRequest)
  1232  	var asInterface interface{} = h
  1233  	override, ok := asInterface.(interface {
  1234  		OverrideExtractResourceNames(*CreateUserRequest) []*user.Name
  1235  	})
  1236  	if ok {
  1237  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1238  	}
  1239  	return nil
  1240  }
  1241  
  1242  func (h *CreateUserDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1243  	return nil
  1244  }
  1245  
  1246  func (h *CreateUserDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1247  	typedMsg := msg.(*CreateUserRequest)
  1248  	var asInterface interface{} = h
  1249  	override, ok := asInterface.(interface {
  1250  		OverrideExtractResourceBody(*CreateUserRequest) *user.User
  1251  	})
  1252  	if ok {
  1253  		return override.OverrideExtractResourceBody(typedMsg)
  1254  	}
  1255  	{
  1256  		return typedMsg.GetUser()
  1257  	}
  1258  	return (*user.User)(nil)
  1259  }
  1260  
  1261  func (h *CreateUserDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1262  	typedMsg := msg.(*CreateUserRequest)
  1263  	var asInterface interface{} = h
  1264  	override, ok := asInterface.(interface {
  1265  		OverrideExtractResourceBodies(*CreateUserRequest) []*user.User
  1266  	})
  1267  	if ok {
  1268  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1269  	}
  1270  	return nil
  1271  }
  1272  
  1273  func (h *CreateUserDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1274  	typedMsg := msg.(*user.User)
  1275  	var asInterface interface{} = h
  1276  	override, ok := asInterface.(interface {
  1277  		OverrideExtractResourceName(*user.User) *user.Name
  1278  	})
  1279  	if ok {
  1280  		return override.OverrideExtractResourceName(typedMsg)
  1281  	}
  1282  	{
  1283  		if name := typedMsg.GetName(); name != nil {
  1284  			return name
  1285  		}
  1286  	}
  1287  	return (*user.Name)(nil)
  1288  }
  1289  
  1290  func (h *CreateUserDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1291  	typedMsg := msg.(*user.User)
  1292  	var asInterface interface{} = h
  1293  	override, ok := asInterface.(interface {
  1294  		OverrideExtractResourceNames(*user.User) []*user.Name
  1295  	})
  1296  	if ok {
  1297  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1298  	}
  1299  	return nil
  1300  }
  1301  
  1302  func (h *CreateUserDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1303  	return nil
  1304  }
  1305  
  1306  func (h *CreateUserDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1307  	return msg.(*user.User)
  1308  }
  1309  
  1310  func (h *CreateUserDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1311  	typedMsg := msg.(*user.User)
  1312  	var asInterface interface{} = h
  1313  	override, ok := asInterface.(interface {
  1314  		OverrideExtractResourceBodies(*user.User) []*user.User
  1315  	})
  1316  	if ok {
  1317  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1318  	}
  1319  	return nil
  1320  }
  1321  
  1322  func GetCreateUserDescriptor() *CreateUserDescriptor {
  1323  	return createUserDescriptor
  1324  }
  1325  
  1326  type UpdateUserDescriptor struct{}
  1327  
  1328  type UpdateUserDescriptorClientMsgHandle struct{}
  1329  
  1330  type UpdateUserDescriptorServerMsgHandle struct{}
  1331  
  1332  func (d *UpdateUserDescriptor) NewEmptyClientMsg() proto.Message {
  1333  	return &UpdateUserRequest{}
  1334  }
  1335  
  1336  func (d *UpdateUserDescriptor) NewEmptyServerMsg() proto.Message {
  1337  	return &user.User{}
  1338  }
  1339  
  1340  func (d *UpdateUserDescriptor) IsUnary() bool {
  1341  	return true
  1342  }
  1343  
  1344  func (d *UpdateUserDescriptor) IsClientStream() bool {
  1345  	return false
  1346  }
  1347  
  1348  func (d *UpdateUserDescriptor) IsServerStream() bool {
  1349  	return false
  1350  }
  1351  
  1352  func (d *UpdateUserDescriptor) IsCollection() bool {
  1353  	return false
  1354  }
  1355  
  1356  func (d *UpdateUserDescriptor) IsPlural() bool {
  1357  	return false
  1358  }
  1359  
  1360  func (d *UpdateUserDescriptor) HasResource() bool {
  1361  	return true
  1362  }
  1363  
  1364  func (d *UpdateUserDescriptor) RequestHasResourceBody() bool {
  1365  	return true
  1366  }
  1367  
  1368  func (d *UpdateUserDescriptor) GetVerb() string {
  1369  	return "update"
  1370  }
  1371  
  1372  func (d *UpdateUserDescriptor) GetMethodName() string {
  1373  	return "UpdateUser"
  1374  }
  1375  
  1376  func (d *UpdateUserDescriptor) GetFullMethodName() string {
  1377  	return "/ntt.iam.v1.UserService/UpdateUser"
  1378  }
  1379  
  1380  func (d *UpdateUserDescriptor) GetProtoPkgName() string {
  1381  	return "ntt.iam.v1"
  1382  }
  1383  
  1384  func (d *UpdateUserDescriptor) GetApiName() string {
  1385  	return "UserService"
  1386  }
  1387  
  1388  func (d *UpdateUserDescriptor) GetServiceDomain() string {
  1389  	return "iam.edgelq.com"
  1390  }
  1391  
  1392  func (d *UpdateUserDescriptor) GetServiceVersion() string {
  1393  	return "v1"
  1394  }
  1395  
  1396  func (d *UpdateUserDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1397  	return userServiceDescriptor
  1398  }
  1399  
  1400  func (d *UpdateUserDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1401  	return user.GetDescriptor()
  1402  }
  1403  
  1404  func (d *UpdateUserDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1405  	return &UpdateUserDescriptorClientMsgHandle{}
  1406  }
  1407  
  1408  func (d *UpdateUserDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1409  	return &UpdateUserDescriptorServerMsgHandle{}
  1410  }
  1411  
  1412  func (h *UpdateUserDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1413  	typedMsg := msg.(*UpdateUserRequest)
  1414  	var asInterface interface{} = h
  1415  	override, ok := asInterface.(interface {
  1416  		OverrideExtractResourceName(*UpdateUserRequest) *user.Name
  1417  	})
  1418  	if ok {
  1419  		return override.OverrideExtractResourceName(typedMsg)
  1420  	}
  1421  	{
  1422  		res := typedMsg.GetUser()
  1423  		if name := res.GetName(); name != nil {
  1424  			return name
  1425  		}
  1426  	}
  1427  	return (*user.Name)(nil)
  1428  }
  1429  
  1430  func (h *UpdateUserDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1431  	typedMsg := msg.(*UpdateUserRequest)
  1432  	var asInterface interface{} = h
  1433  	override, ok := asInterface.(interface {
  1434  		OverrideExtractResourceNames(*UpdateUserRequest) []*user.Name
  1435  	})
  1436  	if ok {
  1437  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1438  	}
  1439  	return nil
  1440  }
  1441  
  1442  func (h *UpdateUserDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1443  	return nil
  1444  }
  1445  
  1446  func (h *UpdateUserDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1447  	typedMsg := msg.(*UpdateUserRequest)
  1448  	var asInterface interface{} = h
  1449  	override, ok := asInterface.(interface {
  1450  		OverrideExtractResourceBody(*UpdateUserRequest) *user.User
  1451  	})
  1452  	if ok {
  1453  		return override.OverrideExtractResourceBody(typedMsg)
  1454  	}
  1455  	{
  1456  		return typedMsg.GetUser()
  1457  	}
  1458  	return (*user.User)(nil)
  1459  }
  1460  
  1461  func (h *UpdateUserDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1462  	typedMsg := msg.(*UpdateUserRequest)
  1463  	var asInterface interface{} = h
  1464  	override, ok := asInterface.(interface {
  1465  		OverrideExtractResourceBodies(*UpdateUserRequest) []*user.User
  1466  	})
  1467  	if ok {
  1468  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1469  	}
  1470  	return nil
  1471  }
  1472  
  1473  func (h *UpdateUserDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1474  	typedMsg := msg.(*user.User)
  1475  	var asInterface interface{} = h
  1476  	override, ok := asInterface.(interface {
  1477  		OverrideExtractResourceName(*user.User) *user.Name
  1478  	})
  1479  	if ok {
  1480  		return override.OverrideExtractResourceName(typedMsg)
  1481  	}
  1482  	{
  1483  		if name := typedMsg.GetName(); name != nil {
  1484  			return name
  1485  		}
  1486  	}
  1487  	return (*user.Name)(nil)
  1488  }
  1489  
  1490  func (h *UpdateUserDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1491  	typedMsg := msg.(*user.User)
  1492  	var asInterface interface{} = h
  1493  	override, ok := asInterface.(interface {
  1494  		OverrideExtractResourceNames(*user.User) []*user.Name
  1495  	})
  1496  	if ok {
  1497  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1498  	}
  1499  	return nil
  1500  }
  1501  
  1502  func (h *UpdateUserDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1503  	return nil
  1504  }
  1505  
  1506  func (h *UpdateUserDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1507  	return msg.(*user.User)
  1508  }
  1509  
  1510  func (h *UpdateUserDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1511  	typedMsg := msg.(*user.User)
  1512  	var asInterface interface{} = h
  1513  	override, ok := asInterface.(interface {
  1514  		OverrideExtractResourceBodies(*user.User) []*user.User
  1515  	})
  1516  	if ok {
  1517  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1518  	}
  1519  	return nil
  1520  }
  1521  
  1522  func GetUpdateUserDescriptor() *UpdateUserDescriptor {
  1523  	return updateUserDescriptor
  1524  }
  1525  
  1526  type DeleteUserDescriptor struct{}
  1527  
  1528  type DeleteUserDescriptorClientMsgHandle struct{}
  1529  
  1530  type DeleteUserDescriptorServerMsgHandle struct{}
  1531  
  1532  func (d *DeleteUserDescriptor) NewEmptyClientMsg() proto.Message {
  1533  	return &DeleteUserRequest{}
  1534  }
  1535  
  1536  func (d *DeleteUserDescriptor) NewEmptyServerMsg() proto.Message {
  1537  	return &emptypb.Empty{}
  1538  }
  1539  
  1540  func (d *DeleteUserDescriptor) IsUnary() bool {
  1541  	return true
  1542  }
  1543  
  1544  func (d *DeleteUserDescriptor) IsClientStream() bool {
  1545  	return false
  1546  }
  1547  
  1548  func (d *DeleteUserDescriptor) IsServerStream() bool {
  1549  	return false
  1550  }
  1551  
  1552  func (d *DeleteUserDescriptor) IsCollection() bool {
  1553  	return false
  1554  }
  1555  
  1556  func (d *DeleteUserDescriptor) IsPlural() bool {
  1557  	return false
  1558  }
  1559  
  1560  func (d *DeleteUserDescriptor) HasResource() bool {
  1561  	return true
  1562  }
  1563  
  1564  func (d *DeleteUserDescriptor) RequestHasResourceBody() bool {
  1565  	return false
  1566  }
  1567  
  1568  func (d *DeleteUserDescriptor) GetVerb() string {
  1569  	return "delete"
  1570  }
  1571  
  1572  func (d *DeleteUserDescriptor) GetMethodName() string {
  1573  	return "DeleteUser"
  1574  }
  1575  
  1576  func (d *DeleteUserDescriptor) GetFullMethodName() string {
  1577  	return "/ntt.iam.v1.UserService/DeleteUser"
  1578  }
  1579  
  1580  func (d *DeleteUserDescriptor) GetProtoPkgName() string {
  1581  	return "ntt.iam.v1"
  1582  }
  1583  
  1584  func (d *DeleteUserDescriptor) GetApiName() string {
  1585  	return "UserService"
  1586  }
  1587  
  1588  func (d *DeleteUserDescriptor) GetServiceDomain() string {
  1589  	return "iam.edgelq.com"
  1590  }
  1591  
  1592  func (d *DeleteUserDescriptor) GetServiceVersion() string {
  1593  	return "v1"
  1594  }
  1595  
  1596  func (d *DeleteUserDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1597  	return userServiceDescriptor
  1598  }
  1599  
  1600  func (d *DeleteUserDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1601  	return user.GetDescriptor()
  1602  }
  1603  
  1604  func (d *DeleteUserDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1605  	return &DeleteUserDescriptorClientMsgHandle{}
  1606  }
  1607  
  1608  func (d *DeleteUserDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1609  	return &DeleteUserDescriptorServerMsgHandle{}
  1610  }
  1611  
  1612  func (h *DeleteUserDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1613  	typedMsg := msg.(*DeleteUserRequest)
  1614  	var asInterface interface{} = h
  1615  	override, ok := asInterface.(interface {
  1616  		OverrideExtractResourceName(*DeleteUserRequest) *user.Name
  1617  	})
  1618  	if ok {
  1619  		return override.OverrideExtractResourceName(typedMsg)
  1620  	}
  1621  	{
  1622  		if name := typedMsg.GetName(); name != nil {
  1623  			return name
  1624  		}
  1625  	}
  1626  	return (*user.Name)(nil)
  1627  }
  1628  
  1629  func (h *DeleteUserDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1630  	typedMsg := msg.(*DeleteUserRequest)
  1631  	var asInterface interface{} = h
  1632  	override, ok := asInterface.(interface {
  1633  		OverrideExtractResourceNames(*DeleteUserRequest) []*user.Name
  1634  	})
  1635  	if ok {
  1636  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1637  	}
  1638  	return nil
  1639  }
  1640  
  1641  func (h *DeleteUserDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1642  	return nil
  1643  }
  1644  
  1645  func (h *DeleteUserDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1646  	typedMsg := msg.(*DeleteUserRequest)
  1647  	var asInterface interface{} = h
  1648  	override, ok := asInterface.(interface {
  1649  		OverrideExtractResourceBody(*DeleteUserRequest) *user.User
  1650  	})
  1651  	if ok {
  1652  		return override.OverrideExtractResourceBody(typedMsg)
  1653  	}
  1654  	return nil
  1655  }
  1656  
  1657  func (h *DeleteUserDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1658  	typedMsg := msg.(*DeleteUserRequest)
  1659  	var asInterface interface{} = h
  1660  	override, ok := asInterface.(interface {
  1661  		OverrideExtractResourceBodies(*DeleteUserRequest) []*user.User
  1662  	})
  1663  	if ok {
  1664  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1665  	}
  1666  	return nil
  1667  }
  1668  
  1669  func (h *DeleteUserDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1670  	typedMsg := msg.(*emptypb.Empty)
  1671  	var asInterface interface{} = h
  1672  	override, ok := asInterface.(interface {
  1673  		OverrideExtractResourceName(*emptypb.Empty) *user.Name
  1674  	})
  1675  	if ok {
  1676  		return override.OverrideExtractResourceName(typedMsg)
  1677  	}
  1678  	return nil
  1679  }
  1680  
  1681  func (h *DeleteUserDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1682  	typedMsg := msg.(*emptypb.Empty)
  1683  	var asInterface interface{} = h
  1684  	override, ok := asInterface.(interface {
  1685  		OverrideExtractResourceNames(*emptypb.Empty) []*user.Name
  1686  	})
  1687  	if ok {
  1688  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1689  	}
  1690  	return nil
  1691  }
  1692  
  1693  func (h *DeleteUserDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1694  	return nil
  1695  }
  1696  
  1697  func (h *DeleteUserDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1698  	typedMsg := msg.(*emptypb.Empty)
  1699  	var asInterface interface{} = h
  1700  	override, ok := asInterface.(interface {
  1701  		OverrideExtractResourceBody(*emptypb.Empty) *user.User
  1702  	})
  1703  	if ok {
  1704  		return override.OverrideExtractResourceBody(typedMsg)
  1705  	}
  1706  	return nil
  1707  }
  1708  
  1709  func (h *DeleteUserDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1710  	typedMsg := msg.(*emptypb.Empty)
  1711  	var asInterface interface{} = h
  1712  	override, ok := asInterface.(interface {
  1713  		OverrideExtractResourceBodies(*emptypb.Empty) []*user.User
  1714  	})
  1715  	if ok {
  1716  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1717  	}
  1718  	return nil
  1719  }
  1720  
  1721  func GetDeleteUserDescriptor() *DeleteUserDescriptor {
  1722  	return deleteUserDescriptor
  1723  }
  1724  
  1725  type GetUserByEmailDescriptor struct{}
  1726  
  1727  type GetUserByEmailDescriptorClientMsgHandle struct{}
  1728  
  1729  type GetUserByEmailDescriptorServerMsgHandle struct{}
  1730  
  1731  func (d *GetUserByEmailDescriptor) NewEmptyClientMsg() proto.Message {
  1732  	return &GetUserByEmailRequest{}
  1733  }
  1734  
  1735  func (d *GetUserByEmailDescriptor) NewEmptyServerMsg() proto.Message {
  1736  	return &user.User{}
  1737  }
  1738  
  1739  func (d *GetUserByEmailDescriptor) IsUnary() bool {
  1740  	return true
  1741  }
  1742  
  1743  func (d *GetUserByEmailDescriptor) IsClientStream() bool {
  1744  	return false
  1745  }
  1746  
  1747  func (d *GetUserByEmailDescriptor) IsServerStream() bool {
  1748  	return false
  1749  }
  1750  
  1751  func (d *GetUserByEmailDescriptor) IsCollection() bool {
  1752  	return false
  1753  }
  1754  
  1755  func (d *GetUserByEmailDescriptor) IsPlural() bool {
  1756  	return false
  1757  }
  1758  
  1759  func (d *GetUserByEmailDescriptor) HasResource() bool {
  1760  	return true
  1761  }
  1762  
  1763  func (d *GetUserByEmailDescriptor) RequestHasResourceBody() bool {
  1764  	return false
  1765  }
  1766  
  1767  func (d *GetUserByEmailDescriptor) GetVerb() string {
  1768  	return "getByEmail"
  1769  }
  1770  
  1771  func (d *GetUserByEmailDescriptor) GetMethodName() string {
  1772  	return "GetUserByEmail"
  1773  }
  1774  
  1775  func (d *GetUserByEmailDescriptor) GetFullMethodName() string {
  1776  	return "/ntt.iam.v1.UserService/GetUserByEmail"
  1777  }
  1778  
  1779  func (d *GetUserByEmailDescriptor) GetProtoPkgName() string {
  1780  	return "ntt.iam.v1"
  1781  }
  1782  
  1783  func (d *GetUserByEmailDescriptor) GetApiName() string {
  1784  	return "UserService"
  1785  }
  1786  
  1787  func (d *GetUserByEmailDescriptor) GetServiceDomain() string {
  1788  	return "iam.edgelq.com"
  1789  }
  1790  
  1791  func (d *GetUserByEmailDescriptor) GetServiceVersion() string {
  1792  	return "v1"
  1793  }
  1794  
  1795  func (d *GetUserByEmailDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1796  	return userServiceDescriptor
  1797  }
  1798  
  1799  func (d *GetUserByEmailDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1800  	return user.GetDescriptor()
  1801  }
  1802  
  1803  func (d *GetUserByEmailDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1804  	return &GetUserByEmailDescriptorClientMsgHandle{}
  1805  }
  1806  
  1807  func (d *GetUserByEmailDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1808  	return &GetUserByEmailDescriptorServerMsgHandle{}
  1809  }
  1810  
  1811  func (h *GetUserByEmailDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1812  	typedMsg := msg.(*GetUserByEmailRequest)
  1813  	var asInterface interface{} = h
  1814  	override, ok := asInterface.(interface {
  1815  		OverrideExtractResourceName(*GetUserByEmailRequest) *user.Name
  1816  	})
  1817  	if ok {
  1818  		return override.OverrideExtractResourceName(typedMsg)
  1819  	}
  1820  	return nil
  1821  }
  1822  
  1823  func (h *GetUserByEmailDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1824  	typedMsg := msg.(*GetUserByEmailRequest)
  1825  	var asInterface interface{} = h
  1826  	override, ok := asInterface.(interface {
  1827  		OverrideExtractResourceNames(*GetUserByEmailRequest) []*user.Name
  1828  	})
  1829  	if ok {
  1830  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1831  	}
  1832  	return nil
  1833  }
  1834  
  1835  func (h *GetUserByEmailDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1836  	return nil
  1837  }
  1838  
  1839  func (h *GetUserByEmailDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1840  	typedMsg := msg.(*GetUserByEmailRequest)
  1841  	var asInterface interface{} = h
  1842  	override, ok := asInterface.(interface {
  1843  		OverrideExtractResourceBody(*GetUserByEmailRequest) *user.User
  1844  	})
  1845  	if ok {
  1846  		return override.OverrideExtractResourceBody(typedMsg)
  1847  	}
  1848  	return nil
  1849  }
  1850  
  1851  func (h *GetUserByEmailDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1852  	typedMsg := msg.(*GetUserByEmailRequest)
  1853  	var asInterface interface{} = h
  1854  	override, ok := asInterface.(interface {
  1855  		OverrideExtractResourceBodies(*GetUserByEmailRequest) []*user.User
  1856  	})
  1857  	if ok {
  1858  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1859  	}
  1860  	return nil
  1861  }
  1862  
  1863  func (h *GetUserByEmailDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1864  	typedMsg := msg.(*user.User)
  1865  	var asInterface interface{} = h
  1866  	override, ok := asInterface.(interface {
  1867  		OverrideExtractResourceName(*user.User) *user.Name
  1868  	})
  1869  	if ok {
  1870  		return override.OverrideExtractResourceName(typedMsg)
  1871  	}
  1872  	return nil
  1873  }
  1874  
  1875  func (h *GetUserByEmailDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  1876  	typedMsg := msg.(*user.User)
  1877  	var asInterface interface{} = h
  1878  	override, ok := asInterface.(interface {
  1879  		OverrideExtractResourceNames(*user.User) []*user.Name
  1880  	})
  1881  	if ok {
  1882  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  1883  	}
  1884  	return nil
  1885  }
  1886  
  1887  func (h *GetUserByEmailDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  1888  	return nil
  1889  }
  1890  
  1891  func (h *GetUserByEmailDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  1892  	return msg.(*user.User)
  1893  }
  1894  
  1895  func (h *GetUserByEmailDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  1896  	typedMsg := msg.(*user.User)
  1897  	var asInterface interface{} = h
  1898  	override, ok := asInterface.(interface {
  1899  		OverrideExtractResourceBodies(*user.User) []*user.User
  1900  	})
  1901  	if ok {
  1902  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  1903  	}
  1904  	return nil
  1905  }
  1906  
  1907  func GetGetUserByEmailDescriptor() *GetUserByEmailDescriptor {
  1908  	return getUserByEmailDescriptor
  1909  }
  1910  
  1911  type BatchGetUsersByEmailDescriptor struct{}
  1912  
  1913  type BatchGetUsersByEmailDescriptorClientMsgHandle struct{}
  1914  
  1915  type BatchGetUsersByEmailDescriptorServerMsgHandle struct{}
  1916  
  1917  func (d *BatchGetUsersByEmailDescriptor) NewEmptyClientMsg() proto.Message {
  1918  	return &BatchGetUsersByEmailRequest{}
  1919  }
  1920  
  1921  func (d *BatchGetUsersByEmailDescriptor) NewEmptyServerMsg() proto.Message {
  1922  	return &BatchGetUsersByEmailResponse{}
  1923  }
  1924  
  1925  func (d *BatchGetUsersByEmailDescriptor) IsUnary() bool {
  1926  	return true
  1927  }
  1928  
  1929  func (d *BatchGetUsersByEmailDescriptor) IsClientStream() bool {
  1930  	return false
  1931  }
  1932  
  1933  func (d *BatchGetUsersByEmailDescriptor) IsServerStream() bool {
  1934  	return false
  1935  }
  1936  
  1937  func (d *BatchGetUsersByEmailDescriptor) IsCollection() bool {
  1938  	return false
  1939  }
  1940  
  1941  func (d *BatchGetUsersByEmailDescriptor) IsPlural() bool {
  1942  	return true
  1943  }
  1944  
  1945  func (d *BatchGetUsersByEmailDescriptor) HasResource() bool {
  1946  	return true
  1947  }
  1948  
  1949  func (d *BatchGetUsersByEmailDescriptor) RequestHasResourceBody() bool {
  1950  	return false
  1951  }
  1952  
  1953  func (d *BatchGetUsersByEmailDescriptor) GetVerb() string {
  1954  	return "batchGetByEmail"
  1955  }
  1956  
  1957  func (d *BatchGetUsersByEmailDescriptor) GetMethodName() string {
  1958  	return "BatchGetUsersByEmail"
  1959  }
  1960  
  1961  func (d *BatchGetUsersByEmailDescriptor) GetFullMethodName() string {
  1962  	return "/ntt.iam.v1.UserService/BatchGetUsersByEmail"
  1963  }
  1964  
  1965  func (d *BatchGetUsersByEmailDescriptor) GetProtoPkgName() string {
  1966  	return "ntt.iam.v1"
  1967  }
  1968  
  1969  func (d *BatchGetUsersByEmailDescriptor) GetApiName() string {
  1970  	return "UserService"
  1971  }
  1972  
  1973  func (d *BatchGetUsersByEmailDescriptor) GetServiceDomain() string {
  1974  	return "iam.edgelq.com"
  1975  }
  1976  
  1977  func (d *BatchGetUsersByEmailDescriptor) GetServiceVersion() string {
  1978  	return "v1"
  1979  }
  1980  
  1981  func (d *BatchGetUsersByEmailDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  1982  	return userServiceDescriptor
  1983  }
  1984  
  1985  func (d *BatchGetUsersByEmailDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  1986  	return user.GetDescriptor()
  1987  }
  1988  
  1989  func (d *BatchGetUsersByEmailDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  1990  	return &BatchGetUsersByEmailDescriptorClientMsgHandle{}
  1991  }
  1992  
  1993  func (d *BatchGetUsersByEmailDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  1994  	return &BatchGetUsersByEmailDescriptorServerMsgHandle{}
  1995  }
  1996  
  1997  func (h *BatchGetUsersByEmailDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  1998  	typedMsg := msg.(*BatchGetUsersByEmailRequest)
  1999  	var asInterface interface{} = h
  2000  	override, ok := asInterface.(interface {
  2001  		OverrideExtractResourceName(*BatchGetUsersByEmailRequest) *user.Name
  2002  	})
  2003  	if ok {
  2004  		return override.OverrideExtractResourceName(typedMsg)
  2005  	}
  2006  	return nil
  2007  }
  2008  
  2009  func (h *BatchGetUsersByEmailDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2010  	typedMsg := msg.(*BatchGetUsersByEmailRequest)
  2011  	var asInterface interface{} = h
  2012  	override, ok := asInterface.(interface {
  2013  		OverrideExtractResourceNames(*BatchGetUsersByEmailRequest) []*user.Name
  2014  	})
  2015  	if ok {
  2016  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2017  	}
  2018  	return nil
  2019  }
  2020  
  2021  func (h *BatchGetUsersByEmailDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2022  	return nil
  2023  }
  2024  
  2025  func (h *BatchGetUsersByEmailDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2026  	typedMsg := msg.(*BatchGetUsersByEmailRequest)
  2027  	var asInterface interface{} = h
  2028  	override, ok := asInterface.(interface {
  2029  		OverrideExtractResourceBody(*BatchGetUsersByEmailRequest) *user.User
  2030  	})
  2031  	if ok {
  2032  		return override.OverrideExtractResourceBody(typedMsg)
  2033  	}
  2034  	return nil
  2035  }
  2036  
  2037  func (h *BatchGetUsersByEmailDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2038  	typedMsg := msg.(*BatchGetUsersByEmailRequest)
  2039  	var asInterface interface{} = h
  2040  	override, ok := asInterface.(interface {
  2041  		OverrideExtractResourceBodies(*BatchGetUsersByEmailRequest) []*user.User
  2042  	})
  2043  	if ok {
  2044  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2045  	}
  2046  	return nil
  2047  }
  2048  
  2049  func (h *BatchGetUsersByEmailDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2050  	typedMsg := msg.(*BatchGetUsersByEmailResponse)
  2051  	var asInterface interface{} = h
  2052  	override, ok := asInterface.(interface {
  2053  		OverrideExtractResourceName(*BatchGetUsersByEmailResponse) *user.Name
  2054  	})
  2055  	if ok {
  2056  		return override.OverrideExtractResourceName(typedMsg)
  2057  	}
  2058  	return nil
  2059  }
  2060  
  2061  func (h *BatchGetUsersByEmailDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2062  	typedMsg := msg.(*BatchGetUsersByEmailResponse)
  2063  	var asInterface interface{} = h
  2064  	override, ok := asInterface.(interface {
  2065  		OverrideExtractResourceNames(*BatchGetUsersByEmailResponse) []*user.Name
  2066  	})
  2067  	if ok {
  2068  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2069  	}
  2070  	return nil
  2071  }
  2072  
  2073  func (h *BatchGetUsersByEmailDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2074  	return nil
  2075  }
  2076  
  2077  func (h *BatchGetUsersByEmailDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2078  	typedMsg := msg.(*BatchGetUsersByEmailResponse)
  2079  	var asInterface interface{} = h
  2080  	override, ok := asInterface.(interface {
  2081  		OverrideExtractResourceBody(*BatchGetUsersByEmailResponse) *user.User
  2082  	})
  2083  	if ok {
  2084  		return override.OverrideExtractResourceBody(typedMsg)
  2085  	}
  2086  	return nil
  2087  }
  2088  
  2089  func (h *BatchGetUsersByEmailDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2090  	typedMsg := msg.(*BatchGetUsersByEmailResponse)
  2091  	var asInterface interface{} = h
  2092  	override, ok := asInterface.(interface {
  2093  		OverrideExtractResourceBodies(*BatchGetUsersByEmailResponse) []*user.User
  2094  	})
  2095  	if ok {
  2096  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2097  	}
  2098  	return nil
  2099  }
  2100  
  2101  func GetBatchGetUsersByEmailDescriptor() *BatchGetUsersByEmailDescriptor {
  2102  	return batchGetUsersByEmailDescriptor
  2103  }
  2104  
  2105  type GetMySettingsDescriptor struct{}
  2106  
  2107  type GetMySettingsDescriptorClientMsgHandle struct{}
  2108  
  2109  type GetMySettingsDescriptorServerMsgHandle struct{}
  2110  
  2111  func (d *GetMySettingsDescriptor) NewEmptyClientMsg() proto.Message {
  2112  	return &GetMySettingsRequest{}
  2113  }
  2114  
  2115  func (d *GetMySettingsDescriptor) NewEmptyServerMsg() proto.Message {
  2116  	return &GetMySettingsResponse{}
  2117  }
  2118  
  2119  func (d *GetMySettingsDescriptor) IsUnary() bool {
  2120  	return true
  2121  }
  2122  
  2123  func (d *GetMySettingsDescriptor) IsClientStream() bool {
  2124  	return false
  2125  }
  2126  
  2127  func (d *GetMySettingsDescriptor) IsServerStream() bool {
  2128  	return false
  2129  }
  2130  
  2131  func (d *GetMySettingsDescriptor) IsCollection() bool {
  2132  	return true
  2133  }
  2134  
  2135  func (d *GetMySettingsDescriptor) IsPlural() bool {
  2136  	return false
  2137  }
  2138  
  2139  func (d *GetMySettingsDescriptor) HasResource() bool {
  2140  	return true
  2141  }
  2142  
  2143  func (d *GetMySettingsDescriptor) RequestHasResourceBody() bool {
  2144  	return false
  2145  }
  2146  
  2147  func (d *GetMySettingsDescriptor) GetVerb() string {
  2148  	return "getMySettings"
  2149  }
  2150  
  2151  func (d *GetMySettingsDescriptor) GetMethodName() string {
  2152  	return "GetMySettings"
  2153  }
  2154  
  2155  func (d *GetMySettingsDescriptor) GetFullMethodName() string {
  2156  	return "/ntt.iam.v1.UserService/GetMySettings"
  2157  }
  2158  
  2159  func (d *GetMySettingsDescriptor) GetProtoPkgName() string {
  2160  	return "ntt.iam.v1"
  2161  }
  2162  
  2163  func (d *GetMySettingsDescriptor) GetApiName() string {
  2164  	return "UserService"
  2165  }
  2166  
  2167  func (d *GetMySettingsDescriptor) GetServiceDomain() string {
  2168  	return "iam.edgelq.com"
  2169  }
  2170  
  2171  func (d *GetMySettingsDescriptor) GetServiceVersion() string {
  2172  	return "v1"
  2173  }
  2174  
  2175  func (d *GetMySettingsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  2176  	return userServiceDescriptor
  2177  }
  2178  
  2179  func (d *GetMySettingsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  2180  	return user.GetDescriptor()
  2181  }
  2182  
  2183  func (d *GetMySettingsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  2184  	return &GetMySettingsDescriptorClientMsgHandle{}
  2185  }
  2186  
  2187  func (d *GetMySettingsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  2188  	return &GetMySettingsDescriptorServerMsgHandle{}
  2189  }
  2190  
  2191  func (h *GetMySettingsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2192  	typedMsg := msg.(*GetMySettingsRequest)
  2193  	var asInterface interface{} = h
  2194  	override, ok := asInterface.(interface {
  2195  		OverrideExtractResourceName(*GetMySettingsRequest) *user.Name
  2196  	})
  2197  	if ok {
  2198  		return override.OverrideExtractResourceName(typedMsg)
  2199  	}
  2200  	return nil
  2201  }
  2202  
  2203  func (h *GetMySettingsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2204  	typedMsg := msg.(*GetMySettingsRequest)
  2205  	var asInterface interface{} = h
  2206  	override, ok := asInterface.(interface {
  2207  		OverrideExtractResourceNames(*GetMySettingsRequest) []*user.Name
  2208  	})
  2209  	if ok {
  2210  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2211  	}
  2212  	return nil
  2213  }
  2214  
  2215  func (h *GetMySettingsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2216  	return nil
  2217  }
  2218  
  2219  func (h *GetMySettingsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2220  	typedMsg := msg.(*GetMySettingsRequest)
  2221  	var asInterface interface{} = h
  2222  	override, ok := asInterface.(interface {
  2223  		OverrideExtractResourceBody(*GetMySettingsRequest) *user.User
  2224  	})
  2225  	if ok {
  2226  		return override.OverrideExtractResourceBody(typedMsg)
  2227  	}
  2228  	return nil
  2229  }
  2230  
  2231  func (h *GetMySettingsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2232  	typedMsg := msg.(*GetMySettingsRequest)
  2233  	var asInterface interface{} = h
  2234  	override, ok := asInterface.(interface {
  2235  		OverrideExtractResourceBodies(*GetMySettingsRequest) []*user.User
  2236  	})
  2237  	if ok {
  2238  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2239  	}
  2240  	return nil
  2241  }
  2242  
  2243  func (h *GetMySettingsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2244  	typedMsg := msg.(*GetMySettingsResponse)
  2245  	var asInterface interface{} = h
  2246  	override, ok := asInterface.(interface {
  2247  		OverrideExtractResourceName(*GetMySettingsResponse) *user.Name
  2248  	})
  2249  	if ok {
  2250  		return override.OverrideExtractResourceName(typedMsg)
  2251  	}
  2252  	return nil
  2253  }
  2254  
  2255  func (h *GetMySettingsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2256  	typedMsg := msg.(*GetMySettingsResponse)
  2257  	var asInterface interface{} = h
  2258  	override, ok := asInterface.(interface {
  2259  		OverrideExtractResourceNames(*GetMySettingsResponse) []*user.Name
  2260  	})
  2261  	if ok {
  2262  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2263  	}
  2264  	return nil
  2265  }
  2266  
  2267  func (h *GetMySettingsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2268  	return nil
  2269  }
  2270  
  2271  func (h *GetMySettingsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2272  	typedMsg := msg.(*GetMySettingsResponse)
  2273  	var asInterface interface{} = h
  2274  	override, ok := asInterface.(interface {
  2275  		OverrideExtractResourceBody(*GetMySettingsResponse) *user.User
  2276  	})
  2277  	if ok {
  2278  		return override.OverrideExtractResourceBody(typedMsg)
  2279  	}
  2280  	return nil
  2281  }
  2282  
  2283  func (h *GetMySettingsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2284  	typedMsg := msg.(*GetMySettingsResponse)
  2285  	var asInterface interface{} = h
  2286  	override, ok := asInterface.(interface {
  2287  		OverrideExtractResourceBodies(*GetMySettingsResponse) []*user.User
  2288  	})
  2289  	if ok {
  2290  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2291  	}
  2292  	return nil
  2293  }
  2294  
  2295  func GetGetMySettingsDescriptor() *GetMySettingsDescriptor {
  2296  	return getMySettingsDescriptor
  2297  }
  2298  
  2299  type SetMySettingsDescriptor struct{}
  2300  
  2301  type SetMySettingsDescriptorClientMsgHandle struct{}
  2302  
  2303  type SetMySettingsDescriptorServerMsgHandle struct{}
  2304  
  2305  func (d *SetMySettingsDescriptor) NewEmptyClientMsg() proto.Message {
  2306  	return &SetMySettingsRequest{}
  2307  }
  2308  
  2309  func (d *SetMySettingsDescriptor) NewEmptyServerMsg() proto.Message {
  2310  	return &emptypb.Empty{}
  2311  }
  2312  
  2313  func (d *SetMySettingsDescriptor) IsUnary() bool {
  2314  	return true
  2315  }
  2316  
  2317  func (d *SetMySettingsDescriptor) IsClientStream() bool {
  2318  	return false
  2319  }
  2320  
  2321  func (d *SetMySettingsDescriptor) IsServerStream() bool {
  2322  	return false
  2323  }
  2324  
  2325  func (d *SetMySettingsDescriptor) IsCollection() bool {
  2326  	return true
  2327  }
  2328  
  2329  func (d *SetMySettingsDescriptor) IsPlural() bool {
  2330  	return false
  2331  }
  2332  
  2333  func (d *SetMySettingsDescriptor) HasResource() bool {
  2334  	return true
  2335  }
  2336  
  2337  func (d *SetMySettingsDescriptor) RequestHasResourceBody() bool {
  2338  	return false
  2339  }
  2340  
  2341  func (d *SetMySettingsDescriptor) GetVerb() string {
  2342  	return "setMySettings"
  2343  }
  2344  
  2345  func (d *SetMySettingsDescriptor) GetMethodName() string {
  2346  	return "SetMySettings"
  2347  }
  2348  
  2349  func (d *SetMySettingsDescriptor) GetFullMethodName() string {
  2350  	return "/ntt.iam.v1.UserService/SetMySettings"
  2351  }
  2352  
  2353  func (d *SetMySettingsDescriptor) GetProtoPkgName() string {
  2354  	return "ntt.iam.v1"
  2355  }
  2356  
  2357  func (d *SetMySettingsDescriptor) GetApiName() string {
  2358  	return "UserService"
  2359  }
  2360  
  2361  func (d *SetMySettingsDescriptor) GetServiceDomain() string {
  2362  	return "iam.edgelq.com"
  2363  }
  2364  
  2365  func (d *SetMySettingsDescriptor) GetServiceVersion() string {
  2366  	return "v1"
  2367  }
  2368  
  2369  func (d *SetMySettingsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  2370  	return userServiceDescriptor
  2371  }
  2372  
  2373  func (d *SetMySettingsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  2374  	return user.GetDescriptor()
  2375  }
  2376  
  2377  func (d *SetMySettingsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  2378  	return &SetMySettingsDescriptorClientMsgHandle{}
  2379  }
  2380  
  2381  func (d *SetMySettingsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  2382  	return &SetMySettingsDescriptorServerMsgHandle{}
  2383  }
  2384  
  2385  func (h *SetMySettingsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2386  	typedMsg := msg.(*SetMySettingsRequest)
  2387  	var asInterface interface{} = h
  2388  	override, ok := asInterface.(interface {
  2389  		OverrideExtractResourceName(*SetMySettingsRequest) *user.Name
  2390  	})
  2391  	if ok {
  2392  		return override.OverrideExtractResourceName(typedMsg)
  2393  	}
  2394  	return nil
  2395  }
  2396  
  2397  func (h *SetMySettingsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2398  	typedMsg := msg.(*SetMySettingsRequest)
  2399  	var asInterface interface{} = h
  2400  	override, ok := asInterface.(interface {
  2401  		OverrideExtractResourceNames(*SetMySettingsRequest) []*user.Name
  2402  	})
  2403  	if ok {
  2404  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2405  	}
  2406  	return nil
  2407  }
  2408  
  2409  func (h *SetMySettingsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2410  	return nil
  2411  }
  2412  
  2413  func (h *SetMySettingsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2414  	typedMsg := msg.(*SetMySettingsRequest)
  2415  	var asInterface interface{} = h
  2416  	override, ok := asInterface.(interface {
  2417  		OverrideExtractResourceBody(*SetMySettingsRequest) *user.User
  2418  	})
  2419  	if ok {
  2420  		return override.OverrideExtractResourceBody(typedMsg)
  2421  	}
  2422  	return nil
  2423  }
  2424  
  2425  func (h *SetMySettingsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2426  	typedMsg := msg.(*SetMySettingsRequest)
  2427  	var asInterface interface{} = h
  2428  	override, ok := asInterface.(interface {
  2429  		OverrideExtractResourceBodies(*SetMySettingsRequest) []*user.User
  2430  	})
  2431  	if ok {
  2432  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2433  	}
  2434  	return nil
  2435  }
  2436  
  2437  func (h *SetMySettingsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2438  	typedMsg := msg.(*emptypb.Empty)
  2439  	var asInterface interface{} = h
  2440  	override, ok := asInterface.(interface {
  2441  		OverrideExtractResourceName(*emptypb.Empty) *user.Name
  2442  	})
  2443  	if ok {
  2444  		return override.OverrideExtractResourceName(typedMsg)
  2445  	}
  2446  	return nil
  2447  }
  2448  
  2449  func (h *SetMySettingsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2450  	typedMsg := msg.(*emptypb.Empty)
  2451  	var asInterface interface{} = h
  2452  	override, ok := asInterface.(interface {
  2453  		OverrideExtractResourceNames(*emptypb.Empty) []*user.Name
  2454  	})
  2455  	if ok {
  2456  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2457  	}
  2458  	return nil
  2459  }
  2460  
  2461  func (h *SetMySettingsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2462  	return nil
  2463  }
  2464  
  2465  func (h *SetMySettingsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2466  	typedMsg := msg.(*emptypb.Empty)
  2467  	var asInterface interface{} = h
  2468  	override, ok := asInterface.(interface {
  2469  		OverrideExtractResourceBody(*emptypb.Empty) *user.User
  2470  	})
  2471  	if ok {
  2472  		return override.OverrideExtractResourceBody(typedMsg)
  2473  	}
  2474  	return nil
  2475  }
  2476  
  2477  func (h *SetMySettingsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2478  	typedMsg := msg.(*emptypb.Empty)
  2479  	var asInterface interface{} = h
  2480  	override, ok := asInterface.(interface {
  2481  		OverrideExtractResourceBodies(*emptypb.Empty) []*user.User
  2482  	})
  2483  	if ok {
  2484  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2485  	}
  2486  	return nil
  2487  }
  2488  
  2489  func GetSetMySettingsDescriptor() *SetMySettingsDescriptor {
  2490  	return setMySettingsDescriptor
  2491  }
  2492  
  2493  type RefreshUserFromIdTokenDescriptor struct{}
  2494  
  2495  type RefreshUserFromIdTokenDescriptorClientMsgHandle struct{}
  2496  
  2497  type RefreshUserFromIdTokenDescriptorServerMsgHandle struct{}
  2498  
  2499  func (d *RefreshUserFromIdTokenDescriptor) NewEmptyClientMsg() proto.Message {
  2500  	return &RefreshUserFromIdTokenRequest{}
  2501  }
  2502  
  2503  func (d *RefreshUserFromIdTokenDescriptor) NewEmptyServerMsg() proto.Message {
  2504  	return &RefreshUserFromIdTokenResponse{}
  2505  }
  2506  
  2507  func (d *RefreshUserFromIdTokenDescriptor) IsUnary() bool {
  2508  	return true
  2509  }
  2510  
  2511  func (d *RefreshUserFromIdTokenDescriptor) IsClientStream() bool {
  2512  	return false
  2513  }
  2514  
  2515  func (d *RefreshUserFromIdTokenDescriptor) IsServerStream() bool {
  2516  	return false
  2517  }
  2518  
  2519  func (d *RefreshUserFromIdTokenDescriptor) IsCollection() bool {
  2520  	return true
  2521  }
  2522  
  2523  func (d *RefreshUserFromIdTokenDescriptor) IsPlural() bool {
  2524  	return false
  2525  }
  2526  
  2527  func (d *RefreshUserFromIdTokenDescriptor) HasResource() bool {
  2528  	return true
  2529  }
  2530  
  2531  func (d *RefreshUserFromIdTokenDescriptor) RequestHasResourceBody() bool {
  2532  	return false
  2533  }
  2534  
  2535  func (d *RefreshUserFromIdTokenDescriptor) GetVerb() string {
  2536  	return "refreshUserFromIdToken"
  2537  }
  2538  
  2539  func (d *RefreshUserFromIdTokenDescriptor) GetMethodName() string {
  2540  	return "RefreshUserFromIdToken"
  2541  }
  2542  
  2543  func (d *RefreshUserFromIdTokenDescriptor) GetFullMethodName() string {
  2544  	return "/ntt.iam.v1.UserService/RefreshUserFromIdToken"
  2545  }
  2546  
  2547  func (d *RefreshUserFromIdTokenDescriptor) GetProtoPkgName() string {
  2548  	return "ntt.iam.v1"
  2549  }
  2550  
  2551  func (d *RefreshUserFromIdTokenDescriptor) GetApiName() string {
  2552  	return "UserService"
  2553  }
  2554  
  2555  func (d *RefreshUserFromIdTokenDescriptor) GetServiceDomain() string {
  2556  	return "iam.edgelq.com"
  2557  }
  2558  
  2559  func (d *RefreshUserFromIdTokenDescriptor) GetServiceVersion() string {
  2560  	return "v1"
  2561  }
  2562  
  2563  func (d *RefreshUserFromIdTokenDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  2564  	return userServiceDescriptor
  2565  }
  2566  
  2567  func (d *RefreshUserFromIdTokenDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  2568  	return user.GetDescriptor()
  2569  }
  2570  
  2571  func (d *RefreshUserFromIdTokenDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  2572  	return &RefreshUserFromIdTokenDescriptorClientMsgHandle{}
  2573  }
  2574  
  2575  func (d *RefreshUserFromIdTokenDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  2576  	return &RefreshUserFromIdTokenDescriptorServerMsgHandle{}
  2577  }
  2578  
  2579  func (h *RefreshUserFromIdTokenDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2580  	typedMsg := msg.(*RefreshUserFromIdTokenRequest)
  2581  	var asInterface interface{} = h
  2582  	override, ok := asInterface.(interface {
  2583  		OverrideExtractResourceName(*RefreshUserFromIdTokenRequest) *user.Name
  2584  	})
  2585  	if ok {
  2586  		return override.OverrideExtractResourceName(typedMsg)
  2587  	}
  2588  	return nil
  2589  }
  2590  
  2591  func (h *RefreshUserFromIdTokenDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2592  	typedMsg := msg.(*RefreshUserFromIdTokenRequest)
  2593  	var asInterface interface{} = h
  2594  	override, ok := asInterface.(interface {
  2595  		OverrideExtractResourceNames(*RefreshUserFromIdTokenRequest) []*user.Name
  2596  	})
  2597  	if ok {
  2598  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2599  	}
  2600  	return nil
  2601  }
  2602  
  2603  func (h *RefreshUserFromIdTokenDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2604  	return nil
  2605  }
  2606  
  2607  func (h *RefreshUserFromIdTokenDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2608  	typedMsg := msg.(*RefreshUserFromIdTokenRequest)
  2609  	var asInterface interface{} = h
  2610  	override, ok := asInterface.(interface {
  2611  		OverrideExtractResourceBody(*RefreshUserFromIdTokenRequest) *user.User
  2612  	})
  2613  	if ok {
  2614  		return override.OverrideExtractResourceBody(typedMsg)
  2615  	}
  2616  	return nil
  2617  }
  2618  
  2619  func (h *RefreshUserFromIdTokenDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2620  	typedMsg := msg.(*RefreshUserFromIdTokenRequest)
  2621  	var asInterface interface{} = h
  2622  	override, ok := asInterface.(interface {
  2623  		OverrideExtractResourceBodies(*RefreshUserFromIdTokenRequest) []*user.User
  2624  	})
  2625  	if ok {
  2626  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2627  	}
  2628  	return nil
  2629  }
  2630  
  2631  func (h *RefreshUserFromIdTokenDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2632  	typedMsg := msg.(*RefreshUserFromIdTokenResponse)
  2633  	var asInterface interface{} = h
  2634  	override, ok := asInterface.(interface {
  2635  		OverrideExtractResourceName(*RefreshUserFromIdTokenResponse) *user.Name
  2636  	})
  2637  	if ok {
  2638  		return override.OverrideExtractResourceName(typedMsg)
  2639  	}
  2640  	return nil
  2641  }
  2642  
  2643  func (h *RefreshUserFromIdTokenDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2644  	typedMsg := msg.(*RefreshUserFromIdTokenResponse)
  2645  	var asInterface interface{} = h
  2646  	override, ok := asInterface.(interface {
  2647  		OverrideExtractResourceNames(*RefreshUserFromIdTokenResponse) []*user.Name
  2648  	})
  2649  	if ok {
  2650  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2651  	}
  2652  	return nil
  2653  }
  2654  
  2655  func (h *RefreshUserFromIdTokenDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2656  	return nil
  2657  }
  2658  
  2659  func (h *RefreshUserFromIdTokenDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2660  	typedMsg := msg.(*RefreshUserFromIdTokenResponse)
  2661  	var asInterface interface{} = h
  2662  	override, ok := asInterface.(interface {
  2663  		OverrideExtractResourceBody(*RefreshUserFromIdTokenResponse) *user.User
  2664  	})
  2665  	if ok {
  2666  		return override.OverrideExtractResourceBody(typedMsg)
  2667  	}
  2668  	return nil
  2669  }
  2670  
  2671  func (h *RefreshUserFromIdTokenDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2672  	typedMsg := msg.(*RefreshUserFromIdTokenResponse)
  2673  	var asInterface interface{} = h
  2674  	override, ok := asInterface.(interface {
  2675  		OverrideExtractResourceBodies(*RefreshUserFromIdTokenResponse) []*user.User
  2676  	})
  2677  	if ok {
  2678  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2679  	}
  2680  	return nil
  2681  }
  2682  
  2683  func GetRefreshUserFromIdTokenDescriptor() *RefreshUserFromIdTokenDescriptor {
  2684  	return refreshUserFromIdTokenDescriptor
  2685  }
  2686  
  2687  type ResendVerificationEmailDescriptor struct{}
  2688  
  2689  type ResendVerificationEmailDescriptorClientMsgHandle struct{}
  2690  
  2691  type ResendVerificationEmailDescriptorServerMsgHandle struct{}
  2692  
  2693  func (d *ResendVerificationEmailDescriptor) NewEmptyClientMsg() proto.Message {
  2694  	return &ResendVerificationEmailRequest{}
  2695  }
  2696  
  2697  func (d *ResendVerificationEmailDescriptor) NewEmptyServerMsg() proto.Message {
  2698  	return &emptypb.Empty{}
  2699  }
  2700  
  2701  func (d *ResendVerificationEmailDescriptor) IsUnary() bool {
  2702  	return true
  2703  }
  2704  
  2705  func (d *ResendVerificationEmailDescriptor) IsClientStream() bool {
  2706  	return false
  2707  }
  2708  
  2709  func (d *ResendVerificationEmailDescriptor) IsServerStream() bool {
  2710  	return false
  2711  }
  2712  
  2713  func (d *ResendVerificationEmailDescriptor) IsCollection() bool {
  2714  	return true
  2715  }
  2716  
  2717  func (d *ResendVerificationEmailDescriptor) IsPlural() bool {
  2718  	return false
  2719  }
  2720  
  2721  func (d *ResendVerificationEmailDescriptor) HasResource() bool {
  2722  	return true
  2723  }
  2724  
  2725  func (d *ResendVerificationEmailDescriptor) RequestHasResourceBody() bool {
  2726  	return false
  2727  }
  2728  
  2729  func (d *ResendVerificationEmailDescriptor) GetVerb() string {
  2730  	return "resendVerificationEmail"
  2731  }
  2732  
  2733  func (d *ResendVerificationEmailDescriptor) GetMethodName() string {
  2734  	return "ResendVerificationEmail"
  2735  }
  2736  
  2737  func (d *ResendVerificationEmailDescriptor) GetFullMethodName() string {
  2738  	return "/ntt.iam.v1.UserService/ResendVerificationEmail"
  2739  }
  2740  
  2741  func (d *ResendVerificationEmailDescriptor) GetProtoPkgName() string {
  2742  	return "ntt.iam.v1"
  2743  }
  2744  
  2745  func (d *ResendVerificationEmailDescriptor) GetApiName() string {
  2746  	return "UserService"
  2747  }
  2748  
  2749  func (d *ResendVerificationEmailDescriptor) GetServiceDomain() string {
  2750  	return "iam.edgelq.com"
  2751  }
  2752  
  2753  func (d *ResendVerificationEmailDescriptor) GetServiceVersion() string {
  2754  	return "v1"
  2755  }
  2756  
  2757  func (d *ResendVerificationEmailDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  2758  	return userServiceDescriptor
  2759  }
  2760  
  2761  func (d *ResendVerificationEmailDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  2762  	return user.GetDescriptor()
  2763  }
  2764  
  2765  func (d *ResendVerificationEmailDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  2766  	return &ResendVerificationEmailDescriptorClientMsgHandle{}
  2767  }
  2768  
  2769  func (d *ResendVerificationEmailDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  2770  	return &ResendVerificationEmailDescriptorServerMsgHandle{}
  2771  }
  2772  
  2773  func (h *ResendVerificationEmailDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2774  	typedMsg := msg.(*ResendVerificationEmailRequest)
  2775  	var asInterface interface{} = h
  2776  	override, ok := asInterface.(interface {
  2777  		OverrideExtractResourceName(*ResendVerificationEmailRequest) *user.Name
  2778  	})
  2779  	if ok {
  2780  		return override.OverrideExtractResourceName(typedMsg)
  2781  	}
  2782  	return nil
  2783  }
  2784  
  2785  func (h *ResendVerificationEmailDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2786  	typedMsg := msg.(*ResendVerificationEmailRequest)
  2787  	var asInterface interface{} = h
  2788  	override, ok := asInterface.(interface {
  2789  		OverrideExtractResourceNames(*ResendVerificationEmailRequest) []*user.Name
  2790  	})
  2791  	if ok {
  2792  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2793  	}
  2794  	return nil
  2795  }
  2796  
  2797  func (h *ResendVerificationEmailDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2798  	return nil
  2799  }
  2800  
  2801  func (h *ResendVerificationEmailDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2802  	typedMsg := msg.(*ResendVerificationEmailRequest)
  2803  	var asInterface interface{} = h
  2804  	override, ok := asInterface.(interface {
  2805  		OverrideExtractResourceBody(*ResendVerificationEmailRequest) *user.User
  2806  	})
  2807  	if ok {
  2808  		return override.OverrideExtractResourceBody(typedMsg)
  2809  	}
  2810  	return nil
  2811  }
  2812  
  2813  func (h *ResendVerificationEmailDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2814  	typedMsg := msg.(*ResendVerificationEmailRequest)
  2815  	var asInterface interface{} = h
  2816  	override, ok := asInterface.(interface {
  2817  		OverrideExtractResourceBodies(*ResendVerificationEmailRequest) []*user.User
  2818  	})
  2819  	if ok {
  2820  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2821  	}
  2822  	return nil
  2823  }
  2824  
  2825  func (h *ResendVerificationEmailDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2826  	typedMsg := msg.(*emptypb.Empty)
  2827  	var asInterface interface{} = h
  2828  	override, ok := asInterface.(interface {
  2829  		OverrideExtractResourceName(*emptypb.Empty) *user.Name
  2830  	})
  2831  	if ok {
  2832  		return override.OverrideExtractResourceName(typedMsg)
  2833  	}
  2834  	return nil
  2835  }
  2836  
  2837  func (h *ResendVerificationEmailDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2838  	typedMsg := msg.(*emptypb.Empty)
  2839  	var asInterface interface{} = h
  2840  	override, ok := asInterface.(interface {
  2841  		OverrideExtractResourceNames(*emptypb.Empty) []*user.Name
  2842  	})
  2843  	if ok {
  2844  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2845  	}
  2846  	return nil
  2847  }
  2848  
  2849  func (h *ResendVerificationEmailDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2850  	return nil
  2851  }
  2852  
  2853  func (h *ResendVerificationEmailDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2854  	typedMsg := msg.(*emptypb.Empty)
  2855  	var asInterface interface{} = h
  2856  	override, ok := asInterface.(interface {
  2857  		OverrideExtractResourceBody(*emptypb.Empty) *user.User
  2858  	})
  2859  	if ok {
  2860  		return override.OverrideExtractResourceBody(typedMsg)
  2861  	}
  2862  	return nil
  2863  }
  2864  
  2865  func (h *ResendVerificationEmailDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  2866  	typedMsg := msg.(*emptypb.Empty)
  2867  	var asInterface interface{} = h
  2868  	override, ok := asInterface.(interface {
  2869  		OverrideExtractResourceBodies(*emptypb.Empty) []*user.User
  2870  	})
  2871  	if ok {
  2872  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  2873  	}
  2874  	return nil
  2875  }
  2876  
  2877  func GetResendVerificationEmailDescriptor() *ResendVerificationEmailDescriptor {
  2878  	return resendVerificationEmailDescriptor
  2879  }
  2880  
  2881  type IsUserVerifiedDescriptor struct{}
  2882  
  2883  type IsUserVerifiedDescriptorClientMsgHandle struct{}
  2884  
  2885  type IsUserVerifiedDescriptorServerMsgHandle struct{}
  2886  
  2887  func (d *IsUserVerifiedDescriptor) NewEmptyClientMsg() proto.Message {
  2888  	return &IsUserVerifiedRequest{}
  2889  }
  2890  
  2891  func (d *IsUserVerifiedDescriptor) NewEmptyServerMsg() proto.Message {
  2892  	return &emptypb.Empty{}
  2893  }
  2894  
  2895  func (d *IsUserVerifiedDescriptor) IsUnary() bool {
  2896  	return true
  2897  }
  2898  
  2899  func (d *IsUserVerifiedDescriptor) IsClientStream() bool {
  2900  	return false
  2901  }
  2902  
  2903  func (d *IsUserVerifiedDescriptor) IsServerStream() bool {
  2904  	return false
  2905  }
  2906  
  2907  func (d *IsUserVerifiedDescriptor) IsCollection() bool {
  2908  	return true
  2909  }
  2910  
  2911  func (d *IsUserVerifiedDescriptor) IsPlural() bool {
  2912  	return false
  2913  }
  2914  
  2915  func (d *IsUserVerifiedDescriptor) HasResource() bool {
  2916  	return true
  2917  }
  2918  
  2919  func (d *IsUserVerifiedDescriptor) RequestHasResourceBody() bool {
  2920  	return false
  2921  }
  2922  
  2923  func (d *IsUserVerifiedDescriptor) GetVerb() string {
  2924  	return "isUserVerified"
  2925  }
  2926  
  2927  func (d *IsUserVerifiedDescriptor) GetMethodName() string {
  2928  	return "IsUserVerified"
  2929  }
  2930  
  2931  func (d *IsUserVerifiedDescriptor) GetFullMethodName() string {
  2932  	return "/ntt.iam.v1.UserService/IsUserVerified"
  2933  }
  2934  
  2935  func (d *IsUserVerifiedDescriptor) GetProtoPkgName() string {
  2936  	return "ntt.iam.v1"
  2937  }
  2938  
  2939  func (d *IsUserVerifiedDescriptor) GetApiName() string {
  2940  	return "UserService"
  2941  }
  2942  
  2943  func (d *IsUserVerifiedDescriptor) GetServiceDomain() string {
  2944  	return "iam.edgelq.com"
  2945  }
  2946  
  2947  func (d *IsUserVerifiedDescriptor) GetServiceVersion() string {
  2948  	return "v1"
  2949  }
  2950  
  2951  func (d *IsUserVerifiedDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  2952  	return userServiceDescriptor
  2953  }
  2954  
  2955  func (d *IsUserVerifiedDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  2956  	return user.GetDescriptor()
  2957  }
  2958  
  2959  func (d *IsUserVerifiedDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  2960  	return &IsUserVerifiedDescriptorClientMsgHandle{}
  2961  }
  2962  
  2963  func (d *IsUserVerifiedDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  2964  	return &IsUserVerifiedDescriptorServerMsgHandle{}
  2965  }
  2966  
  2967  func (h *IsUserVerifiedDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  2968  	typedMsg := msg.(*IsUserVerifiedRequest)
  2969  	var asInterface interface{} = h
  2970  	override, ok := asInterface.(interface {
  2971  		OverrideExtractResourceName(*IsUserVerifiedRequest) *user.Name
  2972  	})
  2973  	if ok {
  2974  		return override.OverrideExtractResourceName(typedMsg)
  2975  	}
  2976  	return nil
  2977  }
  2978  
  2979  func (h *IsUserVerifiedDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  2980  	typedMsg := msg.(*IsUserVerifiedRequest)
  2981  	var asInterface interface{} = h
  2982  	override, ok := asInterface.(interface {
  2983  		OverrideExtractResourceNames(*IsUserVerifiedRequest) []*user.Name
  2984  	})
  2985  	if ok {
  2986  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  2987  	}
  2988  	return nil
  2989  }
  2990  
  2991  func (h *IsUserVerifiedDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  2992  	return nil
  2993  }
  2994  
  2995  func (h *IsUserVerifiedDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  2996  	typedMsg := msg.(*IsUserVerifiedRequest)
  2997  	var asInterface interface{} = h
  2998  	override, ok := asInterface.(interface {
  2999  		OverrideExtractResourceBody(*IsUserVerifiedRequest) *user.User
  3000  	})
  3001  	if ok {
  3002  		return override.OverrideExtractResourceBody(typedMsg)
  3003  	}
  3004  	return nil
  3005  }
  3006  
  3007  func (h *IsUserVerifiedDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3008  	typedMsg := msg.(*IsUserVerifiedRequest)
  3009  	var asInterface interface{} = h
  3010  	override, ok := asInterface.(interface {
  3011  		OverrideExtractResourceBodies(*IsUserVerifiedRequest) []*user.User
  3012  	})
  3013  	if ok {
  3014  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3015  	}
  3016  	return nil
  3017  }
  3018  
  3019  func (h *IsUserVerifiedDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  3020  	typedMsg := msg.(*emptypb.Empty)
  3021  	var asInterface interface{} = h
  3022  	override, ok := asInterface.(interface {
  3023  		OverrideExtractResourceName(*emptypb.Empty) *user.Name
  3024  	})
  3025  	if ok {
  3026  		return override.OverrideExtractResourceName(typedMsg)
  3027  	}
  3028  	return nil
  3029  }
  3030  
  3031  func (h *IsUserVerifiedDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  3032  	typedMsg := msg.(*emptypb.Empty)
  3033  	var asInterface interface{} = h
  3034  	override, ok := asInterface.(interface {
  3035  		OverrideExtractResourceNames(*emptypb.Empty) []*user.Name
  3036  	})
  3037  	if ok {
  3038  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  3039  	}
  3040  	return nil
  3041  }
  3042  
  3043  func (h *IsUserVerifiedDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  3044  	return nil
  3045  }
  3046  
  3047  func (h *IsUserVerifiedDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  3048  	typedMsg := msg.(*emptypb.Empty)
  3049  	var asInterface interface{} = h
  3050  	override, ok := asInterface.(interface {
  3051  		OverrideExtractResourceBody(*emptypb.Empty) *user.User
  3052  	})
  3053  	if ok {
  3054  		return override.OverrideExtractResourceBody(typedMsg)
  3055  	}
  3056  	return nil
  3057  }
  3058  
  3059  func (h *IsUserVerifiedDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3060  	typedMsg := msg.(*emptypb.Empty)
  3061  	var asInterface interface{} = h
  3062  	override, ok := asInterface.(interface {
  3063  		OverrideExtractResourceBodies(*emptypb.Empty) []*user.User
  3064  	})
  3065  	if ok {
  3066  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3067  	}
  3068  	return nil
  3069  }
  3070  
  3071  func GetIsUserVerifiedDescriptor() *IsUserVerifiedDescriptor {
  3072  	return isUserVerifiedDescriptor
  3073  }
  3074  
  3075  type ResetMFAIfRecoveryKeyUsedDescriptor struct{}
  3076  
  3077  type ResetMFAIfRecoveryKeyUsedDescriptorClientMsgHandle struct{}
  3078  
  3079  type ResetMFAIfRecoveryKeyUsedDescriptorServerMsgHandle struct{}
  3080  
  3081  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) NewEmptyClientMsg() proto.Message {
  3082  	return &ResetMFAIfRecoveryKeyUsedRequest{}
  3083  }
  3084  
  3085  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) NewEmptyServerMsg() proto.Message {
  3086  	return &emptypb.Empty{}
  3087  }
  3088  
  3089  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) IsUnary() bool {
  3090  	return true
  3091  }
  3092  
  3093  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) IsClientStream() bool {
  3094  	return false
  3095  }
  3096  
  3097  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) IsServerStream() bool {
  3098  	return false
  3099  }
  3100  
  3101  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) IsCollection() bool {
  3102  	return true
  3103  }
  3104  
  3105  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) IsPlural() bool {
  3106  	return false
  3107  }
  3108  
  3109  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) HasResource() bool {
  3110  	return true
  3111  }
  3112  
  3113  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) RequestHasResourceBody() bool {
  3114  	return false
  3115  }
  3116  
  3117  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetVerb() string {
  3118  	return "resetMFAIfRecoveryKeyUsed"
  3119  }
  3120  
  3121  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetMethodName() string {
  3122  	return "ResetMFAIfRecoveryKeyUsed"
  3123  }
  3124  
  3125  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetFullMethodName() string {
  3126  	return "/ntt.iam.v1.UserService/ResetMFAIfRecoveryKeyUsed"
  3127  }
  3128  
  3129  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetProtoPkgName() string {
  3130  	return "ntt.iam.v1"
  3131  }
  3132  
  3133  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetApiName() string {
  3134  	return "UserService"
  3135  }
  3136  
  3137  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetServiceDomain() string {
  3138  	return "iam.edgelq.com"
  3139  }
  3140  
  3141  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetServiceVersion() string {
  3142  	return "v1"
  3143  }
  3144  
  3145  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  3146  	return userServiceDescriptor
  3147  }
  3148  
  3149  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  3150  	return user.GetDescriptor()
  3151  }
  3152  
  3153  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  3154  	return &ResetMFAIfRecoveryKeyUsedDescriptorClientMsgHandle{}
  3155  }
  3156  
  3157  func (d *ResetMFAIfRecoveryKeyUsedDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  3158  	return &ResetMFAIfRecoveryKeyUsedDescriptorServerMsgHandle{}
  3159  }
  3160  
  3161  func (h *ResetMFAIfRecoveryKeyUsedDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  3162  	typedMsg := msg.(*ResetMFAIfRecoveryKeyUsedRequest)
  3163  	var asInterface interface{} = h
  3164  	override, ok := asInterface.(interface {
  3165  		OverrideExtractResourceName(*ResetMFAIfRecoveryKeyUsedRequest) *user.Name
  3166  	})
  3167  	if ok {
  3168  		return override.OverrideExtractResourceName(typedMsg)
  3169  	}
  3170  	return nil
  3171  }
  3172  
  3173  func (h *ResetMFAIfRecoveryKeyUsedDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  3174  	typedMsg := msg.(*ResetMFAIfRecoveryKeyUsedRequest)
  3175  	var asInterface interface{} = h
  3176  	override, ok := asInterface.(interface {
  3177  		OverrideExtractResourceNames(*ResetMFAIfRecoveryKeyUsedRequest) []*user.Name
  3178  	})
  3179  	if ok {
  3180  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  3181  	}
  3182  	return nil
  3183  }
  3184  
  3185  func (h *ResetMFAIfRecoveryKeyUsedDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  3186  	return nil
  3187  }
  3188  
  3189  func (h *ResetMFAIfRecoveryKeyUsedDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  3190  	typedMsg := msg.(*ResetMFAIfRecoveryKeyUsedRequest)
  3191  	var asInterface interface{} = h
  3192  	override, ok := asInterface.(interface {
  3193  		OverrideExtractResourceBody(*ResetMFAIfRecoveryKeyUsedRequest) *user.User
  3194  	})
  3195  	if ok {
  3196  		return override.OverrideExtractResourceBody(typedMsg)
  3197  	}
  3198  	return nil
  3199  }
  3200  
  3201  func (h *ResetMFAIfRecoveryKeyUsedDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3202  	typedMsg := msg.(*ResetMFAIfRecoveryKeyUsedRequest)
  3203  	var asInterface interface{} = h
  3204  	override, ok := asInterface.(interface {
  3205  		OverrideExtractResourceBodies(*ResetMFAIfRecoveryKeyUsedRequest) []*user.User
  3206  	})
  3207  	if ok {
  3208  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3209  	}
  3210  	return nil
  3211  }
  3212  
  3213  func (h *ResetMFAIfRecoveryKeyUsedDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  3214  	typedMsg := msg.(*emptypb.Empty)
  3215  	var asInterface interface{} = h
  3216  	override, ok := asInterface.(interface {
  3217  		OverrideExtractResourceName(*emptypb.Empty) *user.Name
  3218  	})
  3219  	if ok {
  3220  		return override.OverrideExtractResourceName(typedMsg)
  3221  	}
  3222  	return nil
  3223  }
  3224  
  3225  func (h *ResetMFAIfRecoveryKeyUsedDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  3226  	typedMsg := msg.(*emptypb.Empty)
  3227  	var asInterface interface{} = h
  3228  	override, ok := asInterface.(interface {
  3229  		OverrideExtractResourceNames(*emptypb.Empty) []*user.Name
  3230  	})
  3231  	if ok {
  3232  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  3233  	}
  3234  	return nil
  3235  }
  3236  
  3237  func (h *ResetMFAIfRecoveryKeyUsedDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  3238  	return nil
  3239  }
  3240  
  3241  func (h *ResetMFAIfRecoveryKeyUsedDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  3242  	typedMsg := msg.(*emptypb.Empty)
  3243  	var asInterface interface{} = h
  3244  	override, ok := asInterface.(interface {
  3245  		OverrideExtractResourceBody(*emptypb.Empty) *user.User
  3246  	})
  3247  	if ok {
  3248  		return override.OverrideExtractResourceBody(typedMsg)
  3249  	}
  3250  	return nil
  3251  }
  3252  
  3253  func (h *ResetMFAIfRecoveryKeyUsedDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3254  	typedMsg := msg.(*emptypb.Empty)
  3255  	var asInterface interface{} = h
  3256  	override, ok := asInterface.(interface {
  3257  		OverrideExtractResourceBodies(*emptypb.Empty) []*user.User
  3258  	})
  3259  	if ok {
  3260  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3261  	}
  3262  	return nil
  3263  }
  3264  
  3265  func GetResetMFAIfRecoveryKeyUsedDescriptor() *ResetMFAIfRecoveryKeyUsedDescriptor {
  3266  	return resetMFAIfRecoveryKeyUsedDescriptor
  3267  }
  3268  
  3269  type SetUsersNameInAuth0Descriptor struct{}
  3270  
  3271  type SetUsersNameInAuth0DescriptorClientMsgHandle struct{}
  3272  
  3273  type SetUsersNameInAuth0DescriptorServerMsgHandle struct{}
  3274  
  3275  func (d *SetUsersNameInAuth0Descriptor) NewEmptyClientMsg() proto.Message {
  3276  	return &SetUsersNameInAuth0Request{}
  3277  }
  3278  
  3279  func (d *SetUsersNameInAuth0Descriptor) NewEmptyServerMsg() proto.Message {
  3280  	return &emptypb.Empty{}
  3281  }
  3282  
  3283  func (d *SetUsersNameInAuth0Descriptor) IsUnary() bool {
  3284  	return true
  3285  }
  3286  
  3287  func (d *SetUsersNameInAuth0Descriptor) IsClientStream() bool {
  3288  	return false
  3289  }
  3290  
  3291  func (d *SetUsersNameInAuth0Descriptor) IsServerStream() bool {
  3292  	return false
  3293  }
  3294  
  3295  func (d *SetUsersNameInAuth0Descriptor) IsCollection() bool {
  3296  	return true
  3297  }
  3298  
  3299  func (d *SetUsersNameInAuth0Descriptor) IsPlural() bool {
  3300  	return false
  3301  }
  3302  
  3303  func (d *SetUsersNameInAuth0Descriptor) HasResource() bool {
  3304  	return true
  3305  }
  3306  
  3307  func (d *SetUsersNameInAuth0Descriptor) RequestHasResourceBody() bool {
  3308  	return false
  3309  }
  3310  
  3311  func (d *SetUsersNameInAuth0Descriptor) GetVerb() string {
  3312  	return "setUsersNameInAuth0"
  3313  }
  3314  
  3315  func (d *SetUsersNameInAuth0Descriptor) GetMethodName() string {
  3316  	return "SetUsersNameInAuth0"
  3317  }
  3318  
  3319  func (d *SetUsersNameInAuth0Descriptor) GetFullMethodName() string {
  3320  	return "/ntt.iam.v1.UserService/SetUsersNameInAuth0"
  3321  }
  3322  
  3323  func (d *SetUsersNameInAuth0Descriptor) GetProtoPkgName() string {
  3324  	return "ntt.iam.v1"
  3325  }
  3326  
  3327  func (d *SetUsersNameInAuth0Descriptor) GetApiName() string {
  3328  	return "UserService"
  3329  }
  3330  
  3331  func (d *SetUsersNameInAuth0Descriptor) GetServiceDomain() string {
  3332  	return "iam.edgelq.com"
  3333  }
  3334  
  3335  func (d *SetUsersNameInAuth0Descriptor) GetServiceVersion() string {
  3336  	return "v1"
  3337  }
  3338  
  3339  func (d *SetUsersNameInAuth0Descriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  3340  	return userServiceDescriptor
  3341  }
  3342  
  3343  func (d *SetUsersNameInAuth0Descriptor) GetResourceDescriptor() gotenresource.Descriptor {
  3344  	return user.GetDescriptor()
  3345  }
  3346  
  3347  func (d *SetUsersNameInAuth0Descriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  3348  	return &SetUsersNameInAuth0DescriptorClientMsgHandle{}
  3349  }
  3350  
  3351  func (d *SetUsersNameInAuth0Descriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  3352  	return &SetUsersNameInAuth0DescriptorServerMsgHandle{}
  3353  }
  3354  
  3355  func (h *SetUsersNameInAuth0DescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  3356  	typedMsg := msg.(*SetUsersNameInAuth0Request)
  3357  	var asInterface interface{} = h
  3358  	override, ok := asInterface.(interface {
  3359  		OverrideExtractResourceName(*SetUsersNameInAuth0Request) *user.Name
  3360  	})
  3361  	if ok {
  3362  		return override.OverrideExtractResourceName(typedMsg)
  3363  	}
  3364  	return nil
  3365  }
  3366  
  3367  func (h *SetUsersNameInAuth0DescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  3368  	typedMsg := msg.(*SetUsersNameInAuth0Request)
  3369  	var asInterface interface{} = h
  3370  	override, ok := asInterface.(interface {
  3371  		OverrideExtractResourceNames(*SetUsersNameInAuth0Request) []*user.Name
  3372  	})
  3373  	if ok {
  3374  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  3375  	}
  3376  	return nil
  3377  }
  3378  
  3379  func (h *SetUsersNameInAuth0DescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  3380  	return nil
  3381  }
  3382  
  3383  func (h *SetUsersNameInAuth0DescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  3384  	typedMsg := msg.(*SetUsersNameInAuth0Request)
  3385  	var asInterface interface{} = h
  3386  	override, ok := asInterface.(interface {
  3387  		OverrideExtractResourceBody(*SetUsersNameInAuth0Request) *user.User
  3388  	})
  3389  	if ok {
  3390  		return override.OverrideExtractResourceBody(typedMsg)
  3391  	}
  3392  	return nil
  3393  }
  3394  
  3395  func (h *SetUsersNameInAuth0DescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3396  	typedMsg := msg.(*SetUsersNameInAuth0Request)
  3397  	var asInterface interface{} = h
  3398  	override, ok := asInterface.(interface {
  3399  		OverrideExtractResourceBodies(*SetUsersNameInAuth0Request) []*user.User
  3400  	})
  3401  	if ok {
  3402  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3403  	}
  3404  	return nil
  3405  }
  3406  
  3407  func (h *SetUsersNameInAuth0DescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  3408  	typedMsg := msg.(*emptypb.Empty)
  3409  	var asInterface interface{} = h
  3410  	override, ok := asInterface.(interface {
  3411  		OverrideExtractResourceName(*emptypb.Empty) *user.Name
  3412  	})
  3413  	if ok {
  3414  		return override.OverrideExtractResourceName(typedMsg)
  3415  	}
  3416  	return nil
  3417  }
  3418  
  3419  func (h *SetUsersNameInAuth0DescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  3420  	typedMsg := msg.(*emptypb.Empty)
  3421  	var asInterface interface{} = h
  3422  	override, ok := asInterface.(interface {
  3423  		OverrideExtractResourceNames(*emptypb.Empty) []*user.Name
  3424  	})
  3425  	if ok {
  3426  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  3427  	}
  3428  	return nil
  3429  }
  3430  
  3431  func (h *SetUsersNameInAuth0DescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  3432  	return nil
  3433  }
  3434  
  3435  func (h *SetUsersNameInAuth0DescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  3436  	typedMsg := msg.(*emptypb.Empty)
  3437  	var asInterface interface{} = h
  3438  	override, ok := asInterface.(interface {
  3439  		OverrideExtractResourceBody(*emptypb.Empty) *user.User
  3440  	})
  3441  	if ok {
  3442  		return override.OverrideExtractResourceBody(typedMsg)
  3443  	}
  3444  	return nil
  3445  }
  3446  
  3447  func (h *SetUsersNameInAuth0DescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3448  	typedMsg := msg.(*emptypb.Empty)
  3449  	var asInterface interface{} = h
  3450  	override, ok := asInterface.(interface {
  3451  		OverrideExtractResourceBodies(*emptypb.Empty) []*user.User
  3452  	})
  3453  	if ok {
  3454  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3455  	}
  3456  	return nil
  3457  }
  3458  
  3459  func GetSetUsersNameInAuth0Descriptor() *SetUsersNameInAuth0Descriptor {
  3460  	return setUsersNameInAuth0Descriptor
  3461  }
  3462  
  3463  type DeleteUsersByCriteriaDescriptor struct{}
  3464  
  3465  type DeleteUsersByCriteriaDescriptorClientMsgHandle struct{}
  3466  
  3467  type DeleteUsersByCriteriaDescriptorServerMsgHandle struct{}
  3468  
  3469  func (d *DeleteUsersByCriteriaDescriptor) NewEmptyClientMsg() proto.Message {
  3470  	return &DeleteUsersByCriteriaRequest{}
  3471  }
  3472  
  3473  func (d *DeleteUsersByCriteriaDescriptor) NewEmptyServerMsg() proto.Message {
  3474  	return &DeleteUsersByCriteriaResponse{}
  3475  }
  3476  
  3477  func (d *DeleteUsersByCriteriaDescriptor) IsUnary() bool {
  3478  	return true
  3479  }
  3480  
  3481  func (d *DeleteUsersByCriteriaDescriptor) IsClientStream() bool {
  3482  	return false
  3483  }
  3484  
  3485  func (d *DeleteUsersByCriteriaDescriptor) IsServerStream() bool {
  3486  	return false
  3487  }
  3488  
  3489  func (d *DeleteUsersByCriteriaDescriptor) IsCollection() bool {
  3490  	return false
  3491  }
  3492  
  3493  func (d *DeleteUsersByCriteriaDescriptor) IsPlural() bool {
  3494  	return false
  3495  }
  3496  
  3497  func (d *DeleteUsersByCriteriaDescriptor) HasResource() bool {
  3498  	return true
  3499  }
  3500  
  3501  func (d *DeleteUsersByCriteriaDescriptor) RequestHasResourceBody() bool {
  3502  	return false
  3503  }
  3504  
  3505  func (d *DeleteUsersByCriteriaDescriptor) GetVerb() string {
  3506  	return "deleteUsersByCriteria"
  3507  }
  3508  
  3509  func (d *DeleteUsersByCriteriaDescriptor) GetMethodName() string {
  3510  	return "DeleteUsersByCriteria"
  3511  }
  3512  
  3513  func (d *DeleteUsersByCriteriaDescriptor) GetFullMethodName() string {
  3514  	return "/ntt.iam.v1.UserService/DeleteUsersByCriteria"
  3515  }
  3516  
  3517  func (d *DeleteUsersByCriteriaDescriptor) GetProtoPkgName() string {
  3518  	return "ntt.iam.v1"
  3519  }
  3520  
  3521  func (d *DeleteUsersByCriteriaDescriptor) GetApiName() string {
  3522  	return "UserService"
  3523  }
  3524  
  3525  func (d *DeleteUsersByCriteriaDescriptor) GetServiceDomain() string {
  3526  	return "iam.edgelq.com"
  3527  }
  3528  
  3529  func (d *DeleteUsersByCriteriaDescriptor) GetServiceVersion() string {
  3530  	return "v1"
  3531  }
  3532  
  3533  func (d *DeleteUsersByCriteriaDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
  3534  	return userServiceDescriptor
  3535  }
  3536  
  3537  func (d *DeleteUsersByCriteriaDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
  3538  	return user.GetDescriptor()
  3539  }
  3540  
  3541  func (d *DeleteUsersByCriteriaDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
  3542  	return &DeleteUsersByCriteriaDescriptorClientMsgHandle{}
  3543  }
  3544  
  3545  func (d *DeleteUsersByCriteriaDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
  3546  	return &DeleteUsersByCriteriaDescriptorServerMsgHandle{}
  3547  }
  3548  
  3549  func (h *DeleteUsersByCriteriaDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  3550  	typedMsg := msg.(*DeleteUsersByCriteriaRequest)
  3551  	var asInterface interface{} = h
  3552  	override, ok := asInterface.(interface {
  3553  		OverrideExtractResourceName(*DeleteUsersByCriteriaRequest) *user.Name
  3554  	})
  3555  	if ok {
  3556  		return override.OverrideExtractResourceName(typedMsg)
  3557  	}
  3558  	return nil
  3559  }
  3560  
  3561  func (h *DeleteUsersByCriteriaDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  3562  	typedMsg := msg.(*DeleteUsersByCriteriaRequest)
  3563  	var asInterface interface{} = h
  3564  	override, ok := asInterface.(interface {
  3565  		OverrideExtractResourceNames(*DeleteUsersByCriteriaRequest) []*user.Name
  3566  	})
  3567  	if ok {
  3568  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  3569  	}
  3570  	return nil
  3571  }
  3572  
  3573  func (h *DeleteUsersByCriteriaDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  3574  	return nil
  3575  }
  3576  
  3577  func (h *DeleteUsersByCriteriaDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  3578  	typedMsg := msg.(*DeleteUsersByCriteriaRequest)
  3579  	var asInterface interface{} = h
  3580  	override, ok := asInterface.(interface {
  3581  		OverrideExtractResourceBody(*DeleteUsersByCriteriaRequest) *user.User
  3582  	})
  3583  	if ok {
  3584  		return override.OverrideExtractResourceBody(typedMsg)
  3585  	}
  3586  	return nil
  3587  }
  3588  
  3589  func (h *DeleteUsersByCriteriaDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3590  	typedMsg := msg.(*DeleteUsersByCriteriaRequest)
  3591  	var asInterface interface{} = h
  3592  	override, ok := asInterface.(interface {
  3593  		OverrideExtractResourceBodies(*DeleteUsersByCriteriaRequest) []*user.User
  3594  	})
  3595  	if ok {
  3596  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3597  	}
  3598  	return nil
  3599  }
  3600  
  3601  func (h *DeleteUsersByCriteriaDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
  3602  	typedMsg := msg.(*DeleteUsersByCriteriaResponse)
  3603  	var asInterface interface{} = h
  3604  	override, ok := asInterface.(interface {
  3605  		OverrideExtractResourceName(*DeleteUsersByCriteriaResponse) *user.Name
  3606  	})
  3607  	if ok {
  3608  		return override.OverrideExtractResourceName(typedMsg)
  3609  	}
  3610  	return nil
  3611  }
  3612  
  3613  func (h *DeleteUsersByCriteriaDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
  3614  	typedMsg := msg.(*DeleteUsersByCriteriaResponse)
  3615  	var asInterface interface{} = h
  3616  	override, ok := asInterface.(interface {
  3617  		OverrideExtractResourceNames(*DeleteUsersByCriteriaResponse) []*user.Name
  3618  	})
  3619  	if ok {
  3620  		return user.UserNameList(override.OverrideExtractResourceNames(typedMsg))
  3621  	}
  3622  	return nil
  3623  }
  3624  
  3625  func (h *DeleteUsersByCriteriaDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
  3626  	return nil
  3627  }
  3628  
  3629  func (h *DeleteUsersByCriteriaDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
  3630  	typedMsg := msg.(*DeleteUsersByCriteriaResponse)
  3631  	var asInterface interface{} = h
  3632  	override, ok := asInterface.(interface {
  3633  		OverrideExtractResourceBody(*DeleteUsersByCriteriaResponse) *user.User
  3634  	})
  3635  	if ok {
  3636  		return override.OverrideExtractResourceBody(typedMsg)
  3637  	}
  3638  	return nil
  3639  }
  3640  
  3641  func (h *DeleteUsersByCriteriaDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
  3642  	typedMsg := msg.(*DeleteUsersByCriteriaResponse)
  3643  	var asInterface interface{} = h
  3644  	override, ok := asInterface.(interface {
  3645  		OverrideExtractResourceBodies(*DeleteUsersByCriteriaResponse) []*user.User
  3646  	})
  3647  	if ok {
  3648  		return user.UserList(override.OverrideExtractResourceBodies(typedMsg))
  3649  	}
  3650  	return nil
  3651  }
  3652  
  3653  func GetDeleteUsersByCriteriaDescriptor() *DeleteUsersByCriteriaDescriptor {
  3654  	return deleteUsersByCriteriaDescriptor
  3655  }
  3656  
  3657  type UserServiceDescriptor struct{}
  3658  
  3659  func (d *UserServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
  3660  	return []gotenclient.MethodDescriptor{
  3661  		getUserDescriptor,
  3662  		batchGetUsersDescriptor,
  3663  		listUsersDescriptor,
  3664  		watchUserDescriptor,
  3665  		watchUsersDescriptor,
  3666  		createUserDescriptor,
  3667  		updateUserDescriptor,
  3668  		deleteUserDescriptor,
  3669  		getUserByEmailDescriptor,
  3670  		batchGetUsersByEmailDescriptor,
  3671  		getMySettingsDescriptor,
  3672  		setMySettingsDescriptor,
  3673  		refreshUserFromIdTokenDescriptor,
  3674  		resendVerificationEmailDescriptor,
  3675  		isUserVerifiedDescriptor,
  3676  		resetMFAIfRecoveryKeyUsedDescriptor,
  3677  		setUsersNameInAuth0Descriptor,
  3678  		deleteUsersByCriteriaDescriptor,
  3679  	}
  3680  }
  3681  
  3682  func (d *UserServiceDescriptor) GetFullAPIName() string {
  3683  	return "/ntt.iam.v1.UserService"
  3684  }
  3685  
  3686  func (d *UserServiceDescriptor) GetProtoPkgName() string {
  3687  	return "ntt.iam.v1"
  3688  }
  3689  
  3690  func (d *UserServiceDescriptor) GetApiName() string {
  3691  	return "UserService"
  3692  }
  3693  
  3694  func (d *UserServiceDescriptor) GetServiceDomain() string {
  3695  	return "iam.edgelq.com"
  3696  }
  3697  
  3698  func (d *UserServiceDescriptor) GetServiceVersion() string {
  3699  	return "v1"
  3700  }
  3701  
  3702  func GetUserServiceDescriptor() *UserServiceDescriptor {
  3703  	return userServiceDescriptor
  3704  }
  3705  
  3706  func initDescriptors() {
  3707  	userServiceDescriptor = &UserServiceDescriptor{}
  3708  	getUserDescriptor = &GetUserDescriptor{}
  3709  	batchGetUsersDescriptor = &BatchGetUsersDescriptor{}
  3710  	listUsersDescriptor = &ListUsersDescriptor{}
  3711  	watchUserDescriptor = &WatchUserDescriptor{}
  3712  	watchUsersDescriptor = &WatchUsersDescriptor{}
  3713  	createUserDescriptor = &CreateUserDescriptor{}
  3714  	updateUserDescriptor = &UpdateUserDescriptor{}
  3715  	deleteUserDescriptor = &DeleteUserDescriptor{}
  3716  	getUserByEmailDescriptor = &GetUserByEmailDescriptor{}
  3717  	batchGetUsersByEmailDescriptor = &BatchGetUsersByEmailDescriptor{}
  3718  	getMySettingsDescriptor = &GetMySettingsDescriptor{}
  3719  	setMySettingsDescriptor = &SetMySettingsDescriptor{}
  3720  	refreshUserFromIdTokenDescriptor = &RefreshUserFromIdTokenDescriptor{}
  3721  	resendVerificationEmailDescriptor = &ResendVerificationEmailDescriptor{}
  3722  	isUserVerifiedDescriptor = &IsUserVerifiedDescriptor{}
  3723  	resetMFAIfRecoveryKeyUsedDescriptor = &ResetMFAIfRecoveryKeyUsedDescriptor{}
  3724  	setUsersNameInAuth0Descriptor = &SetUsersNameInAuth0Descriptor{}
  3725  	deleteUsersByCriteriaDescriptor = &DeleteUsersByCriteriaDescriptor{}
  3726  	gotenclient.GetRegistry().RegisterApiDescriptor(userServiceDescriptor)
  3727  	gotenclient.GetRegistry().RegisterMethodDescriptor(getUserDescriptor)
  3728  	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetUsersDescriptor)
  3729  	gotenclient.GetRegistry().RegisterMethodDescriptor(listUsersDescriptor)
  3730  	gotenclient.GetRegistry().RegisterMethodDescriptor(watchUserDescriptor)
  3731  	gotenclient.GetRegistry().RegisterMethodDescriptor(watchUsersDescriptor)
  3732  	gotenclient.GetRegistry().RegisterMethodDescriptor(createUserDescriptor)
  3733  	gotenclient.GetRegistry().RegisterMethodDescriptor(updateUserDescriptor)
  3734  	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteUserDescriptor)
  3735  	gotenclient.GetRegistry().RegisterMethodDescriptor(getUserByEmailDescriptor)
  3736  	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetUsersByEmailDescriptor)
  3737  	gotenclient.GetRegistry().RegisterMethodDescriptor(getMySettingsDescriptor)
  3738  	gotenclient.GetRegistry().RegisterMethodDescriptor(setMySettingsDescriptor)
  3739  	gotenclient.GetRegistry().RegisterMethodDescriptor(refreshUserFromIdTokenDescriptor)
  3740  	gotenclient.GetRegistry().RegisterMethodDescriptor(resendVerificationEmailDescriptor)
  3741  	gotenclient.GetRegistry().RegisterMethodDescriptor(isUserVerifiedDescriptor)
  3742  	gotenclient.GetRegistry().RegisterMethodDescriptor(resetMFAIfRecoveryKeyUsedDescriptor)
  3743  	gotenclient.GetRegistry().RegisterMethodDescriptor(setUsersNameInAuth0Descriptor)
  3744  	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteUsersByCriteriaDescriptor)
  3745  }
  3746  
  3747  func init() {
  3748  	if !descriptorsInitialized {
  3749  		initDescriptors()
  3750  		descriptorsInitialized = true
  3751  	}
  3752  }