// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/user/v1/keyapis_user_user_v1.proto

// This CPP symbol can be defined to use imports that match up to the framework
// imports needed when using CocoaPods.
#if !defined(GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS)
 #define GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS 0
#endif

#if GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS
 #import <Protobuf/GPBProtocolBuffers_RuntimeSupport.h>
#else
 #import "GPBProtocolBuffers_RuntimeSupport.h"
#endif

#if GOOGLE_PROTOBUF_OBJC_VERSION < 30007
#error This file was generated by a newer version of protoc which is incompatible with your Protocol Buffer library sources.
#endif
#if 30007 < GOOGLE_PROTOBUF_OBJC_MIN_SUPPORTED_VERSION
#error This file was generated by an older version of protoc which is incompatible with your Protocol Buffer library sources.
#endif

#import <stdatomic.h>

#import "keyapis/user/v1/KeyapisUserUserV1.pbobjc.h"
#import "google/api/Visibility.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.pbobjc.h"
#import "google/protobuf/Descriptor.pbobjc.h"
// @@protoc_insertion_point(imports)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#pragma clang diagnostic ignored "-Wdirect-ivar-access"
#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"

#pragma mark - Objective-C Class declarations
// Forward declarations of Objective-C classes that we can use as
// static values in struct initializers.
// We don't use [Foo class] because it is not a static value.
GPBObjCClassDeclaration(GPBInt32Value);
GPBObjCClassDeclaration(GPBStringValue);
GPBObjCClassDeclaration(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISUSERV1DeleteUserRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1DeleteUserResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1DeleteUserResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1DeleteUserSessionsRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1DeleteUserSessionsResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1DeleteUserSessionsResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserCodeRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserCodeResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserCodeResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserCountRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserCountResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserCountResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserListRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserListResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserListResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1GetUserResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1PatchUserRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1PatchUserResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1PatchUserResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCleanSsoDataRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCleanSsoDataResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCodeCreateRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCodeCreateResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserCodeCreateResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserRequest);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserResponse);
GPBObjCClassDeclaration(KEYAPISUSERV1PostUserResponse_Error);
GPBObjCClassDeclaration(KEYAPISUSERV1User);
GPBObjCClassDeclaration(KEYAPISUSERV1UserCode);
GPBObjCClassDeclaration(KEYAPISUSERV1UserFilter);
GPBObjCClassDeclaration(KEYAPISUSERV1UserPaging);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_Conflict);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_EntityNotFound);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_UserStatusForbidden);
GPBObjCClassDeclaration(KEYAPISUSERV1User_SavingError_UserTypeForbidden);
GPBObjCClassDeclaration(KEYAPISUSERV1ValidationError);

#pragma mark - KEYAPISUSERV1KeyapisUserUserV1Root

@implementation KEYAPISUSERV1KeyapisUserUserV1Root

+ (GPBExtensionRegistry*)extensionRegistry {
  // This is called by +initialize so there is no need to worry
  // about thread safety and initialization of registry.
  static GPBExtensionRegistry* registry = nil;
  if (!registry) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    registry = [[GPBExtensionRegistry alloc] init];
    // Merge in the imports (direct or indirect) that defined extensions.
    [registry addExtensions:[GAPIAnnotationsRoot extensionRegistry]];
    [registry addExtensions:[GAPIFieldBehaviorRoot extensionRegistry]];
    [registry addExtensions:[GAPIVisibilityRoot extensionRegistry]];
  }
  return registry;
}

@end

static GPBFileDescription KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription = {
  .package = "keyapis.user.v1",
  .prefix = "KEYAPISUSERV1",
  .syntax = GPBFileSyntaxProto3
};

#pragma mark - Enum KEYAPISUSERV1User_Type

GPBEnumDescriptor *KEYAPISUSERV1User_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000Owner\000Employee\000Master\000Slave\000"
        "Admin\000Seller\000Mrf\000Backoffice\000Service\000Root"
        "\000Bti\000LtpFirst\000ExternalSeller\000Application"
        "\000Manager\000DeviceAdmin\000";
    static const int32_t values[] = {
        KEYAPISUSERV1User_Type_TypeUnknown,
        KEYAPISUSERV1User_Type_Owner,
        KEYAPISUSERV1User_Type_Employee,
        KEYAPISUSERV1User_Type_Master,
        KEYAPISUSERV1User_Type_Slave,
        KEYAPISUSERV1User_Type_Admin,
        KEYAPISUSERV1User_Type_Seller,
        KEYAPISUSERV1User_Type_Mrf,
        KEYAPISUSERV1User_Type_Backoffice,
        KEYAPISUSERV1User_Type_Service,
        KEYAPISUSERV1User_Type_Root,
        KEYAPISUSERV1User_Type_Bti,
        KEYAPISUSERV1User_Type_LtpFirst,
        KEYAPISUSERV1User_Type_ExternalSeller,
        KEYAPISUSERV1User_Type_Application,
        KEYAPISUSERV1User_Type_Manager,
        KEYAPISUSERV1User_Type_DeviceAdmin,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISUSERV1User_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISUSERV1User_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISUSERV1User_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISUSERV1User_Type_TypeUnknown:
    case KEYAPISUSERV1User_Type_Owner:
    case KEYAPISUSERV1User_Type_Employee:
    case KEYAPISUSERV1User_Type_Master:
    case KEYAPISUSERV1User_Type_Slave:
    case KEYAPISUSERV1User_Type_Admin:
    case KEYAPISUSERV1User_Type_Seller:
    case KEYAPISUSERV1User_Type_Mrf:
    case KEYAPISUSERV1User_Type_Backoffice:
    case KEYAPISUSERV1User_Type_Service:
    case KEYAPISUSERV1User_Type_Root:
    case KEYAPISUSERV1User_Type_Bti:
    case KEYAPISUSERV1User_Type_LtpFirst:
    case KEYAPISUSERV1User_Type_ExternalSeller:
    case KEYAPISUSERV1User_Type_Application:
    case KEYAPISUSERV1User_Type_Manager:
    case KEYAPISUSERV1User_Type_DeviceAdmin:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISUSERV1User_StatusType

GPBEnumDescriptor *KEYAPISUSERV1User_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000New\000Demo\000Active\000Blocke"
        "d\000";
    static const int32_t values[] = {
        KEYAPISUSERV1User_StatusType_StatusTypeUnknown,
        KEYAPISUSERV1User_StatusType_New,
        KEYAPISUSERV1User_StatusType_Demo,
        KEYAPISUSERV1User_StatusType_Active,
        KEYAPISUSERV1User_StatusType_Blocked,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISUSERV1User_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISUSERV1User_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISUSERV1User_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISUSERV1User_StatusType_StatusTypeUnknown:
    case KEYAPISUSERV1User_StatusType_New:
    case KEYAPISUSERV1User_StatusType_Demo:
    case KEYAPISUSERV1User_StatusType_Active:
    case KEYAPISUSERV1User_StatusType_Blocked:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISUSERV1UserPaging_OrderByType

GPBEnumDescriptor *KEYAPISUSERV1UserPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Id\000CreatedAt\000ChangedA"
        "t\000Email\000Rank\000Description\000";
    static const int32_t values[] = {
        KEYAPISUSERV1UserPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISUSERV1UserPaging_OrderByType_Id,
        KEYAPISUSERV1UserPaging_OrderByType_CreatedAt,
        KEYAPISUSERV1UserPaging_OrderByType_ChangedAt,
        KEYAPISUSERV1UserPaging_OrderByType_Email,
        KEYAPISUSERV1UserPaging_OrderByType_Rank,
        KEYAPISUSERV1UserPaging_OrderByType_Description,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISUSERV1UserPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISUSERV1UserPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISUSERV1UserPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISUSERV1UserPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISUSERV1UserPaging_OrderByType_Id:
    case KEYAPISUSERV1UserPaging_OrderByType_CreatedAt:
    case KEYAPISUSERV1UserPaging_OrderByType_ChangedAt:
    case KEYAPISUSERV1UserPaging_OrderByType_Email:
    case KEYAPISUSERV1UserPaging_OrderByType_Rank:
    case KEYAPISUSERV1UserPaging_OrderByType_Description:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISUSERV1UserPaging_DirectionType

GPBEnumDescriptor *KEYAPISUSERV1UserPaging_DirectionType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "DirectionTypeUnknown\000Desc\000Asc\000";
    static const int32_t values[] = {
        KEYAPISUSERV1UserPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISUSERV1UserPaging_DirectionType_Desc,
        KEYAPISUSERV1UserPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISUSERV1UserPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISUSERV1UserPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISUSERV1UserPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISUSERV1UserPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISUSERV1UserPaging_DirectionType_Desc:
    case KEYAPISUSERV1UserPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISUSERV1DeleteUserSessionsRequest

@implementation KEYAPISUSERV1DeleteUserSessionsRequest

@dynamic id_p;

typedef struct KEYAPISUSERV1DeleteUserSessionsRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISUSERV1DeleteUserSessionsRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1DeleteUserSessionsRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1DeleteUserSessionsRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1DeleteUserSessionsRequest)
                                   messageName:@"DeleteUserSessionsRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1DeleteUserSessionsRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1DeleteUserSessionsResponse

@implementation KEYAPISUSERV1DeleteUserSessionsResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISUSERV1DeleteUserSessionsResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1DeleteUserSessionsResponse_Error *error;
} KEYAPISUSERV1DeleteUserSessionsResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1DeleteUserSessionsResponse_Error),
        .number = KEYAPISUSERV1DeleteUserSessionsResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1DeleteUserSessionsResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1DeleteUserSessionsResponse)
                                   messageName:@"DeleteUserSessionsResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1DeleteUserSessionsResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1DeleteUserSessionsResponse_ClearTypeOneOfCase(KEYAPISUSERV1DeleteUserSessionsResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1DeleteUserSessionsResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1DeleteUserSessionsResponse_Error

@implementation KEYAPISUSERV1DeleteUserSessionsResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISUSERV1DeleteUserSessionsResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
} KEYAPISUSERV1DeleteUserSessionsResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1DeleteUserSessionsResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1DeleteUserSessionsResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1DeleteUserSessionsResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1DeleteUserSessionsResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1DeleteUserSessionsResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1DeleteUserSessionsResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1DeleteUserSessionsResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1DeleteUserSessionsResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1User

@implementation KEYAPISUSERV1User

@dynamic id_p;
@dynamic type;
@dynamic statusType;
@dynamic hasLogin, login;
@dynamic hasEmail, email;
@dynamic hasPhoneNumber, phoneNumber;
@dynamic hasCompanyId, companyId;
@dynamic hasMrfId, mrfId;
@dynamic hasRfId, rfId;
@dynamic hasCreatedAt, createdAt;
@dynamic hasChangedAt, changedAt;
@dynamic hasActivatedAt, activatedAt;
@dynamic hasBlockedAt, blockedAt;
@dynamic hasCreatorUserId, creatorUserId;
@dynamic hasOwnerUserId, ownerUserId;
@dynamic hasInvoiceEmail, invoiceEmail;
@dynamic hasVcUserId, vcUserId;
@dynamic hasDescription_p, description_p;
@dynamic hasUstoreUserId, ustoreUserId;
@dynamic hasEnvURL, envURL;

typedef struct KEYAPISUSERV1User__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  KEYAPISUSERV1User_Type type;
  KEYAPISUSERV1User_StatusType statusType;
  GPBStringValue *login;
  GPBStringValue *email;
  GPBStringValue *phoneNumber;
  GPBInt32Value *companyId;
  GPBInt32Value *mrfId;
  GPBInt32Value *rfId;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
  GPBTimestamp *activatedAt;
  GPBTimestamp *blockedAt;
  GPBInt32Value *creatorUserId;
  GPBInt32Value *ownerUserId;
  GPBStringValue *invoiceEmail;
  GPBInt32Value *vcUserId;
  GPBStringValue *description_p;
  GPBInt32Value *ustoreUserId;
  GPBStringValue *envURL;
} KEYAPISUSERV1User__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1User_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISUSERV1User_Type_EnumDescriptor,
        .number = KEYAPISUSERV1User_FieldNumber_Type,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISUSERV1User_StatusType_EnumDescriptor,
        .number = KEYAPISUSERV1User_FieldNumber_StatusType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "login",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1User_FieldNumber_Login,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, login),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "email",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1User_FieldNumber_Email,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, email),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "phoneNumber",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1User_FieldNumber_PhoneNumber,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, phoneNumber),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "companyId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISUSERV1User_FieldNumber_CompanyId,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, companyId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "mrfId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISUSERV1User_FieldNumber_MrfId,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, mrfId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "rfId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISUSERV1User_FieldNumber_RfId,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, rfId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISUSERV1User_FieldNumber_CreatedAt,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISUSERV1User_FieldNumber_ChangedAt,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "activatedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISUSERV1User_FieldNumber_ActivatedAt,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, activatedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "blockedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISUSERV1User_FieldNumber_BlockedAt,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, blockedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "creatorUserId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISUSERV1User_FieldNumber_CreatorUserId,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, creatorUserId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "ownerUserId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISUSERV1User_FieldNumber_OwnerUserId,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, ownerUserId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "invoiceEmail",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1User_FieldNumber_InvoiceEmail,
        .hasIndex = 15,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, invoiceEmail),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "vcUserId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISUSERV1User_FieldNumber_VcUserId,
        .hasIndex = 16,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, vcUserId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "description_p",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1User_FieldNumber_Description_p,
        .hasIndex = 17,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, description_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "ustoreUserId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISUSERV1User_FieldNumber_UstoreUserId,
        .hasIndex = 18,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, ustoreUserId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "envURL",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1User_FieldNumber_EnvURL,
        .hasIndex = 19,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User__storage_, envURL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User)
                                   messageName:@"User"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1User__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\024\003\241!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISUSERV1User_Type_RawValue(KEYAPISUSERV1User *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1User descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1User_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISUSERV1User_Type_RawValue(KEYAPISUSERV1User *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1User descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1User_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISUSERV1User_StatusType_RawValue(KEYAPISUSERV1User *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1User descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1User_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISUSERV1User_StatusType_RawValue(KEYAPISUSERV1User *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1User descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1User_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISUSERV1User_SavingError

@implementation KEYAPISUSERV1User_SavingError

@dynamic reasonOneOfCase;
@dynamic conflict;
@dynamic userTypeForbidden;
@dynamic userStatusForbidden;
@dynamic mrfIdIsRequiredForUserType;
@dynamic creatorMustBeAdmin;
@dynamic rfIdDoesNotMatchMrfId;
@dynamic emailIsAlreadyTaken;
@dynamic entityNotFound;

typedef struct KEYAPISUSERV1User_SavingError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1User_SavingError_Conflict *conflict;
  KEYAPISUSERV1User_SavingError_UserTypeForbidden *userTypeForbidden;
  KEYAPISUSERV1User_SavingError_UserStatusForbidden *userStatusForbidden;
  KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType *mrfIdIsRequiredForUserType;
  KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin *creatorMustBeAdmin;
  KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId *rfIdDoesNotMatchMrfId;
  KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken *emailIsAlreadyTaken;
  KEYAPISUSERV1User_SavingError_EntityNotFound *entityNotFound;
} KEYAPISUSERV1User_SavingError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "conflict",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_Conflict),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_Conflict,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, conflict),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userTypeForbidden",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_UserTypeForbidden),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_UserTypeForbidden,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, userTypeForbidden),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userStatusForbidden",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_UserStatusForbidden),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_UserStatusForbidden,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, userStatusForbidden),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "mrfIdIsRequiredForUserType",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_MrfIdIsRequiredForUserType,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, mrfIdIsRequiredForUserType),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "creatorMustBeAdmin",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_CreatorMustBeAdmin,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, creatorMustBeAdmin),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "rfIdDoesNotMatchMrfId",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_RfIdDoesNotMatchMrfId,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, rfIdDoesNotMatchMrfId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "emailIsAlreadyTaken",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_EmailIsAlreadyTaken,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, emailIsAlreadyTaken),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "entityNotFound",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError_EntityNotFound),
        .number = KEYAPISUSERV1User_SavingError_FieldNumber_EntityNotFound,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError__storage_, entityNotFound),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)
                                   messageName:@"SavingError"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1User_SavingError_ClearReasonOneOfCase(KEYAPISUSERV1User_SavingError *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1User_SavingError descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1User_SavingError_Conflict

@implementation KEYAPISUSERV1User_SavingError_Conflict


typedef struct KEYAPISUSERV1User_SavingError_Conflict__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1User_SavingError_Conflict__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_Conflict)
                                   messageName:@"Conflict"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_Conflict__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1User_SavingError_UserTypeForbidden

@implementation KEYAPISUSERV1User_SavingError_UserTypeForbidden


typedef struct KEYAPISUSERV1User_SavingError_UserTypeForbidden__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1User_SavingError_UserTypeForbidden__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_UserTypeForbidden)
                                   messageName:@"UserTypeForbidden"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_UserTypeForbidden__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1User_SavingError_UserStatusForbidden

@implementation KEYAPISUSERV1User_SavingError_UserStatusForbidden


typedef struct KEYAPISUSERV1User_SavingError_UserStatusForbidden__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1User_SavingError_UserStatusForbidden__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_UserStatusForbidden)
                                   messageName:@"UserStatusForbidden"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_UserStatusForbidden__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType

@implementation KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType


typedef struct KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType)
                                   messageName:@"MrfIdRequiredForUserType"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_MrfIdRequiredForUserType__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin

@implementation KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin


typedef struct KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin)
                                   messageName:@"CreatorMustBeAdmin"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_CreatorMustBeAdmin__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId

@implementation KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId


typedef struct KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId)
                                   messageName:@"RfIdDoesNotMatchMrfId"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_RfIdDoesNotMatchMrfId__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken

@implementation KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken


typedef struct KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken)
                                   messageName:@"EmailIsAlreadyTaken"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_EmailIsAlreadyTaken__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1User_SavingError_EntityNotFound

@implementation KEYAPISUSERV1User_SavingError_EntityNotFound

@dynamic field;

typedef struct KEYAPISUSERV1User_SavingError_EntityNotFound__storage_ {
  uint32_t _has_storage_[1];
  NSString *field;
} KEYAPISUSERV1User_SavingError_EntityNotFound__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "field",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1User_SavingError_EntityNotFound_FieldNumber_Field,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1User_SavingError_EntityNotFound__storage_, field),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1User_SavingError_EntityNotFound)
                                   messageName:@"EntityNotFound"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1User_SavingError_EntityNotFound__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1User_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1UserCode

@implementation KEYAPISUSERV1UserCode

@dynamic code;
@dynamic userId;
@dynamic hasCreatedAt, createdAt;
@dynamic creatorUserId;
@dynamic creatorUserType;

typedef struct KEYAPISUSERV1UserCode__storage_ {
  uint32_t _has_storage_[1];
  int32_t code;
  int32_t userId;
  int32_t creatorUserId;
  KEYAPISUSERV1User_Type creatorUserType;
  GPBTimestamp *createdAt;
} KEYAPISUSERV1UserCode__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "code",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserCode_FieldNumber_Code,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserCode__storage_, code),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "userId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserCode_FieldNumber_UserId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserCode__storage_, userId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISUSERV1UserCode_FieldNumber_CreatedAt,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserCode__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "creatorUserId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserCode_FieldNumber_CreatorUserId,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserCode__storage_, creatorUserId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "creatorUserType",
        .dataTypeSpecific.enumDescFunc = KEYAPISUSERV1User_Type_EnumDescriptor,
        .number = KEYAPISUSERV1UserCode_FieldNumber_CreatorUserType,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserCode__storage_, creatorUserType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1UserCode)
                                   messageName:@"UserCode"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1UserCode__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISUSERV1UserCode_CreatorUserType_RawValue(KEYAPISUSERV1UserCode *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1UserCode descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1UserCode_FieldNumber_CreatorUserType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISUSERV1UserCode_CreatorUserType_RawValue(KEYAPISUSERV1UserCode *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1UserCode descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1UserCode_FieldNumber_CreatorUserType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISUSERV1GetUserRequest

@implementation KEYAPISUSERV1GetUserRequest

@dynamic id_p;

typedef struct KEYAPISUSERV1GetUserRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISUSERV1GetUserRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1GetUserRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserRequest)
                                   messageName:@"GetUserRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1GetUserResponse

@implementation KEYAPISUSERV1GetUserResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISUSERV1GetUserResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1User *data_p;
  KEYAPISUSERV1GetUserResponse_Error *error;
} KEYAPISUSERV1GetUserResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User),
        .number = KEYAPISUSERV1GetUserResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1GetUserResponse_Error),
        .number = KEYAPISUSERV1GetUserResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserResponse)
                                   messageName:@"GetUserResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserResponse_ClearTypeOneOfCase(KEYAPISUSERV1GetUserResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserResponse_Error

@implementation KEYAPISUSERV1GetUserResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISUSERV1GetUserResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
} KEYAPISUSERV1GetUserResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1GetUserResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1GetUserResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1GetUserResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserListRequest

@implementation KEYAPISUSERV1GetUserListRequest

@dynamic paginationOneOfCase;
@dynamic hasFilter, filter;
@dynamic paging;

typedef struct KEYAPISUSERV1GetUserListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1UserFilter *filter;
  KEYAPISUSERV1UserPaging *paging;
} KEYAPISUSERV1GetUserListRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1UserFilter),
        .number = KEYAPISUSERV1GetUserListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1UserPaging),
        .number = KEYAPISUSERV1GetUserListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserListRequest)
                                   messageName:@"GetUserListRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserListRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "pagination",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserListRequest_ClearPaginationOneOfCase(KEYAPISUSERV1GetUserListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserListResponse

@implementation KEYAPISUSERV1GetUserListResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISUSERV1GetUserListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1User *data_p;
  KEYAPISUSERV1GetUserListResponse_Error *error;
} KEYAPISUSERV1GetUserListResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User),
        .number = KEYAPISUSERV1GetUserListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1GetUserListResponse_Error),
        .number = KEYAPISUSERV1GetUserListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserListResponse)
                                   messageName:@"GetUserListResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserListResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserListResponse_ClearTypeOneOfCase(KEYAPISUSERV1GetUserListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserListResponse_Error

@implementation KEYAPISUSERV1GetUserListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISUSERV1GetUserListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
} KEYAPISUSERV1GetUserListResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1GetUserListResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserListResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserListResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1GetUserListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserListResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1GetUserListResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserListResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserCountRequest

@implementation KEYAPISUSERV1GetUserCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISUSERV1GetUserCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISUSERV1UserFilter *filter;
} KEYAPISUSERV1GetUserCountRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1UserFilter),
        .number = KEYAPISUSERV1GetUserCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserCountRequest)
                                   messageName:@"GetUserCountRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserCountRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1GetUserCountResponse

@implementation KEYAPISUSERV1GetUserCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISUSERV1GetUserCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
  KEYAPISUSERV1GetUserCountResponse_Error *error;
} KEYAPISUSERV1GetUserCountResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1GetUserCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1GetUserCountResponse_Error),
        .number = KEYAPISUSERV1GetUserCountResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCountResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserCountResponse)
                                   messageName:@"GetUserCountResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserCountResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserCountResponse_ClearTypeOneOfCase(KEYAPISUSERV1GetUserCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserCountResponse_Error

@implementation KEYAPISUSERV1GetUserCountResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISUSERV1GetUserCountResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
} KEYAPISUSERV1GetUserCountResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1GetUserCountResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCountResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserCountResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserCountResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1GetUserCountResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserCountResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1GetUserCountResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserCountResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1DeleteUserRequest

@implementation KEYAPISUSERV1DeleteUserRequest

@dynamic id_p;

typedef struct KEYAPISUSERV1DeleteUserRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISUSERV1DeleteUserRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1DeleteUserRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1DeleteUserRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1DeleteUserRequest)
                                   messageName:@"DeleteUserRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1DeleteUserRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1DeleteUserResponse

@implementation KEYAPISUSERV1DeleteUserResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISUSERV1DeleteUserResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1DeleteUserResponse_Error *error;
} KEYAPISUSERV1DeleteUserResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1DeleteUserResponse_Error),
        .number = KEYAPISUSERV1DeleteUserResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1DeleteUserResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1DeleteUserResponse)
                                   messageName:@"DeleteUserResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1DeleteUserResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1DeleteUserResponse_ClearTypeOneOfCase(KEYAPISUSERV1DeleteUserResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1DeleteUserResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1DeleteUserResponse_Error

@implementation KEYAPISUSERV1DeleteUserResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic saving;

typedef struct KEYAPISUSERV1DeleteUserResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
  KEYAPISUSERV1User_SavingError *saving;
} KEYAPISUSERV1DeleteUserResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1DeleteUserResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1DeleteUserResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "saving",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError),
        .number = KEYAPISUSERV1DeleteUserResponse_Error_FieldNumber_Saving,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1DeleteUserResponse_Error__storage_, saving),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1DeleteUserResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1DeleteUserResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1DeleteUserResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1DeleteUserResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1DeleteUserResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1DeleteUserResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserCodeRequest

@implementation KEYAPISUSERV1GetUserCodeRequest

@dynamic id_p;

typedef struct KEYAPISUSERV1GetUserCodeRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISUSERV1GetUserCodeRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1GetUserCodeRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCodeRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserCodeRequest)
                                   messageName:@"GetUserCodeRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserCodeRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1GetUserCodeResponse

@implementation KEYAPISUSERV1GetUserCodeResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISUSERV1GetUserCodeResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1UserCode *data_p;
  KEYAPISUSERV1GetUserCodeResponse_Error *error;
} KEYAPISUSERV1GetUserCodeResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1UserCode),
        .number = KEYAPISUSERV1GetUserCodeResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCodeResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1GetUserCodeResponse_Error),
        .number = KEYAPISUSERV1GetUserCodeResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCodeResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserCodeResponse)
                                   messageName:@"GetUserCodeResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserCodeResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserCodeResponse_ClearTypeOneOfCase(KEYAPISUSERV1GetUserCodeResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserCodeResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserCodeResponse_Error

@implementation KEYAPISUSERV1GetUserCodeResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic userCodeNotFound;

typedef struct KEYAPISUSERV1GetUserCodeResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
  KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound *userCodeNotFound;
} KEYAPISUSERV1GetUserCodeResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1GetUserCodeResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCodeResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userCodeNotFound",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound),
        .number = KEYAPISUSERV1GetUserCodeResponse_Error_FieldNumber_UserCodeNotFound,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1GetUserCodeResponse_Error__storage_, userCodeNotFound),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserCodeResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1GetUserCodeResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1GetUserCodeResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1GetUserCodeResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1GetUserCodeResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1GetUserCodeResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound

@implementation KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound


typedef struct KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound)
                                   messageName:@"UserCodeNotFound"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1GetUserCodeResponse_Error_UserCodeNotFound__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1GetUserCodeResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1PostUserCodeCreateRequest

@implementation KEYAPISUSERV1PostUserCodeCreateRequest

@dynamic hasUserCode, userCode;

typedef struct KEYAPISUSERV1PostUserCodeCreateRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISUSERV1UserCode *userCode;
} KEYAPISUSERV1PostUserCodeCreateRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "userCode",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1UserCode),
        .number = KEYAPISUSERV1PostUserCodeCreateRequest_FieldNumber_UserCode,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCodeCreateRequest__storage_, userCode),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCodeCreateRequest)
                                   messageName:@"PostUserCodeCreateRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCodeCreateRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1PostUserCodeCreateResponse

@implementation KEYAPISUSERV1PostUserCodeCreateResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISUSERV1PostUserCodeCreateResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1UserCode *data_p;
  KEYAPISUSERV1PostUserCodeCreateResponse_Error *error;
} KEYAPISUSERV1PostUserCodeCreateResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1UserCode),
        .number = KEYAPISUSERV1PostUserCodeCreateResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCodeCreateResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1PostUserCodeCreateResponse_Error),
        .number = KEYAPISUSERV1PostUserCodeCreateResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCodeCreateResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCodeCreateResponse)
                                   messageName:@"PostUserCodeCreateResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCodeCreateResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PostUserCodeCreateResponse_ClearTypeOneOfCase(KEYAPISUSERV1PostUserCodeCreateResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PostUserCodeCreateResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1PostUserCodeCreateResponse_Error

@implementation KEYAPISUSERV1PostUserCodeCreateResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISUSERV1PostUserCodeCreateResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
} KEYAPISUSERV1PostUserCodeCreateResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1PostUserCodeCreateResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCodeCreateResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCodeCreateResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCodeCreateResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1PostUserCodeCreateResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PostUserCodeCreateResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1PostUserCodeCreateResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PostUserCodeCreateResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1PatchUserRequest

@implementation KEYAPISUSERV1PatchUserRequest

@dynamic id_p;
@dynamic hasPhoneNumber, phoneNumber;
@dynamic hasEmail, email;
@dynamic hasLogin, login;

typedef struct KEYAPISUSERV1PatchUserRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  GPBStringValue *phoneNumber;
  GPBStringValue *email;
  GPBStringValue *login;
} KEYAPISUSERV1PatchUserRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1PatchUserRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "phoneNumber",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1PatchUserRequest_FieldNumber_PhoneNumber,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserRequest__storage_, phoneNumber),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "email",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1PatchUserRequest_FieldNumber_Email,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserRequest__storage_, email),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "login",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1PatchUserRequest_FieldNumber_Login,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserRequest__storage_, login),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PatchUserRequest)
                                   messageName:@"PatchUserRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PatchUserRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1PatchUserResponse

@implementation KEYAPISUSERV1PatchUserResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISUSERV1PatchUserResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1User *data_p;
  KEYAPISUSERV1PatchUserResponse_Error *error;
} KEYAPISUSERV1PatchUserResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User),
        .number = KEYAPISUSERV1PatchUserResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1PatchUserResponse_Error),
        .number = KEYAPISUSERV1PatchUserResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PatchUserResponse)
                                   messageName:@"PatchUserResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PatchUserResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PatchUserResponse_ClearTypeOneOfCase(KEYAPISUSERV1PatchUserResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PatchUserResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1PatchUserResponse_Error

@implementation KEYAPISUSERV1PatchUserResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic userNotFoundError;

typedef struct KEYAPISUSERV1PatchUserResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
  KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError *userNotFoundError;
} KEYAPISUSERV1PatchUserResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1PatchUserResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userNotFoundError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError),
        .number = KEYAPISUSERV1PatchUserResponse_Error_FieldNumber_UserNotFoundError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PatchUserResponse_Error__storage_, userNotFoundError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PatchUserResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PatchUserResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1PatchUserResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PatchUserResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1PatchUserResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PatchUserResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError

@implementation KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError


typedef struct KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError)
                                   messageName:@"UserNotFoundError"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1PatchUserResponse_Error_UserNotFoundError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1PatchUserResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1UserFilter

@implementation KEYAPISUSERV1UserFilter

@dynamic companyIdsArray, companyIdsArray_Count;
@dynamic userTypesArray, userTypesArray_Count;
@dynamic userStatusTypesArray, userStatusTypesArray_Count;
@dynamic emailsArray, emailsArray_Count;
@dynamic phoneNumbersArray, phoneNumbersArray_Count;
@dynamic loginsArray, loginsArray_Count;
@dynamic hasText, text;
@dynamic hasContacts, contacts;
@dynamic ssoUserIdsArray, ssoUserIdsArray_Count;

typedef struct KEYAPISUSERV1UserFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBInt32Array *companyIdsArray;
  GPBEnumArray *userTypesArray;
  GPBEnumArray *userStatusTypesArray;
  NSMutableArray *emailsArray;
  NSMutableArray *phoneNumbersArray;
  NSMutableArray *loginsArray;
  GPBStringValue *text;
  GPBStringValue *contacts;
  GPBInt32Array *ssoUserIdsArray;
} KEYAPISUSERV1UserFilter__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "companyIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserFilter_FieldNumber_CompanyIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, companyIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "userTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISUSERV1User_Type_EnumDescriptor,
        .number = KEYAPISUSERV1UserFilter_FieldNumber_UserTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, userTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "userStatusTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISUSERV1User_StatusType_EnumDescriptor,
        .number = KEYAPISUSERV1UserFilter_FieldNumber_UserStatusTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, userStatusTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "emailsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserFilter_FieldNumber_EmailsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, emailsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "phoneNumbersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserFilter_FieldNumber_PhoneNumbersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, phoneNumbersArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "loginsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserFilter_FieldNumber_LoginsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, loginsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "text",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1UserFilter_FieldNumber_Text,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, text),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "contacts",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISUSERV1UserFilter_FieldNumber_Contacts,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, contacts),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "ssoUserIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserFilter_FieldNumber_SsoUserIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserFilter__storage_, ssoUserIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1UserFilter)
                                   messageName:@"UserFilter"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1UserFilter__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1UserPaging

@implementation KEYAPISUSERV1UserPaging

@dynamic orderByType;
@dynamic directionType;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISUSERV1UserPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISUSERV1UserPaging_OrderByType orderByType;
  KEYAPISUSERV1UserPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISUSERV1UserPaging__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "orderByType",
        .dataTypeSpecific.enumDescFunc = KEYAPISUSERV1UserPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISUSERV1UserPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISUSERV1UserPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISUSERV1UserPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1UserPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1UserPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1UserPaging)
                                   messageName:@"UserPaging"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1UserPaging__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISUSERV1UserPaging_OrderByType_RawValue(KEYAPISUSERV1UserPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1UserPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1UserPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISUSERV1UserPaging_OrderByType_RawValue(KEYAPISUSERV1UserPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1UserPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1UserPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISUSERV1UserPaging_DirectionType_RawValue(KEYAPISUSERV1UserPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1UserPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1UserPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISUSERV1UserPaging_DirectionType_RawValue(KEYAPISUSERV1UserPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1UserPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISUSERV1UserPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISUSERV1PostUserCleanSsoDataRequest

@implementation KEYAPISUSERV1PostUserCleanSsoDataRequest

@dynamic id_p;

typedef struct KEYAPISUSERV1PostUserCleanSsoDataRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISUSERV1PostUserCleanSsoDataRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1PostUserCleanSsoDataRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCleanSsoDataRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataRequest)
                                   messageName:@"PostUserCleanSsoDataRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCleanSsoDataRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1PostUserCleanSsoDataResponse

@implementation KEYAPISUSERV1PostUserCleanSsoDataResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISUSERV1PostUserCleanSsoDataResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1PostUserCleanSsoDataResponse_Error *error;
} KEYAPISUSERV1PostUserCleanSsoDataResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error),
        .number = KEYAPISUSERV1PostUserCleanSsoDataResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCleanSsoDataResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse)
                                   messageName:@"PostUserCleanSsoDataResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCleanSsoDataResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PostUserCleanSsoDataResponse_ClearTypeOneOfCase(KEYAPISUSERV1PostUserCleanSsoDataResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PostUserCleanSsoDataResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1PostUserCleanSsoDataResponse_Error

@implementation KEYAPISUSERV1PostUserCleanSsoDataResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic userTypeError;
@dynamic userNotFoundError;

typedef struct KEYAPISUSERV1PostUserCleanSsoDataResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
  KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError *userTypeError;
  KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError *userNotFoundError;
} KEYAPISUSERV1PostUserCleanSsoDataResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userTypeError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError),
        .number = KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_FieldNumber_UserTypeError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error__storage_, userTypeError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userNotFoundError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError),
        .number = KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_FieldNumber_UserNotFoundError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error__storage_, userNotFoundError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PostUserCleanSsoDataResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError

@implementation KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError


typedef struct KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError)
                                   messageName:@"UserTypeError"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserTypeError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError

@implementation KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError


typedef struct KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError)
                                   messageName:@"UserNotFoundError"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error_UserNotFoundError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1PostUserCleanSsoDataResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1PostUserRequest

@implementation KEYAPISUSERV1PostUserRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISUSERV1PostUserRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISUSERV1User *data_p;
} KEYAPISUSERV1PostUserRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User),
        .number = KEYAPISUSERV1PostUserRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserRequest)
                                   messageName:@"PostUserRequest"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISUSERV1PostUserResponse

@implementation KEYAPISUSERV1PostUserResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISUSERV1PostUserResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1User *data_p;
  KEYAPISUSERV1PostUserResponse_Error *error;
} KEYAPISUSERV1PostUserResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User),
        .number = KEYAPISUSERV1PostUserResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1PostUserResponse_Error),
        .number = KEYAPISUSERV1PostUserResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserResponse)
                                   messageName:@"PostUserResponse"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PostUserResponse_ClearTypeOneOfCase(KEYAPISUSERV1PostUserResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PostUserResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1PostUserResponse_Error

@implementation KEYAPISUSERV1PostUserResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic saving;

typedef struct KEYAPISUSERV1PostUserResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISUSERV1ValidationError *validation;
  KEYAPISUSERV1User_SavingError *saving;
} KEYAPISUSERV1PostUserResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1ValidationError),
        .number = KEYAPISUSERV1PostUserResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "saving",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISUSERV1User_SavingError),
        .number = KEYAPISUSERV1PostUserResponse_Error_FieldNumber_Saving,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1PostUserResponse_Error__storage_, saving),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1PostUserResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1PostUserResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISUSERV1PostUserResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISUSERV1PostUserResponse_Error_ClearReasonOneOfCase(KEYAPISUSERV1PostUserResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISUSERV1PostUserResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISUSERV1ValidationError

@implementation KEYAPISUSERV1ValidationError

@dynamic path;
@dynamic message;

typedef struct KEYAPISUSERV1ValidationError__storage_ {
  uint32_t _has_storage_[1];
  NSString *path;
  NSString *message;
} KEYAPISUSERV1ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISUSERV1ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISUSERV1ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISUSERV1ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISUSERV1KeyapisUserUserV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISUSERV1ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end


#pragma clang diagnostic pop

// @@protoc_insertion_point(global_scope)

// clang-format on
