// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/banner/v1/keyapis_banner_banner_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/banner/v1/KeyapisBannerBannerV1.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.pbobjc.h"
#import "google/protobuf/Descriptor.pbobjc.h"
// @@protoc_insertion_point(imports)

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

#pragma mark - Objective-C Class declarations
// Forward declarations of Objective-C classes that we can use as
// static values in struct initializers.
// We don't use [Foo class] because it is not a static value.
GPBObjCClassDeclaration(GPBInt32Value);
GPBObjCClassDeclaration(GPBStringValue);
GPBObjCClassDeclaration(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner);
GPBObjCClassDeclaration(KEYAPISBANNERV1BannerFilter);
GPBObjCClassDeclaration(KEYAPISBANNERV1BannerLite);
GPBObjCClassDeclaration(KEYAPISBANNERV1BannerLiteFilter);
GPBObjCClassDeclaration(KEYAPISBANNERV1BannerLite_ImageLite);
GPBObjCClassDeclaration(KEYAPISBANNERV1BannerLite_LinkLite);
GPBObjCClassDeclaration(KEYAPISBANNERV1BannerPaging);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner_Gradient);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner_Gradient_Linear);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner_Gradient_Linear_Point);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner_Image);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner_Link);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner_SavingError);
GPBObjCClassDeclaration(KEYAPISBANNERV1Banner_SavingError_Conflict);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerCountRequest);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerCountResponse);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerCountResponse_Error);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerListRequest);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerListResponse);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerListResponse_Error);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerLiteListRequest);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerLiteListResponse);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerLiteListResponse_Error);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerLiteRequest);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerLiteResponse);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerLiteResponse_Error);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerRequest);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerResponse);
GPBObjCClassDeclaration(KEYAPISBANNERV1GetBannerResponse_Error);
GPBObjCClassDeclaration(KEYAPISBANNERV1PostBannerRequest);
GPBObjCClassDeclaration(KEYAPISBANNERV1PostBannerResponse);
GPBObjCClassDeclaration(KEYAPISBANNERV1PostBannerResponse_Error);
GPBObjCClassDeclaration(KEYAPISBANNERV1PostBannerUploadImageRequest);
GPBObjCClassDeclaration(KEYAPISBANNERV1PostBannerUploadImageResponse);
GPBObjCClassDeclaration(KEYAPISBANNERV1PostBannerUploadImageResponse_Error);
GPBObjCClassDeclaration(KEYAPISBANNERV1UploadImage);
GPBObjCClassDeclaration(KEYAPISBANNERV1ValidationError);

#pragma mark - KEYAPISBANNERV1KeyapisBannerBannerV1Root

@implementation KEYAPISBANNERV1KeyapisBannerBannerV1Root

+ (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]];
  }
  return registry;
}

@end

static GPBFileDescription KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription = {
  .package = "keyapis.banner.v1",
  .prefix = "KEYAPISBANNERV1",
  .syntax = GPBFileSyntaxProto3
};

#pragma mark - Enum KEYAPISBANNERV1Banner_Type

GPBEnumDescriptor *KEYAPISBANNERV1Banner_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000Standard\000";
    static const int32_t values[] = {
        KEYAPISBANNERV1Banner_Type_TypeUnknown,
        KEYAPISBANNERV1Banner_Type_Standard,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1Banner_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1Banner_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1Banner_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1Banner_Type_TypeUnknown:
    case KEYAPISBANNERV1Banner_Type_Standard:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISBANNERV1Banner_PriorityType

GPBEnumDescriptor *KEYAPISBANNERV1Banner_PriorityType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "PriorityTypeUnknown\000Normal\000WhiteLabel\000Cr"
        "itical\000";
    static const int32_t values[] = {
        KEYAPISBANNERV1Banner_PriorityType_PriorityTypeUnknown,
        KEYAPISBANNERV1Banner_PriorityType_Normal,
        KEYAPISBANNERV1Banner_PriorityType_WhiteLabel,
        KEYAPISBANNERV1Banner_PriorityType_Critical,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1Banner_PriorityType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1Banner_PriorityType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1Banner_PriorityType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1Banner_PriorityType_PriorityTypeUnknown:
    case KEYAPISBANNERV1Banner_PriorityType_Normal:
    case KEYAPISBANNERV1Banner_PriorityType_WhiteLabel:
    case KEYAPISBANNERV1Banner_PriorityType_Critical:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISBANNERV1Banner_StatusType

GPBEnumDescriptor *KEYAPISBANNERV1Banner_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Deferred\000Active\000Expire"
        "d\000";
    static const int32_t values[] = {
        KEYAPISBANNERV1Banner_StatusType_StatusTypeUnknown,
        KEYAPISBANNERV1Banner_StatusType_Deferred,
        KEYAPISBANNERV1Banner_StatusType_Active,
        KEYAPISBANNERV1Banner_StatusType_Expired,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1Banner_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1Banner_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1Banner_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1Banner_StatusType_StatusTypeUnknown:
    case KEYAPISBANNERV1Banner_StatusType_Deferred:
    case KEYAPISBANNERV1Banner_StatusType_Active:
    case KEYAPISBANNERV1Banner_StatusType_Expired:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISBANNERV1Banner_PlatformType

GPBEnumDescriptor *KEYAPISBANNERV1Banner_PlatformType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "PlatformTypeUnknown\000Ios\000Android\000Web\000";
    static const int32_t values[] = {
        KEYAPISBANNERV1Banner_PlatformType_PlatformTypeUnknown,
        KEYAPISBANNERV1Banner_PlatformType_Ios,
        KEYAPISBANNERV1Banner_PlatformType_Android,
        KEYAPISBANNERV1Banner_PlatformType_Web,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1Banner_PlatformType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1Banner_PlatformType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1Banner_PlatformType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1Banner_PlatformType_PlatformTypeUnknown:
    case KEYAPISBANNERV1Banner_PlatformType_Ios:
    case KEYAPISBANNERV1Banner_PlatformType_Android:
    case KEYAPISBANNERV1Banner_PlatformType_Web:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISBANNERV1Banner_Image_Type

GPBEnumDescriptor *KEYAPISBANNERV1Banner_Image_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000Portrait\000Landscape\000Icon\000";
    static const int32_t values[] = {
        KEYAPISBANNERV1Banner_Image_Type_TypeUnknown,
        KEYAPISBANNERV1Banner_Image_Type_Portrait,
        KEYAPISBANNERV1Banner_Image_Type_Landscape,
        KEYAPISBANNERV1Banner_Image_Type_Icon,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1Banner_Image_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1Banner_Image_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1Banner_Image_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1Banner_Image_Type_TypeUnknown:
    case KEYAPISBANNERV1Banner_Image_Type_Portrait:
    case KEYAPISBANNERV1Banner_Image_Type_Landscape:
    case KEYAPISBANNERV1Banner_Image_Type_Icon:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISBANNERV1Banner_Link_Type

GPBEnumDescriptor *KEYAPISBANNERV1Banner_Link_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000InternalApp\000ExternalApp\000WebV"
        "iew\000WebBrowser\000ExternalWebView\000";
    static const int32_t values[] = {
        KEYAPISBANNERV1Banner_Link_Type_TypeUnknown,
        KEYAPISBANNERV1Banner_Link_Type_InternalApp,
        KEYAPISBANNERV1Banner_Link_Type_ExternalApp,
        KEYAPISBANNERV1Banner_Link_Type_WebView,
        KEYAPISBANNERV1Banner_Link_Type_WebBrowser,
        KEYAPISBANNERV1Banner_Link_Type_ExternalWebView,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1Banner_Link_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1Banner_Link_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1Banner_Link_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1Banner_Link_Type_TypeUnknown:
    case KEYAPISBANNERV1Banner_Link_Type_InternalApp:
    case KEYAPISBANNERV1Banner_Link_Type_ExternalApp:
    case KEYAPISBANNERV1Banner_Link_Type_WebView:
    case KEYAPISBANNERV1Banner_Link_Type_WebBrowser:
    case KEYAPISBANNERV1Banner_Link_Type_ExternalWebView:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISBANNERV1BannerPaging_OrderByType

GPBEnumDescriptor *KEYAPISBANNERV1BannerPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000ChangedAt\000PriorityThe"
        "nShowStartAt\000CreatedAt\000ShowStartAt\000ShowE"
        "ndedAt\000Rank\000";
    static const int32_t values[] = {
        KEYAPISBANNERV1BannerPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISBANNERV1BannerPaging_OrderByType_ChangedAt,
        KEYAPISBANNERV1BannerPaging_OrderByType_PriorityThenShowStartAt,
        KEYAPISBANNERV1BannerPaging_OrderByType_CreatedAt,
        KEYAPISBANNERV1BannerPaging_OrderByType_ShowStartAt,
        KEYAPISBANNERV1BannerPaging_OrderByType_ShowEndedAt,
        KEYAPISBANNERV1BannerPaging_OrderByType_Rank,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1BannerPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1BannerPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1BannerPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1BannerPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISBANNERV1BannerPaging_OrderByType_ChangedAt:
    case KEYAPISBANNERV1BannerPaging_OrderByType_PriorityThenShowStartAt:
    case KEYAPISBANNERV1BannerPaging_OrderByType_CreatedAt:
    case KEYAPISBANNERV1BannerPaging_OrderByType_ShowStartAt:
    case KEYAPISBANNERV1BannerPaging_OrderByType_ShowEndedAt:
    case KEYAPISBANNERV1BannerPaging_OrderByType_Rank:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISBANNERV1BannerPaging_DirectionType

GPBEnumDescriptor *KEYAPISBANNERV1BannerPaging_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[] = {
        KEYAPISBANNERV1BannerPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISBANNERV1BannerPaging_DirectionType_Desc,
        KEYAPISBANNERV1BannerPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISBANNERV1BannerPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISBANNERV1BannerPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISBANNERV1BannerPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISBANNERV1BannerPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISBANNERV1BannerPaging_DirectionType_Desc:
    case KEYAPISBANNERV1BannerPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISBANNERV1Banner

@implementation KEYAPISBANNERV1Banner

@dynamic id_p;
@dynamic type;
@dynamic priority;
@dynamic priorityType;
@dynamic title;
@dynamic hasHeader, header;
@dynamic hasHeaderColor, headerColor;
@dynamic hasSubtitle, subtitle;
@dynamic hasSubtitleColor, subtitleColor;
@dynamic hasBackgroundColor, backgroundColor;
@dynamic hasBackgroundGradient, backgroundGradient;
@dynamic hasRepeatAfterDays, repeatAfterDays;
@dynamic hasShowStartAt, showStartAt;
@dynamic hasShowEndedAt, showEndedAt;
@dynamic statusType;
@dynamic imagesArray, imagesArray_Count;
@dynamic linksArray, linksArray_Count;
@dynamic userTagsArray, userTagsArray_Count;
@dynamic appTagsArray, appTagsArray_Count;
@dynamic hasCreatedAt, createdAt;
@dynamic hasChangedAt, changedAt;

typedef struct KEYAPISBANNERV1Banner__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1Banner_Type type;
  int32_t priority;
  KEYAPISBANNERV1Banner_PriorityType priorityType;
  KEYAPISBANNERV1Banner_StatusType statusType;
  NSString *id_p;
  NSString *title;
  GPBStringValue *header;
  GPBStringValue *headerColor;
  GPBStringValue *subtitle;
  GPBStringValue *subtitleColor;
  GPBStringValue *backgroundColor;
  KEYAPISBANNERV1Banner_Gradient *backgroundGradient;
  GPBInt32Value *repeatAfterDays;
  GPBTimestamp *showStartAt;
  GPBTimestamp *showEndedAt;
  NSMutableArray *imagesArray;
  NSMutableArray *linksArray;
  NSMutableArray *userTagsArray;
  NSMutableArray *appTagsArray;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
} KEYAPISBANNERV1Banner__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 = KEYAPISBANNERV1Banner_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_Type_EnumDescriptor,
        .number = KEYAPISBANNERV1Banner_FieldNumber_Type,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "priority",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_FieldNumber_Priority,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, priority),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "priorityType",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_PriorityType_EnumDescriptor,
        .number = KEYAPISBANNERV1Banner_FieldNumber_PriorityType,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, priorityType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "title",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_FieldNumber_Title,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, title),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "header",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1Banner_FieldNumber_Header,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, header),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "headerColor",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1Banner_FieldNumber_HeaderColor,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, headerColor),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "subtitle",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1Banner_FieldNumber_Subtitle,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, subtitle),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "subtitleColor",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1Banner_FieldNumber_SubtitleColor,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, subtitleColor),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "backgroundColor",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1Banner_FieldNumber_BackgroundColor,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, backgroundColor),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "backgroundGradient",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1Banner_Gradient),
        .number = KEYAPISBANNERV1Banner_FieldNumber_BackgroundGradient,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, backgroundGradient),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "repeatAfterDays",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISBANNERV1Banner_FieldNumber_RepeatAfterDays,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, repeatAfterDays),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "showStartAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1Banner_FieldNumber_ShowStartAt,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, showStartAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "showEndedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1Banner_FieldNumber_ShowEndedAt,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, showEndedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_StatusType_EnumDescriptor,
        .number = KEYAPISBANNERV1Banner_FieldNumber_StatusType,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "imagesArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1Banner_Image),
        .number = KEYAPISBANNERV1Banner_FieldNumber_ImagesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, imagesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "linksArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1Banner_Link),
        .number = KEYAPISBANNERV1Banner_FieldNumber_LinksArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, linksArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userTagsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_FieldNumber_UserTagsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, userTagsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "appTagsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_FieldNumber_AppTagsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, appTagsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1Banner_FieldNumber_CreatedAt,
        .hasIndex = 15,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1Banner_FieldNumber_ChangedAt,
        .hasIndex = 16,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1Banner)
                                   messageName:@"Banner"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1Banner__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 KEYAPISBANNERV1Banner_Type_RawValue(KEYAPISBANNERV1Banner *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1Banner_Type_RawValue(KEYAPISBANNERV1Banner *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISBANNERV1Banner_PriorityType_RawValue(KEYAPISBANNERV1Banner *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_FieldNumber_PriorityType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1Banner_PriorityType_RawValue(KEYAPISBANNERV1Banner *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_FieldNumber_PriorityType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISBANNERV1Banner_StatusType_RawValue(KEYAPISBANNERV1Banner *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1Banner_StatusType_RawValue(KEYAPISBANNERV1Banner *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISBANNERV1Banner_Gradient

@implementation KEYAPISBANNERV1Banner_Gradient

@dynamic typeOneOfCase;
@dynamic linear;

typedef struct KEYAPISBANNERV1Banner_Gradient__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1Banner_Gradient_Linear *linear;
} KEYAPISBANNERV1Banner_Gradient__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 = "linear",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1Banner_Gradient_Linear),
        .number = KEYAPISBANNERV1Banner_Gradient_FieldNumber_Linear,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Gradient__storage_, linear),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1Banner_Gradient)
                                   messageName:@"Gradient"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1Banner_Gradient__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];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISBANNERV1Banner)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISBANNERV1Banner_Gradient_Linear

@dynamic angle;
@dynamic pointsArray, pointsArray_Count;

typedef struct KEYAPISBANNERV1Banner_Gradient_Linear__storage_ {
  uint32_t _has_storage_[1];
  float angle;
  NSMutableArray *pointsArray;
} KEYAPISBANNERV1Banner_Gradient_Linear__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 = "angle",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_Gradient_Linear_FieldNumber_Angle,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Gradient_Linear__storage_, angle),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "pointsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1Banner_Gradient_Linear_Point),
        .number = KEYAPISBANNERV1Banner_Gradient_Linear_FieldNumber_PointsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Gradient_Linear__storage_, pointsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1Banner_Gradient_Linear)
                                   messageName:@"Linear"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1Banner_Gradient_Linear__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISBANNERV1Banner_Gradient)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISBANNERV1Banner_Gradient_Linear_Point

@implementation KEYAPISBANNERV1Banner_Gradient_Linear_Point

@dynamic color;
@dynamic stop;

typedef struct KEYAPISBANNERV1Banner_Gradient_Linear_Point__storage_ {
  uint32_t _has_storage_[1];
  float stop;
  NSString *color;
} KEYAPISBANNERV1Banner_Gradient_Linear_Point__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 = "color",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_Gradient_Linear_Point_FieldNumber_Color,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Gradient_Linear_Point__storage_, color),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "stop",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_Gradient_Linear_Point_FieldNumber_Stop,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Gradient_Linear_Point__storage_, stop),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1Banner_Gradient_Linear_Point)
                                   messageName:@"Point"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1Banner_Gradient_Linear_Point__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISBANNERV1Banner_Gradient_Linear)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISBANNERV1Banner_Image

@implementation KEYAPISBANNERV1Banner_Image

@dynamic type;
@dynamic URL;

typedef struct KEYAPISBANNERV1Banner_Image__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1Banner_Image_Type type;
  NSString *URL;
} KEYAPISBANNERV1Banner_Image__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 = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_Image_Type_EnumDescriptor,
        .number = KEYAPISBANNERV1Banner_Image_FieldNumber_Type,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Image__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "URL",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_Image_FieldNumber_URL,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Image__storage_, URL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1Banner_Image)
                                   messageName:@"Image"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1Banner_Image__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\002!!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISBANNERV1Banner)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISBANNERV1Banner_Image_Type_RawValue(KEYAPISBANNERV1Banner_Image *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner_Image descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_Image_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1Banner_Image_Type_RawValue(KEYAPISBANNERV1Banner_Image *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner_Image descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_Image_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISBANNERV1Banner_Link

@implementation KEYAPISBANNERV1Banner_Link

@dynamic platformType;
@dynamic type;
@dynamic URL;
@dynamic packagesArray, packagesArray_Count;

typedef struct KEYAPISBANNERV1Banner_Link__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1Banner_PlatformType platformType;
  KEYAPISBANNERV1Banner_Link_Type type;
  NSString *URL;
  NSMutableArray *packagesArray;
} KEYAPISBANNERV1Banner_Link__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 = "platformType",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_PlatformType_EnumDescriptor,
        .number = KEYAPISBANNERV1Banner_Link_FieldNumber_PlatformType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Link__storage_, platformType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_Link_Type_EnumDescriptor,
        .number = KEYAPISBANNERV1Banner_Link_FieldNumber_Type,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Link__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "URL",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_Link_FieldNumber_URL,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Link__storage_, URL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "packagesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1Banner_Link_FieldNumber_PackagesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_Link__storage_, packagesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1Banner_Link)
                                   messageName:@"Link"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1Banner_Link__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\003!!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISBANNERV1Banner)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISBANNERV1Banner_Link_PlatformType_RawValue(KEYAPISBANNERV1Banner_Link *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner_Link descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_Link_FieldNumber_PlatformType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1Banner_Link_PlatformType_RawValue(KEYAPISBANNERV1Banner_Link *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner_Link descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_Link_FieldNumber_PlatformType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISBANNERV1Banner_Link_Type_RawValue(KEYAPISBANNERV1Banner_Link *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner_Link descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_Link_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1Banner_Link_Type_RawValue(KEYAPISBANNERV1Banner_Link *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1Banner_Link descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1Banner_Link_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISBANNERV1Banner_SavingError

@implementation KEYAPISBANNERV1Banner_SavingError

@dynamic reasonOneOfCase;
@dynamic conflict;

typedef struct KEYAPISBANNERV1Banner_SavingError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1Banner_SavingError_Conflict *conflict;
} KEYAPISBANNERV1Banner_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(KEYAPISBANNERV1Banner_SavingError_Conflict),
        .number = KEYAPISBANNERV1Banner_SavingError_FieldNumber_Conflict,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1Banner_SavingError__storage_, conflict),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1Banner_SavingError)
                                   messageName:@"SavingError"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1Banner_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(KEYAPISBANNERV1Banner)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISBANNERV1Banner_SavingError_Conflict


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

@end

#pragma mark - KEYAPISBANNERV1BannerLite

@implementation KEYAPISBANNERV1BannerLite

@dynamic id_p;
@dynamic hasRepeatAfterDays, repeatAfterDays;
@dynamic imagesArray, imagesArray_Count;
@dynamic linksArray, linksArray_Count;

typedef struct KEYAPISBANNERV1BannerLite__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
  GPBInt32Value *repeatAfterDays;
  NSMutableArray *imagesArray;
  NSMutableArray *linksArray;
} KEYAPISBANNERV1BannerLite__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 = KEYAPISBANNERV1BannerLite_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "repeatAfterDays",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISBANNERV1BannerLite_FieldNumber_RepeatAfterDays,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite__storage_, repeatAfterDays),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "imagesArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1BannerLite_ImageLite),
        .number = KEYAPISBANNERV1BannerLite_FieldNumber_ImagesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite__storage_, imagesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "linksArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1BannerLite_LinkLite),
        .number = KEYAPISBANNERV1BannerLite_FieldNumber_LinksArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite__storage_, linksArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1BannerLite)
                                   messageName:@"BannerLite"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1BannerLite__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 - KEYAPISBANNERV1BannerLite_ImageLite

@implementation KEYAPISBANNERV1BannerLite_ImageLite

@dynamic type;
@dynamic URL;

typedef struct KEYAPISBANNERV1BannerLite_ImageLite__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1Banner_Image_Type type;
  NSString *URL;
} KEYAPISBANNERV1BannerLite_ImageLite__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 = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_Image_Type_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerLite_ImageLite_FieldNumber_Type,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite_ImageLite__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "URL",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerLite_ImageLite_FieldNumber_URL,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite_ImageLite__storage_, URL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1BannerLite_ImageLite)
                                   messageName:@"ImageLite"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1BannerLite_ImageLite__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\002!!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISBANNERV1BannerLite)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISBANNERV1BannerLite_ImageLite_Type_RawValue(KEYAPISBANNERV1BannerLite_ImageLite *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLite_ImageLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLite_ImageLite_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1BannerLite_ImageLite_Type_RawValue(KEYAPISBANNERV1BannerLite_ImageLite *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLite_ImageLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLite_ImageLite_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISBANNERV1BannerLite_LinkLite

@implementation KEYAPISBANNERV1BannerLite_LinkLite

@dynamic type;
@dynamic URL;
@dynamic packagesArray, packagesArray_Count;
@dynamic platformType;

typedef struct KEYAPISBANNERV1BannerLite_LinkLite__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1Banner_Link_Type type;
  KEYAPISBANNERV1Banner_PlatformType platformType;
  NSString *URL;
  NSMutableArray *packagesArray;
} KEYAPISBANNERV1BannerLite_LinkLite__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 = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_Link_Type_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_Type,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite_LinkLite__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "URL",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_URL,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite_LinkLite__storage_, URL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "packagesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_PackagesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite_LinkLite__storage_, packagesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "platformType",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_PlatformType_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_PlatformType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLite_LinkLite__storage_, platformType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1BannerLite_LinkLite)
                                   messageName:@"LinkLite"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1BannerLite_LinkLite__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\002!!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISBANNERV1BannerLite)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISBANNERV1BannerLite_LinkLite_Type_RawValue(KEYAPISBANNERV1BannerLite_LinkLite *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLite_LinkLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1BannerLite_LinkLite_Type_RawValue(KEYAPISBANNERV1BannerLite_LinkLite *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLite_LinkLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISBANNERV1BannerLite_LinkLite_PlatformType_RawValue(KEYAPISBANNERV1BannerLite_LinkLite *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLite_LinkLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_PlatformType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1BannerLite_LinkLite_PlatformType_RawValue(KEYAPISBANNERV1BannerLite_LinkLite *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLite_LinkLite descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLite_LinkLite_FieldNumber_PlatformType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISBANNERV1BannerFilter

@implementation KEYAPISBANNERV1BannerFilter

@dynamic hasText, text;
@dynamic typesArray, typesArray_Count;
@dynamic hasBeginPriority, beginPriority;
@dynamic hasEndPriority, endPriority;
@dynamic priorityTypesArray, priorityTypesArray_Count;
@dynamic hasBeginShowStartAt, beginShowStartAt;
@dynamic hasEndShowStartAt, endShowStartAt;
@dynamic hasBeginShowEndedAt, beginShowEndedAt;
@dynamic hasEndShowEndedAt, endShowEndedAt;
@dynamic statusTypesArray, statusTypesArray_Count;
@dynamic userTagsArray, userTagsArray_Count;
@dynamic appTagsArray, appTagsArray_Count;

typedef struct KEYAPISBANNERV1BannerFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBStringValue *text;
  GPBEnumArray *typesArray;
  GPBInt32Value *beginPriority;
  GPBInt32Value *endPriority;
  GPBEnumArray *priorityTypesArray;
  GPBTimestamp *beginShowStartAt;
  GPBTimestamp *endShowStartAt;
  GPBTimestamp *beginShowEndedAt;
  GPBTimestamp *endShowEndedAt;
  GPBEnumArray *statusTypesArray;
  NSMutableArray *userTagsArray;
  NSMutableArray *appTagsArray;
} KEYAPISBANNERV1BannerFilter__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 = "text",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_Text,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, text),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "typesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_Type_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_TypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, typesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "beginPriority",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_BeginPriority,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, beginPriority),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "endPriority",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_EndPriority,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, endPriority),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "priorityTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_PriorityType_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_PriorityTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, priorityTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "beginShowStartAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_BeginShowStartAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, beginShowStartAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "endShowStartAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_EndShowStartAt,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, endShowStartAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "beginShowEndedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_BeginShowEndedAt,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, beginShowEndedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "endShowEndedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_EndShowEndedAt,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, endShowEndedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "statusTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_StatusType_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_StatusTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, statusTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "userTagsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_UserTagsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, userTagsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "appTagsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerFilter_FieldNumber_AppTagsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerFilter__storage_, appTagsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1BannerFilter)
                                   messageName:@"BannerFilter"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1BannerFilter__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 - KEYAPISBANNERV1BannerLiteFilter

@implementation KEYAPISBANNERV1BannerLiteFilter

@dynamic typesArray, typesArray_Count;
@dynamic hasAppName, appName;
@dynamic platformType;
@dynamic hasVersion, version;
@dynamic userTagsArray, userTagsArray_Count;

typedef struct KEYAPISBANNERV1BannerLiteFilter__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1Banner_PlatformType platformType;
  GPBEnumArray *typesArray;
  GPBStringValue *appName;
  GPBStringValue *version;
  NSMutableArray *userTagsArray;
} KEYAPISBANNERV1BannerLiteFilter__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "typesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_Type_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerLiteFilter_FieldNumber_TypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLiteFilter__storage_, typesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "appName",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1BannerLiteFilter_FieldNumber_AppName,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLiteFilter__storage_, appName),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "platformType",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1Banner_PlatformType_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerLiteFilter_FieldNumber_PlatformType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLiteFilter__storage_, platformType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "version",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISBANNERV1BannerLiteFilter_FieldNumber_Version,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLiteFilter__storage_, version),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "userTagsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerLiteFilter_FieldNumber_UserTagsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerLiteFilter__storage_, userTagsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1BannerLiteFilter)
                                   messageName:@"BannerLiteFilter"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1BannerLiteFilter__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 KEYAPISBANNERV1BannerLiteFilter_PlatformType_RawValue(KEYAPISBANNERV1BannerLiteFilter *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLiteFilter descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLiteFilter_FieldNumber_PlatformType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1BannerLiteFilter_PlatformType_RawValue(KEYAPISBANNERV1BannerLiteFilter *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerLiteFilter descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerLiteFilter_FieldNumber_PlatformType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISBANNERV1BannerPaging

@implementation KEYAPISBANNERV1BannerPaging

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

typedef struct KEYAPISBANNERV1BannerPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1BannerPaging_OrderByType orderByType;
  KEYAPISBANNERV1BannerPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISBANNERV1BannerPaging__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 = KEYAPISBANNERV1BannerPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISBANNERV1BannerPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISBANNERV1BannerPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1BannerPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1BannerPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1BannerPaging)
                                   messageName:@"BannerPaging"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1BannerPaging__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 KEYAPISBANNERV1BannerPaging_OrderByType_RawValue(KEYAPISBANNERV1BannerPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1BannerPaging_OrderByType_RawValue(KEYAPISBANNERV1BannerPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISBANNERV1BannerPaging_DirectionType_RawValue(KEYAPISBANNERV1BannerPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISBANNERV1BannerPaging_DirectionType_RawValue(KEYAPISBANNERV1BannerPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1BannerPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISBANNERV1BannerPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISBANNERV1PostBannerRequest

@implementation KEYAPISBANNERV1PostBannerRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISBANNERV1PostBannerRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1Banner *data_p;
} KEYAPISBANNERV1PostBannerRequest__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(KEYAPISBANNERV1Banner),
        .number = KEYAPISBANNERV1PostBannerRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1PostBannerRequest)
                                   messageName:@"PostBannerRequest"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1PostBannerRequest__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 - KEYAPISBANNERV1PostBannerResponse

@implementation KEYAPISBANNERV1PostBannerResponse

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

typedef struct KEYAPISBANNERV1PostBannerResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1Banner *data_p;
  KEYAPISBANNERV1PostBannerResponse_Error *error;
} KEYAPISBANNERV1PostBannerResponse__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(KEYAPISBANNERV1Banner),
        .number = KEYAPISBANNERV1PostBannerResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1PostBannerResponse_Error),
        .number = KEYAPISBANNERV1PostBannerResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1PostBannerResponse)
                                   messageName:@"PostBannerResponse"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1PostBannerResponse__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 KEYAPISBANNERV1PostBannerResponse_ClearTypeOneOfCase(KEYAPISBANNERV1PostBannerResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1PostBannerResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1PostBannerResponse_Error

@implementation KEYAPISBANNERV1PostBannerResponse_Error

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

typedef struct KEYAPISBANNERV1PostBannerResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1ValidationError *validation;
  KEYAPISBANNERV1Banner_SavingError *saving;
} KEYAPISBANNERV1PostBannerResponse_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(KEYAPISBANNERV1ValidationError),
        .number = KEYAPISBANNERV1PostBannerResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "saving",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1Banner_SavingError),
        .number = KEYAPISBANNERV1PostBannerResponse_Error_FieldNumber_Saving,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerResponse_Error__storage_, saving),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1PostBannerResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1PostBannerResponse_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(KEYAPISBANNERV1PostBannerResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISBANNERV1GetBannerRequest

@dynamic id_p;

typedef struct KEYAPISBANNERV1GetBannerRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
} KEYAPISBANNERV1GetBannerRequest__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 = KEYAPISBANNERV1GetBannerRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerRequest)
                                   messageName:@"GetBannerRequest"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerRequest__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 - KEYAPISBANNERV1GetBannerResponse

@implementation KEYAPISBANNERV1GetBannerResponse

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

typedef struct KEYAPISBANNERV1GetBannerResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1Banner *data_p;
  KEYAPISBANNERV1GetBannerResponse_Error *error;
} KEYAPISBANNERV1GetBannerResponse__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(KEYAPISBANNERV1Banner),
        .number = KEYAPISBANNERV1GetBannerResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1GetBannerResponse_Error),
        .number = KEYAPISBANNERV1GetBannerResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerResponse)
                                   messageName:@"GetBannerResponse"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerResponse__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 KEYAPISBANNERV1GetBannerResponse_ClearTypeOneOfCase(KEYAPISBANNERV1GetBannerResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1GetBannerResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1GetBannerResponse_Error

@implementation KEYAPISBANNERV1GetBannerResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISBANNERV1GetBannerLiteRequest

@dynamic id_p;

typedef struct KEYAPISBANNERV1GetBannerLiteRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
} KEYAPISBANNERV1GetBannerLiteRequest__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 = KEYAPISBANNERV1GetBannerLiteRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerLiteRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerLiteRequest)
                                   messageName:@"GetBannerLiteRequest"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerLiteRequest__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 - KEYAPISBANNERV1GetBannerLiteResponse

@implementation KEYAPISBANNERV1GetBannerLiteResponse

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

typedef struct KEYAPISBANNERV1GetBannerLiteResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1BannerLite *data_p;
  KEYAPISBANNERV1GetBannerLiteResponse_Error *error;
} KEYAPISBANNERV1GetBannerLiteResponse__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(KEYAPISBANNERV1BannerLite),
        .number = KEYAPISBANNERV1GetBannerLiteResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerLiteResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1GetBannerLiteResponse_Error),
        .number = KEYAPISBANNERV1GetBannerLiteResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerLiteResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerLiteResponse)
                                   messageName:@"GetBannerLiteResponse"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerLiteResponse__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 KEYAPISBANNERV1GetBannerLiteResponse_ClearTypeOneOfCase(KEYAPISBANNERV1GetBannerLiteResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1GetBannerLiteResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1GetBannerLiteResponse_Error

@implementation KEYAPISBANNERV1GetBannerLiteResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISBANNERV1GetBannerListRequest

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

typedef struct KEYAPISBANNERV1GetBannerListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1BannerFilter *filter;
  KEYAPISBANNERV1BannerPaging *paging;
} KEYAPISBANNERV1GetBannerListRequest__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(KEYAPISBANNERV1BannerFilter),
        .number = KEYAPISBANNERV1GetBannerListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1BannerPaging),
        .number = KEYAPISBANNERV1GetBannerListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerListRequest)
                                   messageName:@"GetBannerListRequest"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerListRequest__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 KEYAPISBANNERV1GetBannerListRequest_ClearPaginationOneOfCase(KEYAPISBANNERV1GetBannerListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1GetBannerListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1GetBannerListResponse

@implementation KEYAPISBANNERV1GetBannerListResponse

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

typedef struct KEYAPISBANNERV1GetBannerListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1Banner *data_p;
  KEYAPISBANNERV1GetBannerListResponse_Error *error;
} KEYAPISBANNERV1GetBannerListResponse__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(KEYAPISBANNERV1Banner),
        .number = KEYAPISBANNERV1GetBannerListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1GetBannerListResponse_Error),
        .number = KEYAPISBANNERV1GetBannerListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerListResponse)
                                   messageName:@"GetBannerListResponse"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerListResponse__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 KEYAPISBANNERV1GetBannerListResponse_ClearTypeOneOfCase(KEYAPISBANNERV1GetBannerListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1GetBannerListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1GetBannerListResponse_Error

@implementation KEYAPISBANNERV1GetBannerListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISBANNERV1GetBannerLiteListRequest

@dynamic hasFilter, filter;
@dynamic isLinkFilterDisabled;

typedef struct KEYAPISBANNERV1GetBannerLiteListRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1BannerLiteFilter *filter;
} KEYAPISBANNERV1GetBannerLiteListRequest__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(KEYAPISBANNERV1BannerLiteFilter),
        .number = KEYAPISBANNERV1GetBannerLiteListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerLiteListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "isLinkFilterDisabled",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1GetBannerLiteListRequest_FieldNumber_IsLinkFilterDisabled,
        .hasIndex = 1,
        .offset = 2,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerLiteListRequest)
                                   messageName:@"GetBannerLiteListRequest"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerLiteListRequest__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 - KEYAPISBANNERV1GetBannerLiteListResponse

@implementation KEYAPISBANNERV1GetBannerLiteListResponse

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

typedef struct KEYAPISBANNERV1GetBannerLiteListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISBANNERV1BannerLite *data_p;
  KEYAPISBANNERV1GetBannerLiteListResponse_Error *error;
} KEYAPISBANNERV1GetBannerLiteListResponse__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(KEYAPISBANNERV1BannerLite),
        .number = KEYAPISBANNERV1GetBannerLiteListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerLiteListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1GetBannerLiteListResponse_Error),
        .number = KEYAPISBANNERV1GetBannerLiteListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerLiteListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerLiteListResponse)
                                   messageName:@"GetBannerLiteListResponse"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerLiteListResponse__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 KEYAPISBANNERV1GetBannerLiteListResponse_ClearTypeOneOfCase(KEYAPISBANNERV1GetBannerLiteListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1GetBannerLiteListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1GetBannerLiteListResponse_Error

@implementation KEYAPISBANNERV1GetBannerLiteListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISBANNERV1GetBannerCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISBANNERV1GetBannerCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISBANNERV1BannerFilter *filter;
} KEYAPISBANNERV1GetBannerCountRequest__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(KEYAPISBANNERV1BannerFilter),
        .number = KEYAPISBANNERV1GetBannerCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerCountRequest)
                                   messageName:@"GetBannerCountRequest"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerCountRequest__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 - KEYAPISBANNERV1GetBannerCountResponse

@implementation KEYAPISBANNERV1GetBannerCountResponse

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

typedef struct KEYAPISBANNERV1GetBannerCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
  KEYAPISBANNERV1GetBannerCountResponse_Error *error;
} KEYAPISBANNERV1GetBannerCountResponse__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 = KEYAPISBANNERV1GetBannerCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1GetBannerCountResponse_Error),
        .number = KEYAPISBANNERV1GetBannerCountResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1GetBannerCountResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1GetBannerCountResponse)
                                   messageName:@"GetBannerCountResponse"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1GetBannerCountResponse__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 KEYAPISBANNERV1GetBannerCountResponse_ClearTypeOneOfCase(KEYAPISBANNERV1GetBannerCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1GetBannerCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1GetBannerCountResponse_Error

@implementation KEYAPISBANNERV1GetBannerCountResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISBANNERV1UploadImage

@dynamic base64;

typedef struct KEYAPISBANNERV1UploadImage__storage_ {
  uint32_t _has_storage_[1];
  NSString *base64;
} KEYAPISBANNERV1UploadImage__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 = "base64",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1UploadImage_FieldNumber_Base64,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1UploadImage__storage_, base64),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1UploadImage)
                                   messageName:@"UploadImage"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1UploadImage__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 - KEYAPISBANNERV1PostBannerUploadImageRequest

@implementation KEYAPISBANNERV1PostBannerUploadImageRequest

@dynamic bannerId;
@dynamic hasUploadImage, uploadImage;

typedef struct KEYAPISBANNERV1PostBannerUploadImageRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *bannerId;
  KEYAPISBANNERV1UploadImage *uploadImage;
} KEYAPISBANNERV1PostBannerUploadImageRequest__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 = "bannerId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1PostBannerUploadImageRequest_FieldNumber_BannerId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerUploadImageRequest__storage_, bannerId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "uploadImage",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1UploadImage),
        .number = KEYAPISBANNERV1PostBannerUploadImageRequest_FieldNumber_UploadImage,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerUploadImageRequest__storage_, uploadImage),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1PostBannerUploadImageRequest)
                                   messageName:@"PostBannerUploadImageRequest"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1PostBannerUploadImageRequest__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 - KEYAPISBANNERV1PostBannerUploadImageResponse

@implementation KEYAPISBANNERV1PostBannerUploadImageResponse

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

typedef struct KEYAPISBANNERV1PostBannerUploadImageResponse__storage_ {
  uint32_t _has_storage_[2];
  NSString *data_p;
  KEYAPISBANNERV1PostBannerUploadImageResponse_Error *error;
} KEYAPISBANNERV1PostBannerUploadImageResponse__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 = KEYAPISBANNERV1PostBannerUploadImageResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerUploadImageResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISBANNERV1PostBannerUploadImageResponse_Error),
        .number = KEYAPISBANNERV1PostBannerUploadImageResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1PostBannerUploadImageResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1PostBannerUploadImageResponse)
                                   messageName:@"PostBannerUploadImageResponse"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1PostBannerUploadImageResponse__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 KEYAPISBANNERV1PostBannerUploadImageResponse_ClearTypeOneOfCase(KEYAPISBANNERV1PostBannerUploadImageResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISBANNERV1PostBannerUploadImageResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISBANNERV1PostBannerUploadImageResponse_Error

@implementation KEYAPISBANNERV1PostBannerUploadImageResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

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

@end

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

@implementation KEYAPISBANNERV1ValidationError

@dynamic path;
@dynamic message;

typedef struct KEYAPISBANNERV1ValidationError__storage_ {
  uint32_t _has_storage_[1];
  NSString *path;
  NSString *message;
} KEYAPISBANNERV1ValidationError__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 = KEYAPISBANNERV1ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISBANNERV1ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISBANNERV1ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISBANNERV1ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISBANNERV1KeyapisBannerBannerV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISBANNERV1ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end


#pragma clang diagnostic pop

// @@protoc_insertion_point(global_scope)

// clang-format on
