// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/notification/v1/keyapis_notification_push_token_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/notification/v1/KeyapisNotificationPushTokenV1.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.pbobjc.h"
#import "google/protobuf/Descriptor.pbobjc.h"
#import "google/api/Visibility.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(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenRequest);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenResponse);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1GetPushTokenCountRequest);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1GetPushTokenListRequest);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1GetPushTokenListResponse);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PostPushTokenRequest);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PostPushTokenResponse);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushToken);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushTokenFilter);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushTokenPaging);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushToken_SavingError);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushToken_ValidationError);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid);
GPBObjCClassDeclaration(KEYAPISNOTIFICATIONV1ValidationError);

#pragma mark - KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root

@implementation KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root

+ (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 KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription = {
  .package = "keyapis.notification.v1",
  .prefix = "KEYAPISNOTIFICATIONV1",
  .syntax = GPBFileSyntaxProto3
};

#pragma mark - Enum KEYAPISNOTIFICATIONV1PushToken_Type

GPBEnumDescriptor *KEYAPISNOTIFICATIONV1PushToken_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000MobileFcm\000MobileHms\000MobileAp"
        "nsText\000MobileApnsCall\000PwaFcm\000PwaApns\000Mob"
        "ileRustore\000";
    static const int32_t values[] = {
        KEYAPISNOTIFICATIONV1PushToken_Type_TypeUnknown,
        KEYAPISNOTIFICATIONV1PushToken_Type_MobileFcm,
        KEYAPISNOTIFICATIONV1PushToken_Type_MobileHms,
        KEYAPISNOTIFICATIONV1PushToken_Type_MobileApnsText,
        KEYAPISNOTIFICATIONV1PushToken_Type_MobileApnsCall,
        KEYAPISNOTIFICATIONV1PushToken_Type_PwaFcm,
        KEYAPISNOTIFICATIONV1PushToken_Type_PwaApns,
        KEYAPISNOTIFICATIONV1PushToken_Type_MobileRustore,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISNOTIFICATIONV1PushToken_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISNOTIFICATIONV1PushToken_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISNOTIFICATIONV1PushToken_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISNOTIFICATIONV1PushToken_Type_TypeUnknown:
    case KEYAPISNOTIFICATIONV1PushToken_Type_MobileFcm:
    case KEYAPISNOTIFICATIONV1PushToken_Type_MobileHms:
    case KEYAPISNOTIFICATIONV1PushToken_Type_MobileApnsText:
    case KEYAPISNOTIFICATIONV1PushToken_Type_MobileApnsCall:
    case KEYAPISNOTIFICATIONV1PushToken_Type_PwaFcm:
    case KEYAPISNOTIFICATIONV1PushToken_Type_PwaApns:
    case KEYAPISNOTIFICATIONV1PushToken_Type_MobileRustore:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType

GPBEnumDescriptor *KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Id\000CreatedAt\000ChangedA"
        "t\000";
    static const int32_t values[] = {
        KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_Id,
        KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_CreatedAt,
        KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_ChangedAt,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_Id:
    case KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_CreatedAt:
    case KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_ChangedAt:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType

GPBEnumDescriptor *KEYAPISNOTIFICATIONV1PushTokenPaging_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[] = {
        KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_Desc,
        KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_Desc:
    case KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISNOTIFICATIONV1PushToken

@implementation KEYAPISNOTIFICATIONV1PushToken

@dynamic id_p;
@dynamic type;
@dynamic token;
@dynamic userAppId;
@dynamic hasUserId, userId;
@dynamic hasCreatedAt, createdAt;
@dynamic hasChangedAt, changedAt;
@dynamic appVersion;

typedef struct KEYAPISNOTIFICATIONV1PushToken__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  KEYAPISNOTIFICATIONV1PushToken_Type type;
  NSString *token;
  NSString *userAppId;
  GPBInt32Value *userId;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
  NSString *appVersion;
} KEYAPISNOTIFICATIONV1PushToken__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 = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISNOTIFICATIONV1PushToken_Type_EnumDescriptor,
        .number = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_Type,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "token",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_Token,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, token),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "userAppId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_UserAppId,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, userAppId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "userId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_UserId,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, userId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_CreatedAt,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_ChangedAt,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "appVersion",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1PushToken_FieldNumber_AppVersion,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken__storage_, appVersion),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken)
                                   messageName:@"PushToken"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushToken__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 KEYAPISNOTIFICATIONV1PushToken_Type_RawValue(KEYAPISNOTIFICATIONV1PushToken *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1PushToken descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISNOTIFICATIONV1PushToken_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISNOTIFICATIONV1PushToken_Type_RawValue(KEYAPISNOTIFICATIONV1PushToken *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1PushToken descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISNOTIFICATIONV1PushToken_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISNOTIFICATIONV1PushToken_ValidationError

@implementation KEYAPISNOTIFICATIONV1PushToken_ValidationError

@dynamic reasonOneOfCase;
@dynamic userAppId;

typedef struct KEYAPISNOTIFICATIONV1PushToken_ValidationError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid *userAppId;
} KEYAPISNOTIFICATIONV1PushToken_ValidationError__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 = "userAppId",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid),
        .number = KEYAPISNOTIFICATIONV1PushToken_ValidationError_FieldNumber_UserAppId,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken_ValidationError__storage_, userAppId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushToken_ValidationError__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(KEYAPISNOTIFICATIONV1PushToken)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid


typedef struct KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid__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(KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid)
                                   messageName:@"UserAppIdInvalid"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushToken_ValidationError_UserAppIdInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISNOTIFICATIONV1PushToken_SavingError

@implementation KEYAPISNOTIFICATIONV1PushToken_SavingError

@dynamic reasonOneOfCase;
@dynamic userAppIdExists;
@dynamic conflict;

typedef struct KEYAPISNOTIFICATIONV1PushToken_SavingError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists *userAppIdExists;
  KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict *conflict;
} KEYAPISNOTIFICATIONV1PushToken_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 = "userAppIdExists",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists),
        .number = KEYAPISNOTIFICATIONV1PushToken_SavingError_FieldNumber_UserAppIdExists,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken_SavingError__storage_, userAppIdExists),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "conflict",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict),
        .number = KEYAPISNOTIFICATIONV1PushToken_SavingError_FieldNumber_Conflict,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushToken_SavingError__storage_, conflict),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_SavingError)
                                   messageName:@"SavingError"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushToken_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(KEYAPISNOTIFICATIONV1PushToken)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists


typedef struct KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists__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(KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists)
                                   messageName:@"UserAppIdExists"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushToken_SavingError_UserAppIdExists__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict

@implementation KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict


typedef struct KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISNOTIFICATIONV1PushToken_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(KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict)
                                   messageName:@"Conflict"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushToken_SavingError_Conflict__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISNOTIFICATIONV1PushTokenFilter

@implementation KEYAPISNOTIFICATIONV1PushTokenFilter

@dynamic typesArray, typesArray_Count;
@dynamic userAppIdsArray, userAppIdsArray_Count;
@dynamic userIdsArray, userIdsArray_Count;
@dynamic hasBeginCreatedAt, beginCreatedAt;
@dynamic hasEndCreatedAt, endCreatedAt;
@dynamic hasBeginChangedAt, beginChangedAt;
@dynamic hasEndChangedAt, endChangedAt;

typedef struct KEYAPISNOTIFICATIONV1PushTokenFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBEnumArray *typesArray;
  NSMutableArray *userAppIdsArray;
  GPBInt32Array *userIdsArray;
  GPBTimestamp *beginCreatedAt;
  GPBTimestamp *endCreatedAt;
  GPBTimestamp *beginChangedAt;
  GPBTimestamp *endChangedAt;
} KEYAPISNOTIFICATIONV1PushTokenFilter__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 = "typesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISNOTIFICATIONV1PushToken_Type_EnumDescriptor,
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_FieldNumber_TypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter__storage_, typesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "userAppIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_FieldNumber_UserAppIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter__storage_, userAppIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "userIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_FieldNumber_UserIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter__storage_, userIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "beginCreatedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_FieldNumber_BeginCreatedAt,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter__storage_, beginCreatedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "endCreatedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_FieldNumber_EndCreatedAt,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter__storage_, endCreatedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "beginChangedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_FieldNumber_BeginChangedAt,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter__storage_, beginChangedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "endChangedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_FieldNumber_EndChangedAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter__storage_, endChangedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenFilter)
                                   messageName:@"PushTokenFilter"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushTokenFilter__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 - KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError

@implementation KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError

@dynamic reasonOneOfCase;
@dynamic userAppIds;

typedef struct KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid *userAppIds;
} KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError__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 = "userAppIds",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid),
        .number = KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_FieldNumber_UserAppIds,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError__storage_, userAppIds),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError__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(KEYAPISNOTIFICATIONV1PushTokenFilter)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid


typedef struct KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid__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(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid)
                                   messageName:@"UserAppIdsInvalid"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError_UserAppIdsInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISNOTIFICATIONV1PushTokenPaging

@implementation KEYAPISNOTIFICATIONV1PushTokenPaging

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

typedef struct KEYAPISNOTIFICATIONV1PushTokenPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType orderByType;
  KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISNOTIFICATIONV1PushTokenPaging__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 = KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging)
                                   messageName:@"PushTokenPaging"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushTokenPaging__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 KEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_RawValue(KEYAPISNOTIFICATIONV1PushTokenPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1PushTokenPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISNOTIFICATIONV1PushTokenPaging_OrderByType_RawValue(KEYAPISNOTIFICATIONV1PushTokenPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1PushTokenPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_RawValue(KEYAPISNOTIFICATIONV1PushTokenPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1PushTokenPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISNOTIFICATIONV1PushTokenPaging_DirectionType_RawValue(KEYAPISNOTIFICATIONV1PushTokenPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1PushTokenPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISNOTIFICATIONV1PushTokenPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError

@implementation KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError

@dynamic reasonOneOfCase;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid *limit;
  KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid *offset;
} KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError__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 = "limit",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid),
        .number = KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_FieldNumber_Limit,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError__storage_, limit),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid),
        .number = KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_FieldNumber_Offset,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError__storage_, offset),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError__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(KEYAPISNOTIFICATIONV1PushTokenPaging)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid


typedef struct KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid__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(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid)
                                   messageName:@"LimitInvalid"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_LimitInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid

@implementation KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid


typedef struct KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid__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(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid)
                                   messageName:@"OffsetInvalid"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError_OffsetInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISNOTIFICATIONV1PostPushTokenRequest

@implementation KEYAPISNOTIFICATIONV1PostPushTokenRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISNOTIFICATIONV1PostPushTokenRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISNOTIFICATIONV1PushToken *data_p;
} KEYAPISNOTIFICATIONV1PostPushTokenRequest__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(KEYAPISNOTIFICATIONV1PushToken),
        .number = KEYAPISNOTIFICATIONV1PostPushTokenRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PostPushTokenRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PostPushTokenRequest)
                                   messageName:@"PostPushTokenRequest"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PostPushTokenRequest__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 - KEYAPISNOTIFICATIONV1PostPushTokenResponse

@implementation KEYAPISNOTIFICATIONV1PostPushTokenResponse

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

typedef struct KEYAPISNOTIFICATIONV1PostPushTokenResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushToken *data_p;
  KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error *error;
} KEYAPISNOTIFICATIONV1PostPushTokenResponse__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(KEYAPISNOTIFICATIONV1PushToken),
        .number = KEYAPISNOTIFICATIONV1PostPushTokenResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PostPushTokenResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error),
        .number = KEYAPISNOTIFICATIONV1PostPushTokenResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PostPushTokenResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PostPushTokenResponse)
                                   messageName:@"PostPushTokenResponse"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PostPushTokenResponse__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 KEYAPISNOTIFICATIONV1PostPushTokenResponse_ClearTypeOneOfCase(KEYAPISNOTIFICATIONV1PostPushTokenResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1PostPushTokenResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error

@implementation KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error

@dynamic reasonOneOfCase;
@dynamic pushTokenValidation;
@dynamic pushTokenSaving;
@dynamic validation;

typedef struct KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushToken_ValidationError *pushTokenValidation;
  KEYAPISNOTIFICATIONV1PushToken_SavingError *pushTokenSaving;
  KEYAPISNOTIFICATIONV1ValidationError *validation;
} KEYAPISNOTIFICATIONV1PostPushTokenResponse_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 = "pushTokenValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_ValidationError),
        .number = KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error_FieldNumber_PushTokenValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error__storage_, pushTokenValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "pushTokenSaving",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushToken_SavingError),
        .number = KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error_FieldNumber_PushTokenSaving,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error__storage_, pushTokenSaving),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1ValidationError),
        .number = KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1PostPushTokenResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1PostPushTokenResponse_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(KEYAPISNOTIFICATIONV1PostPushTokenResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1GetPushTokenListRequest

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

typedef struct KEYAPISNOTIFICATIONV1GetPushTokenListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushTokenFilter *filter;
  KEYAPISNOTIFICATIONV1PushTokenPaging *paging;
} KEYAPISNOTIFICATIONV1GetPushTokenListRequest__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(KEYAPISNOTIFICATIONV1PushTokenFilter),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenListRequest)
                                   messageName:@"GetPushTokenListRequest"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1GetPushTokenListRequest__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 KEYAPISNOTIFICATIONV1GetPushTokenListRequest_ClearPaginationOneOfCase(KEYAPISNOTIFICATIONV1GetPushTokenListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1GetPushTokenListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISNOTIFICATIONV1GetPushTokenCountRequest

@implementation KEYAPISNOTIFICATIONV1GetPushTokenCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISNOTIFICATIONV1GetPushTokenCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISNOTIFICATIONV1PushTokenFilter *filter;
} KEYAPISNOTIFICATIONV1GetPushTokenCountRequest__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(KEYAPISNOTIFICATIONV1PushTokenFilter),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenCountRequest)
                                   messageName:@"GetPushTokenCountRequest"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1GetPushTokenCountRequest__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 - KEYAPISNOTIFICATIONV1GetPushTokenCountResponse

@implementation KEYAPISNOTIFICATIONV1GetPushTokenCountResponse

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

typedef struct KEYAPISNOTIFICATIONV1GetPushTokenCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
  KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error *error;
} KEYAPISNOTIFICATIONV1GetPushTokenCountResponse__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 = KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse)
                                   messageName:@"GetPushTokenCountResponse"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse__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 KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_ClearTypeOneOfCase(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1GetPushTokenCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error

@implementation KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error

@dynamic reasonOneOfCase;
@dynamic pushTokenFilterValidation;
@dynamic validation;

typedef struct KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError *pushTokenFilterValidation;
  KEYAPISNOTIFICATIONV1ValidationError *validation;
} KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_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 = "pushTokenFilterValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error_FieldNumber_PushTokenFilterValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error__storage_, pushTokenFilterValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1ValidationError),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse_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(KEYAPISNOTIFICATIONV1GetPushTokenCountResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1GetPushTokenListResponse

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

typedef struct KEYAPISNOTIFICATIONV1GetPushTokenListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushToken *data_p;
  KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error *error;
} KEYAPISNOTIFICATIONV1GetPushTokenListResponse__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(KEYAPISNOTIFICATIONV1PushToken),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenListResponse)
                                   messageName:@"GetPushTokenListResponse"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1GetPushTokenListResponse__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 KEYAPISNOTIFICATIONV1GetPushTokenListResponse_ClearTypeOneOfCase(KEYAPISNOTIFICATIONV1GetPushTokenListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1GetPushTokenListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error

@implementation KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error

@dynamic reasonOneOfCase;
@dynamic pushTokenFilterValidation;
@dynamic pushTokenPagingValidation;
@dynamic validation;

typedef struct KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError *pushTokenFilterValidation;
  KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError *pushTokenPagingValidation;
  KEYAPISNOTIFICATIONV1ValidationError *validation;
} KEYAPISNOTIFICATIONV1GetPushTokenListResponse_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 = "pushTokenFilterValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenFilter_ValidationError),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error_FieldNumber_PushTokenFilterValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error__storage_, pushTokenFilterValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "pushTokenPagingValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1PushTokenPaging_ValidationError),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error_FieldNumber_PushTokenPagingValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error__storage_, pushTokenPagingValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISNOTIFICATIONV1ValidationError),
        .number = KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1GetPushTokenListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1GetPushTokenListResponse_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(KEYAPISNOTIFICATIONV1GetPushTokenListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenRequest

@dynamic id_p;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISNOTIFICATIONV1DeletePushTokenRequest__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 = KEYAPISNOTIFICATIONV1DeletePushTokenRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenRequest)
                                   messageName:@"DeletePushTokenRequest"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenRequest__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 - KEYAPISNOTIFICATIONV1DeletePushTokenResponse

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error *error;
} KEYAPISNOTIFICATIONV1DeletePushTokenResponse__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(KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error),
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenResponse)
                                   messageName:@"DeletePushTokenResponse"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenResponse__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 KEYAPISNOTIFICATIONV1DeletePushTokenResponse_ClearTypeOneOfCase(KEYAPISNOTIFICATIONV1DeletePushTokenResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1DeletePushTokenResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1ValidationError *validation;
} KEYAPISNOTIFICATIONV1DeletePushTokenResponse_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(KEYAPISNOTIFICATIONV1ValidationError),
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenResponse_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(KEYAPISNOTIFICATIONV1DeletePushTokenResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest

@dynamic userId;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t userId;
} KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest__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 = "userId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest_FieldNumber_UserId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest__storage_, userId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest)
                                   messageName:@"DeletePushTokenUserIdRequest"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdRequest__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 - KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error *error;
} KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse__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(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error),
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse)
                                   messageName:@"DeletePushTokenUserIdResponse"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse__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 KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_ClearTypeOneOfCase(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1ValidationError *validation;
} KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_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(KEYAPISNOTIFICATIONV1ValidationError),
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse_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(KEYAPISNOTIFICATIONV1DeletePushTokenUserIdResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest

@dynamic userAppId;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *userAppId;
} KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest__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 = "userAppId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest_FieldNumber_UserAppId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest__storage_, userAppId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest)
                                   messageName:@"DeletePushTokenUserAppIdRequest"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdRequest__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 - KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error *error;
} KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse__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(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error),
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse)
                                   messageName:@"DeletePushTokenUserAppIdResponse"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse__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 KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_ClearTypeOneOfCase(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error

@implementation KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISNOTIFICATIONV1ValidationError *validation;
} KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_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(KEYAPISNOTIFICATIONV1ValidationError),
        .number = KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse_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(KEYAPISNOTIFICATIONV1DeletePushTokenUserAppIdResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISNOTIFICATIONV1ValidationError

@dynamic path;
@dynamic message;

typedef struct KEYAPISNOTIFICATIONV1ValidationError__storage_ {
  uint32_t _has_storage_[1];
  NSString *path;
  NSString *message;
} KEYAPISNOTIFICATIONV1ValidationError__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 = KEYAPISNOTIFICATIONV1ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISNOTIFICATIONV1ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISNOTIFICATIONV1ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISNOTIFICATIONV1ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISNOTIFICATIONV1KeyapisNotificationPushTokenV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISNOTIFICATIONV1ValidationError__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
