github.com/cloudwan/edgelq-sdk@v1.15.4/iam/client/v1alpha2/role/role_service.pb.descriptors.go (about)

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