// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/device/v1/keyapis_device_device_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/device/v1/KeyapisDeviceDeviceV1.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.pbobjc.h"
#import "google/api/Visibility.pbobjc.h"
#import "keyapis/device/v1/KeyapisDeviceModelV1.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(GPBBoolValue);
GPBObjCClassDeclaration(GPBInt32Value);
GPBObjCClassDeclaration(GPBStringValue);
GPBObjCClassDeclaration(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISDEVICEV1CameraStatus);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeleteDeviceRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeleteDeviceResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceConfigurationStatus);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceConfigurationStatusGrouped);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceFilter);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DeviceLite);
GPBObjCClassDeclaration(KEYAPISDEVICEV1DevicePaging);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_AutochangePasswordSettings);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Credentials);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Dispatching);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Location);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Redirect);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_ConciergeRoomNotFound);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_CredentialsAreRequired);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_FieldIsNotSupported);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_LoginIsExist);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_MacAddressInvalid);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_MacAddressIsExist);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_NotAllowedForModel);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_NotAllowedForType);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_PublicIdentityIsExist);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_SerialNumberForModelIsExist);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SavingError_SerialNumberInvalid);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Settings);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Settings_Autocollect);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Settings_ConciergeCall);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Settings_EmergencyCall);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Settings_FaceRecognition);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_Settings_Sl3Mode);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SipTrunk);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Device_SputnikCredentials);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceCountRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceCountResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceCountResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceListRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceListResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceListResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceLiteRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceLiteResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1GetDeviceResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceInstallPresetRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceInstallPresetResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error_PresetStatusIsProcessing);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReconfigureRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReconfigureResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_HostExists);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginExists);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginIsRequired);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_MacAddressExists);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_SerialNumberExists);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PostDeviceResponse_Error);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_Dtmf);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_FaceRecognition);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_Ntp);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_Room);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_SavingError);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_SavingError_Conflict);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_Sip);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_Syslog);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_VideoConfig);
GPBObjCClassDeclaration(KEYAPISDEVICEV1Preset_VideoConfig_RtspUser);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PutDeviceRequest);
GPBObjCClassDeclaration(KEYAPISDEVICEV1PutDeviceResponse);
GPBObjCClassDeclaration(KEYAPISDEVICEV1ReinstallError);
GPBObjCClassDeclaration(KEYAPISDEVICEV1ReinstallError_SipLoginIsMissing);
GPBObjCClassDeclaration(KEYAPISDEVICEV1SyncStatus);
GPBObjCClassDeclaration(KEYAPISDEVICEV1ValidationError);

#pragma mark - KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root

@implementation KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root

+ (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 KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription = {
  .package = "keyapis.device.v1",
  .prefix = "KEYAPISDEVICEV1",
  .syntax = GPBFileSyntaxProto3
};

#pragma mark - Enum KEYAPISDEVICEV1Device_PresetStatusType

GPBEnumDescriptor *KEYAPISDEVICEV1Device_PresetStatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "PresetStatusTypeUnknown\000Processing\000Succe"
        "ss\000Error\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Device_PresetStatusType_PresetStatusTypeUnknown,
        KEYAPISDEVICEV1Device_PresetStatusType_Processing,
        KEYAPISDEVICEV1Device_PresetStatusType_Success,
        KEYAPISDEVICEV1Device_PresetStatusType_Error,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Device_PresetStatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Device_PresetStatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Device_PresetStatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Device_PresetStatusType_PresetStatusTypeUnknown:
    case KEYAPISDEVICEV1Device_PresetStatusType_Processing:
    case KEYAPISDEVICEV1Device_PresetStatusType_Success:
    case KEYAPISDEVICEV1Device_PresetStatusType_Error:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Device_Type

GPBEnumDescriptor *KEYAPISDEVICEV1Device_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000Intercom\000Videocamera\000Barrier"
        "\000Gate\000AccessControlPanel\000OutdoorCamera\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Device_Type_TypeUnknown,
        KEYAPISDEVICEV1Device_Type_Intercom,
        KEYAPISDEVICEV1Device_Type_Videocamera,
        KEYAPISDEVICEV1Device_Type_Barrier,
        KEYAPISDEVICEV1Device_Type_Gate,
        KEYAPISDEVICEV1Device_Type_AccessControlPanel,
        KEYAPISDEVICEV1Device_Type_OutdoorCamera,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Device_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Device_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Device_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Device_Type_TypeUnknown:
    case KEYAPISDEVICEV1Device_Type_Intercom:
    case KEYAPISDEVICEV1Device_Type_Videocamera:
    case KEYAPISDEVICEV1Device_Type_Barrier:
    case KEYAPISDEVICEV1Device_Type_Gate:
    case KEYAPISDEVICEV1Device_Type_AccessControlPanel:
    case KEYAPISDEVICEV1Device_Type_OutdoorCamera:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Device_ModelType

GPBEnumDescriptor *KEYAPISDEVICEV1Device_ModelType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "ModelTypeUnknown\000Rodos8\000Beward\000Qtech\000Nat"
        "eks\000Tnb\000Maxetline\000TnbDo2\000BewardDs86017Cp"
        "\000BewardDs85006Mp\000DahuaVto2101EP\000Hikvisio"
        "nDsKv8155Im\000Rodos82\000AkuvoxR29C\000SafeLogic"
        "\000BewardDs86006Ap\000SputnikIo\000BewardFr\000Qtec"
        "hFr\000EltexIpaEr010\000BewardMifare\000BasIpAa12"
        "Fb\000AkuvoxX915S\000RubetekRv3434\000SokolPlus\000B"
        "ewardLowCost\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Device_ModelType_ModelTypeUnknown,
        KEYAPISDEVICEV1Device_ModelType_Rodos8,
        KEYAPISDEVICEV1Device_ModelType_Beward,
        KEYAPISDEVICEV1Device_ModelType_Qtech,
        KEYAPISDEVICEV1Device_ModelType_Nateks,
        KEYAPISDEVICEV1Device_ModelType_Tnb,
        KEYAPISDEVICEV1Device_ModelType_Maxetline,
        KEYAPISDEVICEV1Device_ModelType_TnbDo2,
        KEYAPISDEVICEV1Device_ModelType_BewardDs86017Cp,
        KEYAPISDEVICEV1Device_ModelType_BewardDs85006Mp,
        KEYAPISDEVICEV1Device_ModelType_DahuaVto2101EP,
        KEYAPISDEVICEV1Device_ModelType_HikvisionDsKv8155Im,
        KEYAPISDEVICEV1Device_ModelType_Rodos82,
        KEYAPISDEVICEV1Device_ModelType_AkuvoxR29C,
        KEYAPISDEVICEV1Device_ModelType_SafeLogic,
        KEYAPISDEVICEV1Device_ModelType_BewardDs86006Ap,
        KEYAPISDEVICEV1Device_ModelType_SputnikIo,
        KEYAPISDEVICEV1Device_ModelType_BewardFr,
        KEYAPISDEVICEV1Device_ModelType_QtechFr,
        KEYAPISDEVICEV1Device_ModelType_EltexIpaEr010,
        KEYAPISDEVICEV1Device_ModelType_BewardMifare,
        KEYAPISDEVICEV1Device_ModelType_BasIpAa12Fb,
        KEYAPISDEVICEV1Device_ModelType_AkuvoxX915S,
        KEYAPISDEVICEV1Device_ModelType_RubetekRv3434,
        KEYAPISDEVICEV1Device_ModelType_SokolPlus,
        KEYAPISDEVICEV1Device_ModelType_BewardLowCost,
    };
    static const char *extraTextFormatInfo = "\n\010f\342\006A\000\tf\342\006A\000\ne\343\005\201\000\014e\001\201\000\rf\204\000\017f\342\006A\000\023e\343\342\203\000\025c\342\342\203A\000\026f\205\000\027g\342\204\000";
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Device_ModelType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Device_ModelType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None
                              extraTextFormatInfo:extraTextFormatInfo];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Device_ModelType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Device_ModelType_ModelTypeUnknown:
    case KEYAPISDEVICEV1Device_ModelType_Rodos8:
    case KEYAPISDEVICEV1Device_ModelType_Beward:
    case KEYAPISDEVICEV1Device_ModelType_Qtech:
    case KEYAPISDEVICEV1Device_ModelType_Nateks:
    case KEYAPISDEVICEV1Device_ModelType_Tnb:
    case KEYAPISDEVICEV1Device_ModelType_Maxetline:
    case KEYAPISDEVICEV1Device_ModelType_TnbDo2:
    case KEYAPISDEVICEV1Device_ModelType_BewardDs86017Cp:
    case KEYAPISDEVICEV1Device_ModelType_BewardDs85006Mp:
    case KEYAPISDEVICEV1Device_ModelType_DahuaVto2101EP:
    case KEYAPISDEVICEV1Device_ModelType_HikvisionDsKv8155Im:
    case KEYAPISDEVICEV1Device_ModelType_Rodos82:
    case KEYAPISDEVICEV1Device_ModelType_AkuvoxR29C:
    case KEYAPISDEVICEV1Device_ModelType_SafeLogic:
    case KEYAPISDEVICEV1Device_ModelType_BewardDs86006Ap:
    case KEYAPISDEVICEV1Device_ModelType_SputnikIo:
    case KEYAPISDEVICEV1Device_ModelType_BewardFr:
    case KEYAPISDEVICEV1Device_ModelType_QtechFr:
    case KEYAPISDEVICEV1Device_ModelType_EltexIpaEr010:
    case KEYAPISDEVICEV1Device_ModelType_BewardMifare:
    case KEYAPISDEVICEV1Device_ModelType_BasIpAa12Fb:
    case KEYAPISDEVICEV1Device_ModelType_AkuvoxX915S:
    case KEYAPISDEVICEV1Device_ModelType_RubetekRv3434:
    case KEYAPISDEVICEV1Device_ModelType_SokolPlus:
    case KEYAPISDEVICEV1Device_ModelType_BewardLowCost:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Device_StatusType

GPBEnumDescriptor *KEYAPISDEVICEV1Device_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Offline\000Online\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Device_StatusType_StatusTypeUnknown,
        KEYAPISDEVICEV1Device_StatusType_Offline,
        KEYAPISDEVICEV1Device_StatusType_Online,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Device_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Device_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Device_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Device_StatusType_StatusTypeUnknown:
    case KEYAPISDEVICEV1Device_StatusType_Offline:
    case KEYAPISDEVICEV1Device_StatusType_Online:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Device_SipTrunk_SipType

GPBEnumDescriptor *KEYAPISDEVICEV1Device_SipTrunk_SipType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "SipTypeUnknown\000Vims\000Ngn\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Device_SipTrunk_SipType_SipTypeUnknown,
        KEYAPISDEVICEV1Device_SipTrunk_SipType_Vims,
        KEYAPISDEVICEV1Device_SipTrunk_SipType_Ngn,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Device_SipTrunk_SipType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Device_SipTrunk_SipType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Device_SipTrunk_SipType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Device_SipTrunk_SipType_SipTypeUnknown:
    case KEYAPISDEVICEV1Device_SipTrunk_SipType_Vims:
    case KEYAPISDEVICEV1Device_SipTrunk_SipType_Ngn:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Device_Credentials_UserAccessType

GPBEnumDescriptor *KEYAPISDEVICEV1Device_Credentials_UserAccessType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "UserAccessTypeUnknown\000Api\000Web\000Rtsp\000Su\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Device_Credentials_UserAccessType_UserAccessTypeUnknown,
        KEYAPISDEVICEV1Device_Credentials_UserAccessType_Api,
        KEYAPISDEVICEV1Device_Credentials_UserAccessType_Web,
        KEYAPISDEVICEV1Device_Credentials_UserAccessType_Rtsp,
        KEYAPISDEVICEV1Device_Credentials_UserAccessType_Su,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Device_Credentials_UserAccessType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Device_Credentials_UserAccessType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Device_Credentials_UserAccessType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Device_Credentials_UserAccessType_UserAccessTypeUnknown:
    case KEYAPISDEVICEV1Device_Credentials_UserAccessType_Api:
    case KEYAPISDEVICEV1Device_Credentials_UserAccessType_Web:
    case KEYAPISDEVICEV1Device_Credentials_UserAccessType_Rtsp:
    case KEYAPISDEVICEV1Device_Credentials_UserAccessType_Su:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType

GPBEnumDescriptor *KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "ConfigurationTypeUnknown\000Preset\000SipAccou"
        "nt\000SipRooms\000Gate\000Rfids\000Codes\000FaceRecogni"
        "tion\000Concierge\000Autocollect\000Sl3\000Emergency"
        "Call\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_ConfigurationTypeUnknown,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Preset,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_SipAccount,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_SipRooms,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Gate,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Rfids,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Codes,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_FaceRecognition,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Concierge,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Autocollect,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Sl3,
        KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_EmergencyCall,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_ConfigurationTypeUnknown:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Preset:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_SipAccount:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_SipRooms:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Gate:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Rfids:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Codes:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_FaceRecognition:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Concierge:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Autocollect:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_Sl3:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_EmergencyCall:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType

GPBEnumDescriptor *KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Success\000Error\000Pending\000"
        "Processing\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_StatusTypeUnknown,
        KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Success,
        KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Error,
        KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Pending,
        KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Processing,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_StatusTypeUnknown:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Success:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Error:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Pending:
    case KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_Processing:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1CameraStatus_StatusType

GPBEnumDescriptor *KEYAPISDEVICEV1CameraStatus_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Processing\000ProcessingE"
        "rror\000Active\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1CameraStatus_StatusType_StatusTypeUnknown,
        KEYAPISDEVICEV1CameraStatus_StatusType_Processing,
        KEYAPISDEVICEV1CameraStatus_StatusType_ProcessingError,
        KEYAPISDEVICEV1CameraStatus_StatusType_Active,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1CameraStatus_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1CameraStatus_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1CameraStatus_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1CameraStatus_StatusType_StatusTypeUnknown:
    case KEYAPISDEVICEV1CameraStatus_StatusType_Processing:
    case KEYAPISDEVICEV1CameraStatus_StatusType_ProcessingError:
    case KEYAPISDEVICEV1CameraStatus_StatusType_Active:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1SyncStatus_StatusType

GPBEnumDescriptor *KEYAPISDEVICEV1SyncStatus_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000New\000Pending\000Error\000Succ"
        "ess\000Disabled\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1SyncStatus_StatusType_StatusTypeUnknown,
        KEYAPISDEVICEV1SyncStatus_StatusType_New,
        KEYAPISDEVICEV1SyncStatus_StatusType_Pending,
        KEYAPISDEVICEV1SyncStatus_StatusType_Error,
        KEYAPISDEVICEV1SyncStatus_StatusType_Success,
        KEYAPISDEVICEV1SyncStatus_StatusType_Disabled,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1SyncStatus_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1SyncStatus_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1SyncStatus_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1SyncStatus_StatusType_StatusTypeUnknown:
    case KEYAPISDEVICEV1SyncStatus_StatusType_New:
    case KEYAPISDEVICEV1SyncStatus_StatusType_Pending:
    case KEYAPISDEVICEV1SyncStatus_StatusType_Error:
    case KEYAPISDEVICEV1SyncStatus_StatusType_Success:
    case KEYAPISDEVICEV1SyncStatus_StatusType_Disabled:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1DevicePaging_OrderByType

GPBEnumDescriptor *KEYAPISDEVICEV1DevicePaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Id\000Title\000SyncAt\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1DevicePaging_OrderByType_OrderByTypeUnknown,
        KEYAPISDEVICEV1DevicePaging_OrderByType_Id,
        KEYAPISDEVICEV1DevicePaging_OrderByType_Title,
        KEYAPISDEVICEV1DevicePaging_OrderByType_SyncAt,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1DevicePaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1DevicePaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1DevicePaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1DevicePaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISDEVICEV1DevicePaging_OrderByType_Id:
    case KEYAPISDEVICEV1DevicePaging_OrderByType_Title:
    case KEYAPISDEVICEV1DevicePaging_OrderByType_SyncAt:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1DevicePaging_DirectionType

GPBEnumDescriptor *KEYAPISDEVICEV1DevicePaging_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[] = {
        KEYAPISDEVICEV1DevicePaging_DirectionType_DirectionTypeUnknown,
        KEYAPISDEVICEV1DevicePaging_DirectionType_Desc,
        KEYAPISDEVICEV1DevicePaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1DevicePaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1DevicePaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1DevicePaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1DevicePaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISDEVICEV1DevicePaging_DirectionType_Desc:
    case KEYAPISDEVICEV1DevicePaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType

GPBEnumDescriptor *KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000DeviceId\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_DeviceId,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_DeviceId:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType

GPBEnumDescriptor *KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_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[] = {
        KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_Desc,
        KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_Desc:
    case KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Preset_StatusType

GPBEnumDescriptor *KEYAPISDEVICEV1Preset_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Active\000Archive\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Preset_StatusType_StatusTypeUnknown,
        KEYAPISDEVICEV1Preset_StatusType_Active,
        KEYAPISDEVICEV1Preset_StatusType_Archive,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Preset_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Preset_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Preset_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Preset_StatusType_StatusTypeUnknown:
    case KEYAPISDEVICEV1Preset_StatusType_Active:
    case KEYAPISDEVICEV1Preset_StatusType_Archive:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Preset_Syslog_ProtocolType

GPBEnumDescriptor *KEYAPISDEVICEV1Preset_Syslog_ProtocolType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "ProtocolTypeUnknown\000Udp\000Tcp\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Preset_Syslog_ProtocolType_ProtocolTypeUnknown,
        KEYAPISDEVICEV1Preset_Syslog_ProtocolType_Udp,
        KEYAPISDEVICEV1Preset_Syslog_ProtocolType_Tcp,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Preset_Syslog_ProtocolType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Preset_Syslog_ProtocolType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Preset_Syslog_ProtocolType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Preset_Syslog_ProtocolType_ProtocolTypeUnknown:
    case KEYAPISDEVICEV1Preset_Syslog_ProtocolType_Udp:
    case KEYAPISDEVICEV1Preset_Syslog_ProtocolType_Tcp:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Preset_VideoConfig_QualityType

GPBEnumDescriptor *KEYAPISDEVICEV1Preset_VideoConfig_QualityType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "QualityTypeUnknown\000High\000Medium\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Preset_VideoConfig_QualityType_QualityTypeUnknown,
        KEYAPISDEVICEV1Preset_VideoConfig_QualityType_High,
        KEYAPISDEVICEV1Preset_VideoConfig_QualityType_Medium,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Preset_VideoConfig_QualityType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Preset_VideoConfig_QualityType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Preset_VideoConfig_QualityType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Preset_VideoConfig_QualityType_QualityTypeUnknown:
    case KEYAPISDEVICEV1Preset_VideoConfig_QualityType_High:
    case KEYAPISDEVICEV1Preset_VideoConfig_QualityType_Medium:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType

GPBEnumDescriptor *KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "ConfigurationTypeUnknown\000Default\000";
    static const int32_t values[] = {
        KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_ConfigurationTypeUnknown,
        KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_Default,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_ConfigurationTypeUnknown:
    case KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_Default:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISDEVICEV1Device

@implementation KEYAPISDEVICEV1Device

@dynamic id_p;
@dynamic presetId;
@dynamic presetStatusType;
@dynamic hasPresetConfiguredAt, presetConfiguredAt;
@dynamic isSl3ModeEnabled;
@dynamic type;
@dynamic macAddress;
@dynamic title;
@dynamic modelType;
@dynamic ownerCompanyId;
@dynamic serialNumber;
@dynamic flatgrammId;
@dynamic utcOffset;
@dynamic statusType;
@dynamic hasIpAddress, ipAddress;
@dynamic hasPort, port;
@dynamic hasSputnikCredentials, sputnikCredentials;
@dynamic hasLocation, location;
@dynamic hasCameraId, cameraId;
@dynamic tagsArray, tagsArray_Count;
@dynamic hasSettings, settings;
@dynamic hardwareVersion;
@dynamic softwareVersion;
@dynamic hasDispatching, dispatching;
@dynamic hasSipTrunk, sipTrunk;
@dynamic hasRedirect, redirect;
@dynamic hasAutochangePasswordSettings, autochangePasswordSettings;
@dynamic credentialsArray, credentialsArray_Count;
@dynamic hasSipAccount, sipAccount;
@dynamic hasSyncStatus, syncStatus;

typedef struct KEYAPISDEVICEV1Device__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  int32_t presetId;
  KEYAPISDEVICEV1Device_PresetStatusType presetStatusType;
  KEYAPISDEVICEV1Device_Type type;
  KEYAPISDEVICEV1Device_ModelType modelType;
  int32_t ownerCompanyId;
  int32_t flatgrammId;
  int32_t utcOffset;
  KEYAPISDEVICEV1Device_StatusType statusType;
  GPBTimestamp *presetConfiguredAt;
  NSString *macAddress;
  NSString *title;
  NSString *serialNumber;
  GPBStringValue *ipAddress;
  GPBInt32Value *port;
  KEYAPISDEVICEV1Device_SputnikCredentials *sputnikCredentials;
  KEYAPISDEVICEV1Device_Location *location;
  GPBStringValue *cameraId;
  NSMutableArray *tagsArray;
  KEYAPISDEVICEV1Device_Settings *settings;
  NSString *hardwareVersion;
  NSString *softwareVersion;
  KEYAPISDEVICEV1Device_Dispatching *dispatching;
  KEYAPISDEVICEV1Device_SipTrunk *sipTrunk;
  KEYAPISDEVICEV1Device_Redirect *redirect;
  KEYAPISDEVICEV1Device_AutochangePasswordSettings *autochangePasswordSettings;
  NSMutableArray *credentialsArray;
  GPBStringValue *sipAccount;
  KEYAPISDEVICEV1SyncStatus *syncStatus;
} KEYAPISDEVICEV1Device__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 = KEYAPISDEVICEV1Device_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "presetId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_PresetId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, presetId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "presetStatusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_PresetStatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Device_FieldNumber_PresetStatusType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, presetStatusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "presetConfiguredAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1Device_FieldNumber_PresetConfiguredAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, presetConfiguredAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "isSl3ModeEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_IsSl3ModeEnabled,
        .hasIndex = 4,
        .offset = 5,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_Type_EnumDescriptor,
        .number = KEYAPISDEVICEV1Device_FieldNumber_Type,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "macAddress",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_MacAddress,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, macAddress),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "title",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_Title,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, title),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "modelType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_ModelType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Device_FieldNumber_ModelType,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, modelType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "ownerCompanyId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_OwnerCompanyId,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, ownerCompanyId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "serialNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_SerialNumber,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, serialNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "flatgrammId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_FlatgrammId,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, flatgrammId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "utcOffset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_UtcOffset,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, utcOffset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Device_FieldNumber_StatusType,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "ipAddress",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_FieldNumber_IpAddress,
        .hasIndex = 15,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, ipAddress),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "port",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISDEVICEV1Device_FieldNumber_Port,
        .hasIndex = 16,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, port),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "sputnikCredentials",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SputnikCredentials),
        .number = KEYAPISDEVICEV1Device_FieldNumber_SputnikCredentials,
        .hasIndex = 17,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, sputnikCredentials),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "location",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Location),
        .number = KEYAPISDEVICEV1Device_FieldNumber_Location,
        .hasIndex = 18,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, location),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "cameraId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_FieldNumber_CameraId,
        .hasIndex = 19,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, cameraId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "tagsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_TagsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, tagsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "settings",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Settings),
        .number = KEYAPISDEVICEV1Device_FieldNumber_Settings,
        .hasIndex = 20,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, settings),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "hardwareVersion",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_HardwareVersion,
        .hasIndex = 21,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, hardwareVersion),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "softwareVersion",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_FieldNumber_SoftwareVersion,
        .hasIndex = 22,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, softwareVersion),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "dispatching",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Dispatching),
        .number = KEYAPISDEVICEV1Device_FieldNumber_Dispatching,
        .hasIndex = 23,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, dispatching),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "sipTrunk",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SipTrunk),
        .number = KEYAPISDEVICEV1Device_FieldNumber_SipTrunk,
        .hasIndex = 24,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, sipTrunk),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "redirect",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Redirect),
        .number = KEYAPISDEVICEV1Device_FieldNumber_Redirect,
        .hasIndex = 25,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, redirect),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "autochangePasswordSettings",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_AutochangePasswordSettings),
        .number = KEYAPISDEVICEV1Device_FieldNumber_AutochangePasswordSettings,
        .hasIndex = 26,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, autochangePasswordSettings),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "credentialsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Credentials),
        .number = KEYAPISDEVICEV1Device_FieldNumber_CredentialsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, credentialsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "sipAccount",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_FieldNumber_SipAccount,
        .hasIndex = 27,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, sipAccount),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "syncStatus",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1SyncStatus),
        .number = KEYAPISDEVICEV1Device_FieldNumber_SyncStatus,
        .hasIndex = 28,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device__storage_, syncStatus),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device)
                                   messageName:@"Device"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device__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 KEYAPISDEVICEV1Device_PresetStatusType_RawValue(KEYAPISDEVICEV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_PresetStatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Device_PresetStatusType_RawValue(KEYAPISDEVICEV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_PresetStatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISDEVICEV1Device_Type_RawValue(KEYAPISDEVICEV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Device_Type_RawValue(KEYAPISDEVICEV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISDEVICEV1Device_ModelType_RawValue(KEYAPISDEVICEV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_ModelType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Device_ModelType_RawValue(KEYAPISDEVICEV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_ModelType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISDEVICEV1Device_StatusType_RawValue(KEYAPISDEVICEV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Device_StatusType_RawValue(KEYAPISDEVICEV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Device_SputnikCredentials

@implementation KEYAPISDEVICEV1Device_SputnikCredentials

@dynamic login;
@dynamic hasPassword, password;

typedef struct KEYAPISDEVICEV1Device_SputnikCredentials__storage_ {
  uint32_t _has_storage_[1];
  NSString *login;
  GPBStringValue *password;
} KEYAPISDEVICEV1Device_SputnikCredentials__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 = "login",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_SputnikCredentials_FieldNumber_Login,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SputnikCredentials__storage_, login),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_SputnikCredentials_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SputnikCredentials__storage_, password),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_SputnikCredentials)
                                   messageName:@"SputnikCredentials"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_SputnikCredentials__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Location

@implementation KEYAPISDEVICEV1Device_Location

@dynamic latitude;
@dynamic longitude;

typedef struct KEYAPISDEVICEV1Device_Location__storage_ {
  uint32_t _has_storage_[1];
  float latitude;
  float longitude;
} KEYAPISDEVICEV1Device_Location__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 = "latitude",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Location_FieldNumber_Latitude,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Location__storage_, latitude),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "longitude",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Location_FieldNumber_Longitude,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Location__storage_, longitude),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Location)
                                   messageName:@"Location"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Location__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Settings

@implementation KEYAPISDEVICEV1Device_Settings

@dynamic hasCoordinateMatrixSwitch, coordinateMatrixSwitch;
@dynamic hasConciergeCall, conciergeCall;
@dynamic hasAutocollect, autocollect;
@dynamic hasFaceRecognition, faceRecognition;
@dynamic hasSl3Mode, sl3Mode;
@dynamic hasEmergencyCall, emergencyCall;

typedef struct KEYAPISDEVICEV1Device_Settings__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch *coordinateMatrixSwitch;
  KEYAPISDEVICEV1Device_Settings_ConciergeCall *conciergeCall;
  KEYAPISDEVICEV1Device_Settings_Autocollect *autocollect;
  KEYAPISDEVICEV1Device_Settings_FaceRecognition *faceRecognition;
  KEYAPISDEVICEV1Device_Settings_Sl3Mode *sl3Mode;
  KEYAPISDEVICEV1Device_Settings_EmergencyCall *emergencyCall;
} KEYAPISDEVICEV1Device_Settings__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 = "coordinateMatrixSwitch",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch),
        .number = KEYAPISDEVICEV1Device_Settings_FieldNumber_CoordinateMatrixSwitch,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings__storage_, coordinateMatrixSwitch),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "conciergeCall",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Settings_ConciergeCall),
        .number = KEYAPISDEVICEV1Device_Settings_FieldNumber_ConciergeCall,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings__storage_, conciergeCall),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "autocollect",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Settings_Autocollect),
        .number = KEYAPISDEVICEV1Device_Settings_FieldNumber_Autocollect,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings__storage_, autocollect),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "faceRecognition",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Settings_FaceRecognition),
        .number = KEYAPISDEVICEV1Device_Settings_FieldNumber_FaceRecognition,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings__storage_, faceRecognition),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "sl3Mode",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Settings_Sl3Mode),
        .number = KEYAPISDEVICEV1Device_Settings_FieldNumber_Sl3Mode,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings__storage_, sl3Mode),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "emergencyCall",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Settings_EmergencyCall),
        .number = KEYAPISDEVICEV1Device_Settings_FieldNumber_EmergencyCall,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings__storage_, emergencyCall),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings)
                                   messageName:@"Settings"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Settings__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch

@implementation KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch

@dynamic isEnabled;

typedef struct KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch__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 = "isEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch_FieldNumber_IsEnabled,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch)
                                   messageName:@"CoordinateMatrixSwitch"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Settings_CoordinateMatrixSwitch__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Settings_ConciergeCall

@implementation KEYAPISDEVICEV1Device_Settings_ConciergeCall

@dynamic isEnabled;
@dynamic orpon;
@dynamic roomNumber;
@dynamic sipNumber;

typedef struct KEYAPISDEVICEV1Device_Settings_ConciergeCall__storage_ {
  uint32_t _has_storage_[1];
  NSString *roomNumber;
  NSString *sipNumber;
  int64_t orpon;
} KEYAPISDEVICEV1Device_Settings_ConciergeCall__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 = "isEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_ConciergeCall_FieldNumber_IsEnabled,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "orpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_ConciergeCall_FieldNumber_Orpon,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings_ConciergeCall__storage_, orpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "roomNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_ConciergeCall_FieldNumber_RoomNumber,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings_ConciergeCall__storage_, roomNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "sipNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_ConciergeCall_FieldNumber_SipNumber,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings_ConciergeCall__storage_, sipNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings_ConciergeCall)
                                   messageName:@"ConciergeCall"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Settings_ConciergeCall__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Settings_Autocollect

@implementation KEYAPISDEVICEV1Device_Settings_Autocollect

@dynamic isEnabled;

typedef struct KEYAPISDEVICEV1Device_Settings_Autocollect__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISDEVICEV1Device_Settings_Autocollect__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 = "isEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_Autocollect_FieldNumber_IsEnabled,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings_Autocollect)
                                   messageName:@"Autocollect"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Settings_Autocollect__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Settings_FaceRecognition

@implementation KEYAPISDEVICEV1Device_Settings_FaceRecognition

@dynamic isEnabled;

typedef struct KEYAPISDEVICEV1Device_Settings_FaceRecognition__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISDEVICEV1Device_Settings_FaceRecognition__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 = "isEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_FaceRecognition_FieldNumber_IsEnabled,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings_FaceRecognition)
                                   messageName:@"FaceRecognition"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Settings_FaceRecognition__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Settings_Sl3Mode

@implementation KEYAPISDEVICEV1Device_Settings_Sl3Mode

@dynamic isEnabled;
@dynamic hasEncryptionProfileId, encryptionProfileId;

typedef struct KEYAPISDEVICEV1Device_Settings_Sl3Mode__storage_ {
  uint32_t _has_storage_[1];
  GPBStringValue *encryptionProfileId;
} KEYAPISDEVICEV1Device_Settings_Sl3Mode__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 = "isEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_Sl3Mode_FieldNumber_IsEnabled,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "encryptionProfileId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_Settings_Sl3Mode_FieldNumber_EncryptionProfileId,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings_Sl3Mode__storage_, encryptionProfileId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings_Sl3Mode)
                                   messageName:@"Sl3Mode"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Settings_Sl3Mode__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Settings_EmergencyCall

@implementation KEYAPISDEVICEV1Device_Settings_EmergencyCall

@dynamic isCallAvailable;
@dynamic emergencyNumber;

typedef struct KEYAPISDEVICEV1Device_Settings_EmergencyCall__storage_ {
  uint32_t _has_storage_[1];
  NSString *emergencyNumber;
} KEYAPISDEVICEV1Device_Settings_EmergencyCall__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 = "isCallAvailable",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_EmergencyCall_FieldNumber_IsCallAvailable,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "emergencyNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Settings_EmergencyCall_FieldNumber_EmergencyNumber,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Settings_EmergencyCall__storage_, emergencyNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings_EmergencyCall)
                                   messageName:@"EmergencyCall"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Settings_EmergencyCall__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_Settings)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Dispatching

@implementation KEYAPISDEVICEV1Device_Dispatching

@dynamic isEnabled;
@dynamic hasPublicIdentity, publicIdentity;

typedef struct KEYAPISDEVICEV1Device_Dispatching__storage_ {
  uint32_t _has_storage_[1];
  GPBStringValue *publicIdentity;
} KEYAPISDEVICEV1Device_Dispatching__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 = "isEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Dispatching_FieldNumber_IsEnabled,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "publicIdentity",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_Dispatching_FieldNumber_PublicIdentity,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Dispatching__storage_, publicIdentity),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Dispatching)
                                   messageName:@"Dispatching"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Dispatching__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_SipTrunk

@implementation KEYAPISDEVICEV1Device_SipTrunk

@dynamic abcNumber;
@dynamic hasHost, host;
@dynamic hasPort, port;
@dynamic sipType;

typedef struct KEYAPISDEVICEV1Device_SipTrunk__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Device_SipTrunk_SipType sipType;
  NSString *abcNumber;
  GPBStringValue *host;
  GPBInt32Value *port;
} KEYAPISDEVICEV1Device_SipTrunk__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 = "abcNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_SipTrunk_FieldNumber_AbcNumber,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SipTrunk__storage_, abcNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "host",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_SipTrunk_FieldNumber_Host,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SipTrunk__storage_, host),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "port",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISDEVICEV1Device_SipTrunk_FieldNumber_Port,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SipTrunk__storage_, port),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "sipType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_SipTrunk_SipType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Device_SipTrunk_FieldNumber_SipType,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SipTrunk__storage_, sipType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_SipTrunk)
                                   messageName:@"SipTrunk"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_SipTrunk__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISDEVICEV1Device_SipTrunk_SipType_RawValue(KEYAPISDEVICEV1Device_SipTrunk *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device_SipTrunk descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_SipTrunk_FieldNumber_SipType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Device_SipTrunk_SipType_RawValue(KEYAPISDEVICEV1Device_SipTrunk *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device_SipTrunk descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_SipTrunk_FieldNumber_SipType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Device_Redirect

@implementation KEYAPISDEVICEV1Device_Redirect

@dynamic isEnabledSip;
@dynamic isEnabledPhone;

typedef struct KEYAPISDEVICEV1Device_Redirect__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISDEVICEV1Device_Redirect__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 = "isEnabledSip",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Redirect_FieldNumber_IsEnabledSip,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "isEnabledPhone",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_Redirect_FieldNumber_IsEnabledPhone,
        .hasIndex = 2,
        .offset = 3,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Redirect)
                                   messageName:@"Redirect"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Redirect__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_AutochangePasswordSettings

@implementation KEYAPISDEVICEV1Device_AutochangePasswordSettings

@dynamic isEnabled;

typedef struct KEYAPISDEVICEV1Device_AutochangePasswordSettings__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISDEVICEV1Device_AutochangePasswordSettings__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 = "isEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_AutochangePasswordSettings_FieldNumber_IsEnabled,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_AutochangePasswordSettings)
                                   messageName:@"AutochangePasswordSettings"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_AutochangePasswordSettings__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_Credentials

@implementation KEYAPISDEVICEV1Device_Credentials

@dynamic hasLogin, login;
@dynamic hasPassword, password;
@dynamic userAccessType;

typedef struct KEYAPISDEVICEV1Device_Credentials__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Device_Credentials_UserAccessType userAccessType;
  GPBStringValue *login;
  GPBStringValue *password;
} KEYAPISDEVICEV1Device_Credentials__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 = "login",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_Credentials_FieldNumber_Login,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Credentials__storage_, login),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Device_Credentials_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Credentials__storage_, password),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userAccessType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_Credentials_UserAccessType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Device_Credentials_FieldNumber_UserAccessType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_Credentials__storage_, userAccessType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_Credentials)
                                   messageName:@"Credentials"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_Credentials__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISDEVICEV1Device_Credentials_UserAccessType_RawValue(KEYAPISDEVICEV1Device_Credentials *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device_Credentials descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_Credentials_FieldNumber_UserAccessType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Device_Credentials_UserAccessType_RawValue(KEYAPISDEVICEV1Device_Credentials *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device_Credentials descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_Credentials_FieldNumber_UserAccessType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Device_SavingError

@implementation KEYAPISDEVICEV1Device_SavingError

@dynamic reasonOneOfCase;
@dynamic macAddressInvalid;
@dynamic serialNumberInvalid;
@dynamic notAllowedForType;
@dynamic notAllowedForModel;
@dynamic serialNumberForModelIsExist;
@dynamic macAddressIsExist;
@dynamic capabilityIsNotSupported;
@dynamic abcNumberIsExistOnAnotherDevice;
@dynamic publicIdentityIsExist;
@dynamic conciergeRoomNotFound;
@dynamic loginIsExist;
@dynamic credentialsAreRequired;
@dynamic fieldIsNotSupported;

typedef struct KEYAPISDEVICEV1Device_SavingError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1Device_SavingError_MacAddressInvalid *macAddressInvalid;
  KEYAPISDEVICEV1Device_SavingError_SerialNumberInvalid *serialNumberInvalid;
  KEYAPISDEVICEV1Device_SavingError_NotAllowedForType *notAllowedForType;
  KEYAPISDEVICEV1Device_SavingError_NotAllowedForModel *notAllowedForModel;
  KEYAPISDEVICEV1Device_SavingError_SerialNumberForModelIsExist *serialNumberForModelIsExist;
  KEYAPISDEVICEV1Device_SavingError_MacAddressIsExist *macAddressIsExist;
  KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported *capabilityIsNotSupported;
  KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice *abcNumberIsExistOnAnotherDevice;
  KEYAPISDEVICEV1Device_SavingError_PublicIdentityIsExist *publicIdentityIsExist;
  KEYAPISDEVICEV1Device_SavingError_ConciergeRoomNotFound *conciergeRoomNotFound;
  KEYAPISDEVICEV1Device_SavingError_LoginIsExist *loginIsExist;
  KEYAPISDEVICEV1Device_SavingError_CredentialsAreRequired *credentialsAreRequired;
  KEYAPISDEVICEV1Device_SavingError_FieldIsNotSupported *fieldIsNotSupported;
} KEYAPISDEVICEV1Device_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 = "macAddressInvalid",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_MacAddressInvalid),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_MacAddressInvalid,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, macAddressInvalid),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "serialNumberInvalid",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_SerialNumberInvalid),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_SerialNumberInvalid,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, serialNumberInvalid),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "notAllowedForType",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_NotAllowedForType),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_NotAllowedForType,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, notAllowedForType),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "notAllowedForModel",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_NotAllowedForModel),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_NotAllowedForModel,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, notAllowedForModel),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "serialNumberForModelIsExist",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_SerialNumberForModelIsExist),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_SerialNumberForModelIsExist,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, serialNumberForModelIsExist),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "macAddressIsExist",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_MacAddressIsExist),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_MacAddressIsExist,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, macAddressIsExist),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "capabilityIsNotSupported",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_CapabilityIsNotSupported,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, capabilityIsNotSupported),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "abcNumberIsExistOnAnotherDevice",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_AbcNumberIsExistOnAnotherDevice,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, abcNumberIsExistOnAnotherDevice),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "publicIdentityIsExist",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_PublicIdentityIsExist),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_PublicIdentityIsExist,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, publicIdentityIsExist),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "conciergeRoomNotFound",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_ConciergeRoomNotFound),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_ConciergeRoomNotFound,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, conciergeRoomNotFound),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "loginIsExist",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_LoginIsExist),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_LoginIsExist,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, loginIsExist),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "credentialsAreRequired",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_CredentialsAreRequired),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_CredentialsAreRequired,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, credentialsAreRequired),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "fieldIsNotSupported",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_FieldIsNotSupported),
        .number = KEYAPISDEVICEV1Device_SavingError_FieldNumber_FieldIsNotSupported,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError__storage_, fieldIsNotSupported),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_SavingError)
                                   messageName:@"SavingError"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_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(KEYAPISDEVICEV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1Device_SavingError_MacAddressInvalid


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_SerialNumberInvalid

@implementation KEYAPISDEVICEV1Device_SavingError_SerialNumberInvalid


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_NotAllowedForType

@implementation KEYAPISDEVICEV1Device_SavingError_NotAllowedForType


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_NotAllowedForModel

@implementation KEYAPISDEVICEV1Device_SavingError_NotAllowedForModel


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_SerialNumberForModelIsExist

@implementation KEYAPISDEVICEV1Device_SavingError_SerialNumberForModelIsExist


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_MacAddressIsExist

@implementation KEYAPISDEVICEV1Device_SavingError_MacAddressIsExist


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported

@implementation KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported

@dynamic modelCapabilityType;

typedef struct KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Model_CapabilityType modelCapabilityType;
} KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported__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 = "modelCapabilityType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Model_CapabilityType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported_FieldNumber_ModelCapabilityType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported__storage_, modelCapabilityType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported)
                                   messageName:@"CapabilityIsNotSupported"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported_ModelCapabilityType_RawValue(KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported_FieldNumber_ModelCapabilityType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported_ModelCapabilityType_RawValue(KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Device_SavingError_CapabilityIsNotSupported_FieldNumber_ModelCapabilityType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice

@implementation KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice

@dynamic deviceId;

typedef struct KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice__storage_ {
  uint32_t _has_storage_[1];
  int32_t deviceId;
} KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice__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 = "deviceId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice_FieldNumber_DeviceId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice__storage_, deviceId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice)
                                   messageName:@"AbcNumberIsExistOnAnotherDevice"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Device_SavingError_AbcNumberIsExistOnAnotherDevice__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Device_SavingError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_PublicIdentityIsExist

@implementation KEYAPISDEVICEV1Device_SavingError_PublicIdentityIsExist


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_ConciergeRoomNotFound

@implementation KEYAPISDEVICEV1Device_SavingError_ConciergeRoomNotFound


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_LoginIsExist

@implementation KEYAPISDEVICEV1Device_SavingError_LoginIsExist


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_CredentialsAreRequired

@implementation KEYAPISDEVICEV1Device_SavingError_CredentialsAreRequired


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

@end

#pragma mark - KEYAPISDEVICEV1Device_SavingError_FieldIsNotSupported

@implementation KEYAPISDEVICEV1Device_SavingError_FieldIsNotSupported


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

@end

#pragma mark - KEYAPISDEVICEV1DeviceLite

@implementation KEYAPISDEVICEV1DeviceLite

@dynamic id_p;
@dynamic type;
@dynamic title;
@dynamic hasLocation, location;
@dynamic statusType;

typedef struct KEYAPISDEVICEV1DeviceLite__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  KEYAPISDEVICEV1Device_Type type;
  KEYAPISDEVICEV1Device_StatusType statusType;
  NSString *title;
  KEYAPISDEVICEV1Device_Location *location;
} KEYAPISDEVICEV1DeviceLite__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 = KEYAPISDEVICEV1DeviceLite_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceLite__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_Type_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceLite_FieldNumber_Type,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceLite__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "title",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceLite_FieldNumber_Title,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceLite__storage_, title),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "location",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_Location),
        .number = KEYAPISDEVICEV1DeviceLite_FieldNumber_Location,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceLite__storage_, location),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceLite_FieldNumber_StatusType,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceLite__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceLite)
                                   messageName:@"DeviceLite"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceLite__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 KEYAPISDEVICEV1DeviceLite_Type_RawValue(KEYAPISDEVICEV1DeviceLite *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceLite_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DeviceLite_Type_RawValue(KEYAPISDEVICEV1DeviceLite *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceLite_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISDEVICEV1DeviceLite_StatusType_RawValue(KEYAPISDEVICEV1DeviceLite *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceLite_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DeviceLite_StatusType_RawValue(KEYAPISDEVICEV1DeviceLite *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceLite_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1DeviceConfigurationStatus

@implementation KEYAPISDEVICEV1DeviceConfigurationStatus

@dynamic id_p;
@dynamic deviceId;
@dynamic configurationType;
@dynamic statusType;
@dynamic hasConfiguredAt, configuredAt;
@dynamic hasErrorMessage, errorMessage;
@dynamic retryCount;
@dynamic hasPayload, payload;
@dynamic hasNextRetryAt, nextRetryAt;

typedef struct KEYAPISDEVICEV1DeviceConfigurationStatus__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  int32_t deviceId;
  KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType configurationType;
  KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType statusType;
  int32_t retryCount;
  GPBTimestamp *configuredAt;
  GPBStringValue *errorMessage;
  KEYAPISDEVICEV1DeviceConfigurationStatus_Payload *payload;
  GPBTimestamp *nextRetryAt;
} KEYAPISDEVICEV1DeviceConfigurationStatus__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 = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "deviceId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_DeviceId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, deviceId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "configurationType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_ConfigurationType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, configurationType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_StatusType,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "configuredAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_ConfiguredAt,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, configuredAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "errorMessage",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_ErrorMessage,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, errorMessage),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "retryCount",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_RetryCount,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, retryCount),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "payload",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_Payload,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, payload),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "nextRetryAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_NextRetryAt,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus__storage_, nextRetryAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus)
                                   messageName:@"DeviceConfigurationStatus"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceConfigurationStatus__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 KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatus *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_ConfigurationType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatus *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_ConfigurationType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatus *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatus *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatus_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1DeviceConfigurationStatus_Payload

@implementation KEYAPISDEVICEV1DeviceConfigurationStatus_Payload

@dynamic attributeOneOfCase;
@dynamic autocollect;

typedef struct KEYAPISDEVICEV1DeviceConfigurationStatus_Payload__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect *autocollect;
} KEYAPISDEVICEV1DeviceConfigurationStatus_Payload__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 = "autocollect",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_FieldNumber_Autocollect,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload__storage_, autocollect),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload)
                                   messageName:@"Payload"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "attribute",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect

@dynamic hasEnabledAt, enabledAt;
@dynamic hasToBeDisabledAt, toBeDisabledAt;

typedef struct KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect__storage_ {
  uint32_t _has_storage_[1];
  GPBTimestamp *enabledAt;
  GPBTimestamp *toBeDisabledAt;
} KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect__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 = "enabledAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect_FieldNumber_EnabledAt,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect__storage_, enabledAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "toBeDisabledAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect_FieldNumber_ToBeDisabledAt,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect__storage_, toBeDisabledAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect)
                                   messageName:@"Autocollect"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload_Autocollect__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus_Payload)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1DeviceConfigurationStatusGrouped

@implementation KEYAPISDEVICEV1DeviceConfigurationStatusGrouped

@dynamic deviceId;
@dynamic statusesArray, statusesArray_Count;

typedef struct KEYAPISDEVICEV1DeviceConfigurationStatusGrouped__storage_ {
  uint32_t _has_storage_[1];
  int32_t deviceId;
  NSMutableArray *statusesArray;
} KEYAPISDEVICEV1DeviceConfigurationStatusGrouped__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 = "deviceId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGrouped_FieldNumber_DeviceId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGrouped__storage_, deviceId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "statusesArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGrouped_FieldNumber_StatusesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGrouped__storage_, statusesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatusGrouped)
                                   messageName:@"DeviceConfigurationStatusGrouped"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceConfigurationStatusGrouped__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 - KEYAPISDEVICEV1CameraStatus

@implementation KEYAPISDEVICEV1CameraStatus

@dynamic hasId_p, id_p;
@dynamic statusType;
@dynamic errorMessage;

typedef struct KEYAPISDEVICEV1CameraStatus__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1CameraStatus_StatusType statusType;
  GPBStringValue *id_p;
  NSString *errorMessage;
} KEYAPISDEVICEV1CameraStatus__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 = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1CameraStatus_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1CameraStatus__storage_, id_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1CameraStatus_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1CameraStatus_FieldNumber_StatusType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1CameraStatus__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "errorMessage",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1CameraStatus_FieldNumber_ErrorMessage,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1CameraStatus__storage_, errorMessage),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1CameraStatus)
                                   messageName:@"CameraStatus"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1CameraStatus__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 KEYAPISDEVICEV1CameraStatus_StatusType_RawValue(KEYAPISDEVICEV1CameraStatus *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1CameraStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1CameraStatus_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1CameraStatus_StatusType_RawValue(KEYAPISDEVICEV1CameraStatus *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1CameraStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1CameraStatus_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1SyncStatus

@implementation KEYAPISDEVICEV1SyncStatus

@dynamic statusType;
@dynamic errorMessage;
@dynamic retryCount;
@dynamic hasSuccessfulAt, successfulAt;
@dynamic hasSyncAt, syncAt;

typedef struct KEYAPISDEVICEV1SyncStatus__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1SyncStatus_StatusType statusType;
  int32_t retryCount;
  NSString *errorMessage;
  GPBTimestamp *successfulAt;
  GPBTimestamp *syncAt;
} KEYAPISDEVICEV1SyncStatus__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 = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1SyncStatus_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1SyncStatus_FieldNumber_StatusType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1SyncStatus__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "errorMessage",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1SyncStatus_FieldNumber_ErrorMessage,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1SyncStatus__storage_, errorMessage),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "retryCount",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1SyncStatus_FieldNumber_RetryCount,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1SyncStatus__storage_, retryCount),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "successfulAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1SyncStatus_FieldNumber_SuccessfulAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1SyncStatus__storage_, successfulAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "syncAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1SyncStatus_FieldNumber_SyncAt,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1SyncStatus__storage_, syncAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1SyncStatus)
                                   messageName:@"SyncStatus"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1SyncStatus__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 KEYAPISDEVICEV1SyncStatus_StatusType_RawValue(KEYAPISDEVICEV1SyncStatus *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1SyncStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1SyncStatus_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1SyncStatus_StatusType_RawValue(KEYAPISDEVICEV1SyncStatus *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1SyncStatus descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1SyncStatus_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1GetDeviceRequest

@implementation KEYAPISDEVICEV1GetDeviceRequest

@dynamic id_p;

typedef struct KEYAPISDEVICEV1GetDeviceRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISDEVICEV1GetDeviceRequest__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 = KEYAPISDEVICEV1GetDeviceRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceRequest)
                                   messageName:@"GetDeviceRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceRequest__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 - KEYAPISDEVICEV1GetDeviceResponse

@implementation KEYAPISDEVICEV1GetDeviceResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISDEVICEV1GetDeviceResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1Device *data_p;
} KEYAPISDEVICEV1GetDeviceResponse__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(KEYAPISDEVICEV1Device),
        .number = KEYAPISDEVICEV1GetDeviceResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceResponse)
                                   messageName:@"GetDeviceResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceResponse__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 KEYAPISDEVICEV1GetDeviceResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1GetDeviceResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1GetDeviceLiteRequest

@implementation KEYAPISDEVICEV1GetDeviceLiteRequest

@dynamic id_p;

typedef struct KEYAPISDEVICEV1GetDeviceLiteRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISDEVICEV1GetDeviceLiteRequest__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 = KEYAPISDEVICEV1GetDeviceLiteRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceLiteRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceLiteRequest)
                                   messageName:@"GetDeviceLiteRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceLiteRequest__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 - KEYAPISDEVICEV1GetDeviceLiteResponse

@implementation KEYAPISDEVICEV1GetDeviceLiteResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISDEVICEV1GetDeviceLiteResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1DeviceLite *data_p;
} KEYAPISDEVICEV1GetDeviceLiteResponse__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(KEYAPISDEVICEV1DeviceLite),
        .number = KEYAPISDEVICEV1GetDeviceLiteResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceLiteResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceLiteResponse)
                                   messageName:@"GetDeviceLiteResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceLiteResponse__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 KEYAPISDEVICEV1GetDeviceLiteResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1GetDeviceLiteResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceLiteResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1PostDeviceRequest

@implementation KEYAPISDEVICEV1PostDeviceRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISDEVICEV1PostDeviceRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Device *data_p;
} KEYAPISDEVICEV1PostDeviceRequest__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(KEYAPISDEVICEV1Device),
        .number = KEYAPISDEVICEV1PostDeviceRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceRequest)
                                   messageName:@"PostDeviceRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceRequest__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 - KEYAPISDEVICEV1PostDeviceResponse

@implementation KEYAPISDEVICEV1PostDeviceResponse

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

typedef struct KEYAPISDEVICEV1PostDeviceResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1Device *data_p;
  KEYAPISDEVICEV1PostDeviceResponse_Error *error;
} KEYAPISDEVICEV1PostDeviceResponse__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(KEYAPISDEVICEV1Device),
        .number = KEYAPISDEVICEV1PostDeviceResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceResponse_Error),
        .number = KEYAPISDEVICEV1PostDeviceResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceResponse)
                                   messageName:@"PostDeviceResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceResponse__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 KEYAPISDEVICEV1PostDeviceResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1PostDeviceResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1PostDeviceResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1PostDeviceResponse_Error

@implementation KEYAPISDEVICEV1PostDeviceResponse_Error

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

typedef struct KEYAPISDEVICEV1PostDeviceResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1ValidationError *validation;
  KEYAPISDEVICEV1Device_SavingError *saving;
} KEYAPISDEVICEV1PostDeviceResponse_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(KEYAPISDEVICEV1ValidationError),
        .number = KEYAPISDEVICEV1PostDeviceResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "saving",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Device_SavingError),
        .number = KEYAPISDEVICEV1PostDeviceResponse_Error_FieldNumber_Saving,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceResponse_Error__storage_, saving),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceResponse_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(KEYAPISDEVICEV1PostDeviceResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1GetDeviceListRequest

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

typedef struct KEYAPISDEVICEV1GetDeviceListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1DeviceFilter *filter;
  KEYAPISDEVICEV1DevicePaging *paging;
} KEYAPISDEVICEV1GetDeviceListRequest__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(KEYAPISDEVICEV1DeviceFilter),
        .number = KEYAPISDEVICEV1GetDeviceListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1DevicePaging),
        .number = KEYAPISDEVICEV1GetDeviceListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceListRequest)
                                   messageName:@"GetDeviceListRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceListRequest__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 KEYAPISDEVICEV1GetDeviceListRequest_ClearPaginationOneOfCase(KEYAPISDEVICEV1GetDeviceListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1GetDeviceListResponse

@implementation KEYAPISDEVICEV1GetDeviceListResponse

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

typedef struct KEYAPISDEVICEV1GetDeviceListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1Device *data_p;
  KEYAPISDEVICEV1GetDeviceListResponse_Error *error;
} KEYAPISDEVICEV1GetDeviceListResponse__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(KEYAPISDEVICEV1Device),
        .number = KEYAPISDEVICEV1GetDeviceListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1GetDeviceListResponse_Error),
        .number = KEYAPISDEVICEV1GetDeviceListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceListResponse)
                                   messageName:@"GetDeviceListResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceListResponse__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 KEYAPISDEVICEV1GetDeviceListResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1GetDeviceListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1GetDeviceListResponse_Error

@implementation KEYAPISDEVICEV1GetDeviceListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISDEVICEV1GetDeviceCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISDEVICEV1GetDeviceCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1DeviceFilter *filter;
} KEYAPISDEVICEV1GetDeviceCountRequest__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(KEYAPISDEVICEV1DeviceFilter),
        .number = KEYAPISDEVICEV1GetDeviceCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceCountRequest)
                                   messageName:@"GetDeviceCountRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceCountRequest__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 - KEYAPISDEVICEV1GetDeviceCountResponse

@implementation KEYAPISDEVICEV1GetDeviceCountResponse

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

typedef struct KEYAPISDEVICEV1GetDeviceCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
  KEYAPISDEVICEV1GetDeviceCountResponse_Error *error;
} KEYAPISDEVICEV1GetDeviceCountResponse__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 = KEYAPISDEVICEV1GetDeviceCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1GetDeviceCountResponse_Error),
        .number = KEYAPISDEVICEV1GetDeviceCountResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceCountResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceCountResponse)
                                   messageName:@"GetDeviceCountResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceCountResponse__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 KEYAPISDEVICEV1GetDeviceCountResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1GetDeviceCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1GetDeviceCountResponse_Error

@implementation KEYAPISDEVICEV1GetDeviceCountResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISDEVICEV1PutDeviceRequest

@dynamic id_p;
@dynamic presetId;
@dynamic isSl3ModeEnabled;

typedef struct KEYAPISDEVICEV1PutDeviceRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  int32_t presetId;
} KEYAPISDEVICEV1PutDeviceRequest__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 = KEYAPISDEVICEV1PutDeviceRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PutDeviceRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "presetId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1PutDeviceRequest_FieldNumber_PresetId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PutDeviceRequest__storage_, presetId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "isSl3ModeEnabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1PutDeviceRequest_FieldNumber_IsSl3ModeEnabled,
        .hasIndex = 2,
        .offset = 3,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PutDeviceRequest)
                                   messageName:@"PutDeviceRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PutDeviceRequest__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 - KEYAPISDEVICEV1PutDeviceResponse

@implementation KEYAPISDEVICEV1PutDeviceResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISDEVICEV1PutDeviceResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1Device *data_p;
} KEYAPISDEVICEV1PutDeviceResponse__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(KEYAPISDEVICEV1Device),
        .number = KEYAPISDEVICEV1PutDeviceResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PutDeviceResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PutDeviceResponse)
                                   messageName:@"PutDeviceResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PutDeviceResponse__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 KEYAPISDEVICEV1PutDeviceResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1PutDeviceResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1PutDeviceResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1PostDeviceInstallPresetRequest

@implementation KEYAPISDEVICEV1PostDeviceInstallPresetRequest

@dynamic id_p;

typedef struct KEYAPISDEVICEV1PostDeviceInstallPresetRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISDEVICEV1PostDeviceInstallPresetRequest__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 = KEYAPISDEVICEV1PostDeviceInstallPresetRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceInstallPresetRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceInstallPresetRequest)
                                   messageName:@"PostDeviceInstallPresetRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceInstallPresetRequest__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 - KEYAPISDEVICEV1PostDeviceInstallPresetResponse

@implementation KEYAPISDEVICEV1PostDeviceInstallPresetResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISDEVICEV1PostDeviceInstallPresetResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error *error;
} KEYAPISDEVICEV1PostDeviceInstallPresetResponse__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(KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error),
        .number = KEYAPISDEVICEV1PostDeviceInstallPresetResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceInstallPresetResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceInstallPresetResponse)
                                   messageName:@"PostDeviceInstallPresetResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceInstallPresetResponse__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 KEYAPISDEVICEV1PostDeviceInstallPresetResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1PostDeviceInstallPresetResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1PostDeviceInstallPresetResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error

@implementation KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error

@dynamic reasonOneOfCase;
@dynamic presetStatusIsProcessing;

typedef struct KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error_PresetStatusIsProcessing *presetStatusIsProcessing;
} KEYAPISDEVICEV1PostDeviceInstallPresetResponse_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 = "presetStatusIsProcessing",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error_PresetStatusIsProcessing),
        .number = KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error_FieldNumber_PresetStatusIsProcessing,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error__storage_, presetStatusIsProcessing),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceInstallPresetResponse_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(KEYAPISDEVICEV1PostDeviceInstallPresetResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1PostDeviceInstallPresetResponse_Error_PresetStatusIsProcessing


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

@end

#pragma mark - KEYAPISDEVICEV1PostDeviceReplaceRequest

@implementation KEYAPISDEVICEV1PostDeviceReplaceRequest

@dynamic id_p;
@dynamic host;
@dynamic macAddress;
@dynamic serialNumber;
@dynamic login;

typedef struct KEYAPISDEVICEV1PostDeviceReplaceRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  NSString *host;
  NSString *macAddress;
  NSString *serialNumber;
  NSString *login;
} KEYAPISDEVICEV1PostDeviceReplaceRequest__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 = KEYAPISDEVICEV1PostDeviceReplaceRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "host",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1PostDeviceReplaceRequest_FieldNumber_Host,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceRequest__storage_, host),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "macAddress",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1PostDeviceReplaceRequest_FieldNumber_MacAddress,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceRequest__storage_, macAddress),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "serialNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1PostDeviceReplaceRequest_FieldNumber_SerialNumber,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceRequest__storage_, serialNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "login",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1PostDeviceReplaceRequest_FieldNumber_Login,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceRequest__storage_, login),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceRequest)
                                   messageName:@"PostDeviceReplaceRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceReplaceRequest__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 - KEYAPISDEVICEV1PostDeviceReplaceResponse

@implementation KEYAPISDEVICEV1PostDeviceReplaceResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISDEVICEV1PostDeviceReplaceResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1PostDeviceReplaceResponse_Error *error;
} KEYAPISDEVICEV1PostDeviceReplaceResponse__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(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceResponse)
                                   messageName:@"PostDeviceReplaceResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceReplaceResponse__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 KEYAPISDEVICEV1PostDeviceReplaceResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1PostDeviceReplaceResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1PostDeviceReplaceResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1PostDeviceReplaceResponse_Error

@implementation KEYAPISDEVICEV1PostDeviceReplaceResponse_Error

@dynamic reasonOneOfCase;
@dynamic validationError;
@dynamic hostExists;
@dynamic macAddressExists;
@dynamic serialNumberExists;
@dynamic loginExists;
@dynamic loginIsRequired;
@dynamic reinstallError;

typedef struct KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1ValidationError *validationError;
  KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_HostExists *hostExists;
  KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_MacAddressExists *macAddressExists;
  KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_SerialNumberExists *serialNumberExists;
  KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginExists *loginExists;
  KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginIsRequired *loginIsRequired;
  KEYAPISDEVICEV1ReinstallError *reinstallError;
} KEYAPISDEVICEV1PostDeviceReplaceResponse_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 = "validationError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1ValidationError),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_FieldNumber_ValidationError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_, validationError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "hostExists",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_HostExists),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_FieldNumber_HostExists,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_, hostExists),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "macAddressExists",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_MacAddressExists),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_FieldNumber_MacAddressExists,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_, macAddressExists),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "serialNumberExists",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_SerialNumberExists),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_FieldNumber_SerialNumberExists,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_, serialNumberExists),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "loginExists",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginExists),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_FieldNumber_LoginExists,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_, loginExists),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "loginIsRequired",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginIsRequired),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_FieldNumber_LoginIsRequired,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_, loginIsRequired),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "reinstallError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1ReinstallError),
        .number = KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_FieldNumber_ReinstallError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error__storage_, reinstallError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceReplaceResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceReplaceResponse_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(KEYAPISDEVICEV1PostDeviceReplaceResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_HostExists


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

@end

#pragma mark - KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_MacAddressExists

@implementation KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_MacAddressExists


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

@end

#pragma mark - KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_SerialNumberExists

@implementation KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_SerialNumberExists


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

@end

#pragma mark - KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginExists

@implementation KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginExists


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

@end

#pragma mark - KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginIsRequired

@implementation KEYAPISDEVICEV1PostDeviceReplaceResponse_Error_LoginIsRequired


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

@end

#pragma mark - KEYAPISDEVICEV1PostDeviceReconfigureRequest

@implementation KEYAPISDEVICEV1PostDeviceReconfigureRequest

@dynamic id_p;

typedef struct KEYAPISDEVICEV1PostDeviceReconfigureRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISDEVICEV1PostDeviceReconfigureRequest__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 = KEYAPISDEVICEV1PostDeviceReconfigureRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReconfigureRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceReconfigureRequest)
                                   messageName:@"PostDeviceReconfigureRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceReconfigureRequest__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 - KEYAPISDEVICEV1PostDeviceReconfigureResponse

@implementation KEYAPISDEVICEV1PostDeviceReconfigureResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISDEVICEV1PostDeviceReconfigureResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error *error;
} KEYAPISDEVICEV1PostDeviceReconfigureResponse__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(KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error),
        .number = KEYAPISDEVICEV1PostDeviceReconfigureResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReconfigureResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceReconfigureResponse)
                                   messageName:@"PostDeviceReconfigureResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceReconfigureResponse__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 KEYAPISDEVICEV1PostDeviceReconfigureResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1PostDeviceReconfigureResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1PostDeviceReconfigureResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error

@implementation KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error

@dynamic reasonOneOfCase;
@dynamic validationError;
@dynamic reinstallError;

typedef struct KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1ValidationError *validationError;
  KEYAPISDEVICEV1ReinstallError *reinstallError;
} KEYAPISDEVICEV1PostDeviceReconfigureResponse_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 = "validationError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1ValidationError),
        .number = KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error_FieldNumber_ValidationError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error__storage_, validationError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "reinstallError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1ReinstallError),
        .number = KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error_FieldNumber_ReinstallError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error__storage_, reinstallError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceReconfigureResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceReconfigureResponse_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(KEYAPISDEVICEV1PostDeviceReconfigureResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest

@dynamic id_p;

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest__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 = KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest)
                                   messageName:@"GetDeviceConfigurationStatusesRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesRequest__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 - KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse

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

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses *data_p;
  KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error *error;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse__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(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse)
                                   messageName:@"GetDeviceConfigurationStatusesResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse__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 KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses

@dynamic deviceConfigurationStatusesArray, deviceConfigurationStatusesArray_Count;
@dynamic hasCameraStatus, cameraStatus;
@dynamic hasSyncStatus, syncStatus;
@dynamic deviceStatusType;

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Device_StatusType deviceStatusType;
  NSMutableArray *deviceConfigurationStatusesArray;
  KEYAPISDEVICEV1CameraStatus *cameraStatus;
  KEYAPISDEVICEV1SyncStatus *syncStatus;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses__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 = "deviceConfigurationStatusesArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatus),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_FieldNumber_DeviceConfigurationStatusesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses__storage_, deviceConfigurationStatusesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "cameraStatus",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1CameraStatus),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_FieldNumber_CameraStatus,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses__storage_, cameraStatus),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "syncStatus",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1SyncStatus),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_FieldNumber_SyncStatus,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses__storage_, syncStatus),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "deviceStatusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_FieldNumber_DeviceStatusType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses__storage_, deviceStatusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses)
                                   messageName:@"Statuses"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_DeviceStatusType_RawValue(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_FieldNumber_DeviceStatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_DeviceStatusType_RawValue(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Statuses_FieldNumber_DeviceStatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error

@dynamic reasonOneOfCase;
@dynamic validationError;

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1ValidationError *validationError;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_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 = "validationError",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1ValidationError),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error_FieldNumber_ValidationError,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error__storage_, validationError),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse_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(KEYAPISDEVICEV1GetDeviceConfigurationStatusesResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1DeviceConfigurationStatus *data_p;
} KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest__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(KEYAPISDEVICEV1DeviceConfigurationStatus),
        .number = KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest)
                                   messageName:@"PostDeviceConfigurationStatusRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceConfigurationStatusRequest__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 - KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse

@implementation KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse

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

typedef struct KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1DeviceConfigurationStatus *data_p;
  KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_Error *error;
} KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse__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(KEYAPISDEVICEV1DeviceConfigurationStatus),
        .number = KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_Error),
        .number = KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse)
                                   messageName:@"PostDeviceConfigurationStatusResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse__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 KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_Error

@implementation KEYAPISDEVICEV1PostDeviceConfigurationStatusResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest

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

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter *filter;
  KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging *paging;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest__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(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest)
                                   messageName:@"GetDeviceConfigurationStatusGroupedListRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest__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 KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest_ClearPaginationOneOfCase(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse

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

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1DeviceConfigurationStatusGrouped *data_p;
  KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_Error *error;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse__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(KEYAPISDEVICEV1DeviceConfigurationStatusGrouped),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_Error),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse)
                                   messageName:@"GetDeviceConfigurationStatusGroupedListResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse__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 KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_Error

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter *filter;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest__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(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter),
        .number = KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest)
                                   messageName:@"GetDeviceConfigurationStatusGroupedCountRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountRequest__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 - KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse

@implementation KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
} KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse__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 = KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse)
                                   messageName:@"GetDeviceConfigurationStatusGroupedCountResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse__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 KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse_ClearTypeOneOfCase(KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1GetDeviceConfigurationStatusGroupedCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISDEVICEV1DeleteDeviceRequest

@implementation KEYAPISDEVICEV1DeleteDeviceRequest

@dynamic id_p;

typedef struct KEYAPISDEVICEV1DeleteDeviceRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISDEVICEV1DeleteDeviceRequest__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 = KEYAPISDEVICEV1DeleteDeviceRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeleteDeviceRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeleteDeviceRequest)
                                   messageName:@"DeleteDeviceRequest"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeleteDeviceRequest__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 - KEYAPISDEVICEV1DeleteDeviceResponse

@implementation KEYAPISDEVICEV1DeleteDeviceResponse


typedef struct KEYAPISDEVICEV1DeleteDeviceResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISDEVICEV1DeleteDeviceResponse__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(KEYAPISDEVICEV1DeleteDeviceResponse)
                                   messageName:@"DeleteDeviceResponse"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISDEVICEV1DeleteDeviceResponse__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 - KEYAPISDEVICEV1ReinstallError

@implementation KEYAPISDEVICEV1ReinstallError

@dynamic reasonOneOfCase;
@dynamic sipLoginIsMissing;

typedef struct KEYAPISDEVICEV1ReinstallError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1ReinstallError_SipLoginIsMissing *sipLoginIsMissing;
} KEYAPISDEVICEV1ReinstallError__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 = "sipLoginIsMissing",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1ReinstallError_SipLoginIsMissing),
        .number = KEYAPISDEVICEV1ReinstallError_FieldNumber_SipLoginIsMissing,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1ReinstallError__storage_, sipLoginIsMissing),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1ReinstallError)
                                   messageName:@"ReinstallError"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1ReinstallError__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];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1ReinstallError_SipLoginIsMissing


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

@end

#pragma mark - KEYAPISDEVICEV1DeviceFilter

@implementation KEYAPISDEVICEV1DeviceFilter

@dynamic ownerCompanyIdsArray, ownerCompanyIdsArray_Count;
@dynamic hasText, text;
@dynamic flatgrammIdsArray, flatgrammIdsArray_Count;
@dynamic serialNumbersArray, serialNumbersArray_Count;
@dynamic deviceStatusTypesArray, deviceStatusTypesArray_Count;
@dynamic deviceTypesArray, deviceTypesArray_Count;
@dynamic deviceModelTypesArray, deviceModelTypesArray_Count;
@dynamic hasIsConciergeEnabled, isConciergeEnabled;
@dynamic hasIsDispatchingEnabled, isDispatchingEnabled;
@dynamic hasDispatchingPublicNumber, dispatchingPublicNumber;
@dynamic hasHardwareVersion, hardwareVersion;
@dynamic hasSoftwareVersion, softwareVersion;
@dynamic hasIsAutochangePasswordEnabled, isAutochangePasswordEnabled;
@dynamic abcNumberArray, abcNumberArray_Count;
@dynamic cameraIdsArray, cameraIdsArray_Count;
@dynamic syncStatusStatusTypesArray, syncStatusStatusTypesArray_Count;
@dynamic hasSyncRetryCountLessThen, syncRetryCountLessThen;
@dynamic hasBeginSyncSuccessfulAt, beginSyncSuccessfulAt;
@dynamic hasEndSyncSuccessfulAt, endSyncSuccessfulAt;
@dynamic hasBeginSyncAt, beginSyncAt;
@dynamic hasEndSyncAt, endSyncAt;

typedef struct KEYAPISDEVICEV1DeviceFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBInt32Array *ownerCompanyIdsArray;
  GPBStringValue *text;
  GPBInt32Array *flatgrammIdsArray;
  NSMutableArray *serialNumbersArray;
  GPBEnumArray *deviceStatusTypesArray;
  GPBEnumArray *deviceTypesArray;
  GPBEnumArray *deviceModelTypesArray;
  GPBBoolValue *isConciergeEnabled;
  GPBBoolValue *isDispatchingEnabled;
  GPBStringValue *dispatchingPublicNumber;
  GPBStringValue *hardwareVersion;
  GPBStringValue *softwareVersion;
  GPBBoolValue *isAutochangePasswordEnabled;
  NSMutableArray *abcNumberArray;
  NSMutableArray *cameraIdsArray;
  GPBEnumArray *syncStatusStatusTypesArray;
  GPBInt32Value *syncRetryCountLessThen;
  GPBTimestamp *beginSyncSuccessfulAt;
  GPBTimestamp *endSyncSuccessfulAt;
  GPBTimestamp *beginSyncAt;
  GPBTimestamp *endSyncAt;
} KEYAPISDEVICEV1DeviceFilter__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 = "ownerCompanyIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_OwnerCompanyIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, ownerCompanyIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "text",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_Text,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, text),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "flatgrammIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_FlatgrammIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, flatgrammIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "serialNumbersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_SerialNumbersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, serialNumbersArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "deviceStatusTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_DeviceStatusTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, deviceStatusTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "deviceTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_Type_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_DeviceTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, deviceTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "deviceModelTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Device_ModelType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_DeviceModelTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, deviceModelTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "isConciergeEnabled",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBBoolValue),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_IsConciergeEnabled,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, isConciergeEnabled),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "isDispatchingEnabled",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBBoolValue),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_IsDispatchingEnabled,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, isDispatchingEnabled),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "dispatchingPublicNumber",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_DispatchingPublicNumber,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, dispatchingPublicNumber),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "hardwareVersion",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_HardwareVersion,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, hardwareVersion),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "softwareVersion",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_SoftwareVersion,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, softwareVersion),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "isAutochangePasswordEnabled",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBBoolValue),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_IsAutochangePasswordEnabled,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, isAutochangePasswordEnabled),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "abcNumberArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_AbcNumberArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, abcNumberArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "cameraIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_CameraIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, cameraIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "syncStatusStatusTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1SyncStatus_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_SyncStatusStatusTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, syncStatusStatusTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "syncRetryCountLessThen",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_SyncRetryCountLessThen,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, syncRetryCountLessThen),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "beginSyncSuccessfulAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_BeginSyncSuccessfulAt,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, beginSyncSuccessfulAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "endSyncSuccessfulAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_EndSyncSuccessfulAt,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, endSyncSuccessfulAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "beginSyncAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_BeginSyncAt,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, beginSyncAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "endSyncAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1DeviceFilter_FieldNumber_EndSyncAt,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceFilter__storage_, endSyncAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceFilter)
                                   messageName:@"DeviceFilter"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceFilter__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 - KEYAPISDEVICEV1DevicePaging

@implementation KEYAPISDEVICEV1DevicePaging

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

typedef struct KEYAPISDEVICEV1DevicePaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1DevicePaging_OrderByType orderByType;
  KEYAPISDEVICEV1DevicePaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISDEVICEV1DevicePaging__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 = KEYAPISDEVICEV1DevicePaging_OrderByType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DevicePaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DevicePaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1DevicePaging_DirectionType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DevicePaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DevicePaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DevicePaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DevicePaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DevicePaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DevicePaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DevicePaging)
                                   messageName:@"DevicePaging"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DevicePaging__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 KEYAPISDEVICEV1DevicePaging_OrderByType_RawValue(KEYAPISDEVICEV1DevicePaging *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DevicePaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DevicePaging_OrderByType_RawValue(KEYAPISDEVICEV1DevicePaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DevicePaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISDEVICEV1DevicePaging_DirectionType_RawValue(KEYAPISDEVICEV1DevicePaging *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DevicePaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DevicePaging_DirectionType_RawValue(KEYAPISDEVICEV1DevicePaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DevicePaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter

@implementation KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter

@dynamic deviceIdsArray, deviceIdsArray_Count;
@dynamic configurationTypesArray, configurationTypesArray_Count;
@dynamic statusTypesArray, statusTypesArray_Count;
@dynamic hasIsReadyForRetry, isReadyForRetry;
@dynamic hasRetryCountLessThen, retryCountLessThen;

typedef struct KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBInt32Array *deviceIdsArray;
  GPBEnumArray *configurationTypesArray;
  GPBEnumArray *statusTypesArray;
  GPBBoolValue *isReadyForRetry;
  GPBInt32Value *retryCountLessThen;
} KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__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 = "deviceIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter_FieldNumber_DeviceIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__storage_, deviceIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "configurationTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1DeviceConfigurationStatus_ConfigurationType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter_FieldNumber_ConfigurationTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__storage_, configurationTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "statusTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1DeviceConfigurationStatus_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter_FieldNumber_StatusTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__storage_, statusTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "isReadyForRetry",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBBoolValue),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter_FieldNumber_IsReadyForRetry,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__storage_, isReadyForRetry),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "retryCountLessThen",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter_FieldNumber_RetryCountLessThen,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__storage_, retryCountLessThen),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter)
                                   messageName:@"DeviceConfigurationStatusGroupedFilter"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedFilter__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 - KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging

@implementation KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging

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

typedef struct KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType orderByType;
  KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging__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 = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging)
                                   messageName:@"DeviceConfigurationStatusGroupedPaging"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging__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 KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_OrderByType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_DirectionType_RawValue(KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1DeviceConfigurationStatusGroupedPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1ValidationError

@implementation KEYAPISDEVICEV1ValidationError

@dynamic path;
@dynamic message;

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

@implementation KEYAPISDEVICEV1Preset

@dynamic id_p;
@dynamic title;
@dynamic mrfIdsArray, mrfIdsArray_Count;
@dynamic rfIdsArray, rfIdsArray_Count;
@dynamic hasDescription_p, description_p;
@dynamic hasCreatedAt, createdAt;
@dynamic hasChangedAt, changedAt;
@dynamic statusType;
@dynamic hasSip, sip;
@dynamic hasNtp, ntp;
@dynamic hasSyslog, syslog;
@dynamic roomsArray, roomsArray_Count;
@dynamic hasVideoConfig, videoConfig;
@dynamic dtmfArray, dtmfArray_Count;
@dynamic hasFaceRecognition, faceRecognition;

typedef struct KEYAPISDEVICEV1Preset__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  KEYAPISDEVICEV1Preset_StatusType statusType;
  NSString *title;
  GPBInt32Array *mrfIdsArray;
  GPBInt32Array *rfIdsArray;
  GPBStringValue *description_p;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
  KEYAPISDEVICEV1Preset_Sip *sip;
  KEYAPISDEVICEV1Preset_Ntp *ntp;
  KEYAPISDEVICEV1Preset_Syslog *syslog;
  NSMutableArray *roomsArray;
  KEYAPISDEVICEV1Preset_VideoConfig *videoConfig;
  NSMutableArray *dtmfArray;
  KEYAPISDEVICEV1Preset_FaceRecognition *faceRecognition;
} KEYAPISDEVICEV1Preset__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 = KEYAPISDEVICEV1Preset_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "title",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FieldNumber_Title,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, title),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "mrfIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FieldNumber_MrfIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, mrfIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "rfIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FieldNumber_RfIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, rfIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "description_p",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_Description_p,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, description_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_CreatedAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_ChangedAt,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Preset_StatusType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Preset_FieldNumber_StatusType,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "sip",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_Sip),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_Sip,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, sip),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "ntp",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_Ntp),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_Ntp,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, ntp),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "syslog",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_Syslog),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_Syslog,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, syslog),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "roomsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_Room),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_RoomsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, roomsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "videoConfig",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_VideoConfig),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_VideoConfig,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, videoConfig),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "dtmfArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_Dtmf),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_DtmfArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, dtmfArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "faceRecognition",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_FaceRecognition),
        .number = KEYAPISDEVICEV1Preset_FieldNumber_FaceRecognition,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset__storage_, faceRecognition),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset)
                                   messageName:@"Preset"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset__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 KEYAPISDEVICEV1Preset_StatusType_RawValue(KEYAPISDEVICEV1Preset *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Preset_StatusType_RawValue(KEYAPISDEVICEV1Preset *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Preset_Sip

@implementation KEYAPISDEVICEV1Preset_Sip

@dynamic host;
@dynamic port;
@dynamic regHost;
@dynamic regPort;
@dynamic proxyHost;
@dynamic proxyPort;

typedef struct KEYAPISDEVICEV1Preset_Sip__storage_ {
  uint32_t _has_storage_[1];
  int32_t port;
  int32_t regPort;
  int32_t proxyPort;
  NSString *host;
  NSString *regHost;
  NSString *proxyHost;
} KEYAPISDEVICEV1Preset_Sip__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 = "host",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Sip_FieldNumber_Host,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Sip__storage_, host),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "port",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Sip_FieldNumber_Port,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Sip__storage_, port),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "regHost",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Sip_FieldNumber_RegHost,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Sip__storage_, regHost),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "regPort",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Sip_FieldNumber_RegPort,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Sip__storage_, regPort),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "proxyHost",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Sip_FieldNumber_ProxyHost,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Sip__storage_, proxyHost),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "proxyPort",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Sip_FieldNumber_ProxyPort,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Sip__storage_, proxyPort),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_Sip)
                                   messageName:@"Sip"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_Sip__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Preset_Ntp

@implementation KEYAPISDEVICEV1Preset_Ntp

@dynamic host;
@dynamic port;

typedef struct KEYAPISDEVICEV1Preset_Ntp__storage_ {
  uint32_t _has_storage_[1];
  int32_t port;
  NSString *host;
} KEYAPISDEVICEV1Preset_Ntp__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 = "host",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Ntp_FieldNumber_Host,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Ntp__storage_, host),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "port",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Ntp_FieldNumber_Port,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Ntp__storage_, port),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_Ntp)
                                   messageName:@"Ntp"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_Ntp__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Preset_Syslog

@implementation KEYAPISDEVICEV1Preset_Syslog

@dynamic host;
@dynamic port;
@dynamic protocolType;

typedef struct KEYAPISDEVICEV1Preset_Syslog__storage_ {
  uint32_t _has_storage_[1];
  int32_t port;
  KEYAPISDEVICEV1Preset_Syslog_ProtocolType protocolType;
  NSString *host;
} KEYAPISDEVICEV1Preset_Syslog__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 = "host",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Syslog_FieldNumber_Host,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Syslog__storage_, host),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "port",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Syslog_FieldNumber_Port,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Syslog__storage_, port),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "protocolType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Preset_Syslog_ProtocolType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Preset_Syslog_FieldNumber_ProtocolType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Syslog__storage_, protocolType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_Syslog)
                                   messageName:@"Syslog"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_Syslog__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISDEVICEV1Preset_Syslog_ProtocolType_RawValue(KEYAPISDEVICEV1Preset_Syslog *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset_Syslog descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_Syslog_FieldNumber_ProtocolType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Preset_Syslog_ProtocolType_RawValue(KEYAPISDEVICEV1Preset_Syslog *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset_Syslog descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_Syslog_FieldNumber_ProtocolType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Preset_Room

@implementation KEYAPISDEVICEV1Preset_Room

@dynamic phone;
@dynamic num;

typedef struct KEYAPISDEVICEV1Preset_Room__storage_ {
  uint32_t _has_storage_[1];
  int32_t num;
  NSString *phone;
} KEYAPISDEVICEV1Preset_Room__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 = "phone",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Room_FieldNumber_Phone,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Room__storage_, phone),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "num",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_Room_FieldNumber_Num,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_Room__storage_, num),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_Room)
                                   messageName:@"Room"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_Room__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Preset_VideoConfig

@implementation KEYAPISDEVICEV1Preset_VideoConfig

@dynamic qualityType;
@dynamic hasRtspUser, rtspUser;

typedef struct KEYAPISDEVICEV1Preset_VideoConfig__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Preset_VideoConfig_QualityType qualityType;
  KEYAPISDEVICEV1Preset_VideoConfig_RtspUser *rtspUser;
} KEYAPISDEVICEV1Preset_VideoConfig__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 = "qualityType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Preset_VideoConfig_QualityType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Preset_VideoConfig_FieldNumber_QualityType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_VideoConfig__storage_, qualityType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "rtspUser",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_VideoConfig_RtspUser),
        .number = KEYAPISDEVICEV1Preset_VideoConfig_FieldNumber_RtspUser,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_VideoConfig__storage_, rtspUser),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_VideoConfig)
                                   messageName:@"VideoConfig"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_VideoConfig__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISDEVICEV1Preset_VideoConfig_QualityType_RawValue(KEYAPISDEVICEV1Preset_VideoConfig *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset_VideoConfig descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_VideoConfig_FieldNumber_QualityType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Preset_VideoConfig_QualityType_RawValue(KEYAPISDEVICEV1Preset_VideoConfig *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset_VideoConfig descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_VideoConfig_FieldNumber_QualityType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Preset_VideoConfig_RtspUser

@implementation KEYAPISDEVICEV1Preset_VideoConfig_RtspUser

@dynamic username;
@dynamic password;

typedef struct KEYAPISDEVICEV1Preset_VideoConfig_RtspUser__storage_ {
  uint32_t _has_storage_[1];
  NSString *username;
  NSString *password;
} KEYAPISDEVICEV1Preset_VideoConfig_RtspUser__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 = "username",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_VideoConfig_RtspUser_FieldNumber_Username,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_VideoConfig_RtspUser__storage_, username),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_VideoConfig_RtspUser_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_VideoConfig_RtspUser__storage_, password),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_VideoConfig_RtspUser)
                                   messageName:@"RtspUser"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_VideoConfig_RtspUser__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset_VideoConfig)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISDEVICEV1Preset_Dtmf

@implementation KEYAPISDEVICEV1Preset_Dtmf

@dynamic code;
@dynamic relayIndex;

typedef struct KEYAPISDEVICEV1Preset_Dtmf__storage_ {
  uint32_t _has_storage_[1];
  int32_t relayIndex;
  NSString *code;
} KEYAPISDEVICEV1Preset_Dtmf__storage_;

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

@end

#pragma mark - KEYAPISDEVICEV1Preset_FaceRecognition

@implementation KEYAPISDEVICEV1Preset_FaceRecognition

@dynamic host;
@dynamic altHost;
@dynamic endpoint;
@dynamic authToken;
@dynamic configurationType;
@dynamic originId;
@dynamic groupIdsArray, groupIdsArray_Count;

typedef struct KEYAPISDEVICEV1Preset_FaceRecognition__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType configurationType;
  NSString *host;
  NSString *altHost;
  NSString *endpoint;
  NSString *authToken;
  NSString *originId;
  GPBInt32Array *groupIdsArray;
} KEYAPISDEVICEV1Preset_FaceRecognition__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 = "host",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_Host,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_, host),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "altHost",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_AltHost,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_, altHost),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "endpoint",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_Endpoint,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_, endpoint),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "authToken",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_AuthToken,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_, authToken),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "configurationType",
        .dataTypeSpecific.enumDescFunc = KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_EnumDescriptor,
        .number = KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_ConfigurationType,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_, configurationType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "originId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_OriginId,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_, originId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "groupIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_GroupIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_, groupIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_FaceRecognition)
                                   messageName:@"FaceRecognition"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_FaceRecognition__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_RawValue(KEYAPISDEVICEV1Preset_FaceRecognition *message) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset_FaceRecognition descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_ConfigurationType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISDEVICEV1Preset_FaceRecognition_ConfigurationType_RawValue(KEYAPISDEVICEV1Preset_FaceRecognition *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISDEVICEV1Preset_FaceRecognition descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISDEVICEV1Preset_FaceRecognition_FieldNumber_ConfigurationType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISDEVICEV1Preset_SavingError

@implementation KEYAPISDEVICEV1Preset_SavingError

@dynamic reasonOneOfCase;
@dynamic conflict;
@dynamic notAllowedForDefault;

typedef struct KEYAPISDEVICEV1Preset_SavingError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISDEVICEV1Preset_SavingError_Conflict *conflict;
  KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault *notAllowedForDefault;
} KEYAPISDEVICEV1Preset_SavingError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "conflict",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_SavingError_Conflict),
        .number = KEYAPISDEVICEV1Preset_SavingError_FieldNumber_Conflict,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_SavingError__storage_, conflict),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "notAllowedForDefault",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault),
        .number = KEYAPISDEVICEV1Preset_SavingError_FieldNumber_NotAllowedForDefault,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISDEVICEV1Preset_SavingError__storage_, notAllowedForDefault),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISDEVICEV1Preset_SavingError)
                                   messageName:@"SavingError"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_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(KEYAPISDEVICEV1Preset)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISDEVICEV1Preset_SavingError_Conflict


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

@end

#pragma mark - KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault

@implementation KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault


typedef struct KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault__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(KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault)
                                   messageName:@"NotAllowedForDefault"
                               fileDescription:&KEYAPISDEVICEV1KeyapisDeviceDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISDEVICEV1Preset_SavingError_NotAllowedForDefault__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISDEVICEV1Preset_SavingError)];
    #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