session-ios/protobuf/TextSecure.pb.m

// Generated by the protocol buffer compiler.  DO NOT EDIT!

#import "TextSecure.pb.h"
// @@protoc_insertion_point(imports)

@implementation TextSecureRoot
static PBExtensionRegistry* extensionRegistry = nil;
+ (PBExtensionRegistry*) extensionRegistry {
  return extensionRegistry;
}

+ (void) initialize {
  if (self == [TextSecureRoot class]) {
    PBMutableExtensionRegistry* registry = [PBMutableExtensionRegistry registry];
    [self registerAllExtensions:registry];
    extensionRegistry = registry;
  }
}
+ (void) registerAllExtensions:(PBMutableExtensionRegistry*) registry {
}
@end

@interface Envelope ()
@property EnvelopeType type;
@property (strong) NSString* source;
@property UInt32 sourceDevice;
@property (strong) NSString* relay;
@property UInt64 timestamp;
@property (strong) NSData* legacyMessage;
@property (strong) NSData* content;
@end

@implementation Envelope

- (BOOL) hasType {
  return !!hasType_;
}
- (void) setHasType:(BOOL) value_ {
  hasType_ = !!value_;
}
@synthesize type;
- (BOOL) hasSource {
  return !!hasSource_;
}
- (void) setHasSource:(BOOL) value_ {
  hasSource_ = !!value_;
}
@synthesize source;
- (BOOL) hasSourceDevice {
  return !!hasSourceDevice_;
}
- (void) setHasSourceDevice:(BOOL) value_ {
  hasSourceDevice_ = !!value_;
}
@synthesize sourceDevice;
- (BOOL) hasRelay {
  return !!hasRelay_;
}
- (void) setHasRelay:(BOOL) value_ {
  hasRelay_ = !!value_;
}
@synthesize relay;
- (BOOL) hasTimestamp {
  return !!hasTimestamp_;
}
- (void) setHasTimestamp:(BOOL) value_ {
  hasTimestamp_ = !!value_;
}
@synthesize timestamp;
- (BOOL) hasLegacyMessage {
  return !!hasLegacyMessage_;
}
- (void) setHasLegacyMessage:(BOOL) value_ {
  hasLegacyMessage_ = !!value_;
}
@synthesize legacyMessage;
- (BOOL) hasContent {
  return !!hasContent_;
}
- (void) setHasContent:(BOOL) value_ {
  hasContent_ = !!value_;
}
@synthesize content;
- (id) init {
  if ((self = [super init])) {
    self.type = EnvelopeTypeUnknown;
    self.source = @"";
    self.sourceDevice = 0;
    self.relay = @"";
    self.timestamp = 0L;
    self.legacyMessage = [NSData data];
    self.content = [NSData data];
  }
  return self;
}
static Envelope* defaultEnvelopeInstance = nil;
+ (void) initialize {
  if (self == [Envelope class]) {
    defaultEnvelopeInstance = [[Envelope alloc] init];
  }
}
+ (Envelope*) defaultInstance {
  return defaultEnvelopeInstance;
}
- (Envelope*) defaultInstance {
  return defaultEnvelopeInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasType) {
    [output writeEnum:1 value:self.type];
  }
  if (self.hasSource) {
    [output writeString:2 value:self.source];
  }
  if (self.hasRelay) {
    [output writeString:3 value:self.relay];
  }
  if (self.hasTimestamp) {
    [output writeUInt64:5 value:self.timestamp];
  }
  if (self.hasLegacyMessage) {
    [output writeData:6 value:self.legacyMessage];
  }
  if (self.hasSourceDevice) {
    [output writeUInt32:7 value:self.sourceDevice];
  }
  if (self.hasContent) {
    [output writeData:8 value:self.content];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasType) {
    size_ += computeEnumSize(1, self.type);
  }
  if (self.hasSource) {
    size_ += computeStringSize(2, self.source);
  }
  if (self.hasRelay) {
    size_ += computeStringSize(3, self.relay);
  }
  if (self.hasTimestamp) {
    size_ += computeUInt64Size(5, self.timestamp);
  }
  if (self.hasLegacyMessage) {
    size_ += computeDataSize(6, self.legacyMessage);
  }
  if (self.hasSourceDevice) {
    size_ += computeUInt32Size(7, self.sourceDevice);
  }
  if (self.hasContent) {
    size_ += computeDataSize(8, self.content);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (Envelope*) parseFromData:(NSData*) data {
  return (Envelope*)[[[Envelope builder] mergeFromData:data] build];
}
+ (Envelope*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (Envelope*)[[[Envelope builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (Envelope*) parseFromInputStream:(NSInputStream*) input {
  return (Envelope*)[[[Envelope builder] mergeFromInputStream:input] build];
}
+ (Envelope*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (Envelope*)[[[Envelope builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (Envelope*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (Envelope*)[[[Envelope builder] mergeFromCodedInputStream:input] build];
}
+ (Envelope*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (Envelope*)[[[Envelope builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (EnvelopeBuilder*) builder {
  return [[EnvelopeBuilder alloc] init];
}
+ (EnvelopeBuilder*) builderWithPrototype:(Envelope*) prototype {
  return [[Envelope builder] mergeFrom:prototype];
}
- (EnvelopeBuilder*) builder {
  return [Envelope builder];
}
- (EnvelopeBuilder*) toBuilder {
  return [Envelope builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"type", self.type];
  }
  if (self.hasSource) {
    [output appendFormat:@"%@%@: %@\n", indent, @"source", self.source];
  }
  if (self.hasRelay) {
    [output appendFormat:@"%@%@: %@\n", indent, @"relay", self.relay];
  }
  if (self.hasTimestamp) {
    [output appendFormat:@"%@%@: %@\n", indent, @"timestamp", [NSNumber numberWithLongLong:self.timestamp]];
  }
  if (self.hasLegacyMessage) {
    [output appendFormat:@"%@%@: %@\n", indent, @"legacyMessage", self.legacyMessage];
  }
  if (self.hasSourceDevice) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sourceDevice", [NSNumber numberWithInteger:self.sourceDevice]];
  }
  if (self.hasContent) {
    [output appendFormat:@"%@%@: %@\n", indent, @"content", self.content];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[Envelope class]]) {
    return NO;
  }
  Envelope *otherMessage = other;
  return
      self.hasType == otherMessage.hasType &&
      (!self.hasType || self.type == otherMessage.type) &&
      self.hasSource == otherMessage.hasSource &&
      (!self.hasSource || [self.source isEqual:otherMessage.source]) &&
      self.hasRelay == otherMessage.hasRelay &&
      (!self.hasRelay || [self.relay isEqual:otherMessage.relay]) &&
      self.hasTimestamp == otherMessage.hasTimestamp &&
      (!self.hasTimestamp || self.timestamp == otherMessage.timestamp) &&
      self.hasLegacyMessage == otherMessage.hasLegacyMessage &&
      (!self.hasLegacyMessage || [self.legacyMessage isEqual:otherMessage.legacyMessage]) &&
      self.hasSourceDevice == otherMessage.hasSourceDevice &&
      (!self.hasSourceDevice || self.sourceDevice == otherMessage.sourceDevice) &&
      self.hasContent == otherMessage.hasContent &&
      (!self.hasContent || [self.content isEqual:otherMessage.content]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasType) {
    hashCode = hashCode * 31 + self.type;
  }
  if (self.hasSource) {
    hashCode = hashCode * 31 + [self.source hash];
  }
  if (self.hasRelay) {
    hashCode = hashCode * 31 + [self.relay hash];
  }
  if (self.hasTimestamp) {
    hashCode = hashCode * 31 + [[NSNumber numberWithLongLong:self.timestamp] hash];
  }
  if (self.hasLegacyMessage) {
    hashCode = hashCode * 31 + [self.legacyMessage hash];
  }
  if (self.hasSourceDevice) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sourceDevice] hash];
  }
  if (self.hasContent) {
    hashCode = hashCode * 31 + [self.content hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

BOOL EnvelopeTypeIsValidValue(EnvelopeType value) {
  switch (value) {
    case EnvelopeTypeUnknown:
    case EnvelopeTypeCiphertext:
    case EnvelopeTypeKeyExchange:
    case EnvelopeTypePrekeyBundle:
    case EnvelopeTypeReceipt:
      return YES;
    default:
      return NO;
  }
}
@interface EnvelopeBuilder()
@property (strong) Envelope* result;
@end

@implementation EnvelopeBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[Envelope alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (EnvelopeBuilder*) clear {
  self.result = [[Envelope alloc] init];
  return self;
}
- (EnvelopeBuilder*) clone {
  return [Envelope builderWithPrototype:result];
}
- (Envelope*) defaultInstance {
  return [Envelope defaultInstance];
}
- (Envelope*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (Envelope*) buildPartial {
  Envelope* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (EnvelopeBuilder*) mergeFrom:(Envelope*) other {
  if (other == [Envelope defaultInstance]) {
    return self;
  }
  if (other.hasType) {
    [self setType:other.type];
  }
  if (other.hasSource) {
    [self setSource:other.source];
  }
  if (other.hasSourceDevice) {
    [self setSourceDevice:other.sourceDevice];
  }
  if (other.hasRelay) {
    [self setRelay:other.relay];
  }
  if (other.hasTimestamp) {
    [self setTimestamp:other.timestamp];
  }
  if (other.hasLegacyMessage) {
    [self setLegacyMessage:other.legacyMessage];
  }
  if (other.hasContent) {
    [self setContent:other.content];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (EnvelopeBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (EnvelopeBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        EnvelopeType value = (EnvelopeType)[input readEnum];
        if (EnvelopeTypeIsValidValue(value)) {
          [self setType:value];
        } else {
          [unknownFields mergeVarintField:1 value:value];
        }
        break;
      }
      case 18: {
        [self setSource:[input readString]];
        break;
      }
      case 26: {
        [self setRelay:[input readString]];
        break;
      }
      case 40: {
        [self setTimestamp:[input readUInt64]];
        break;
      }
      case 50: {
        [self setLegacyMessage:[input readData]];
        break;
      }
      case 56: {
        [self setSourceDevice:[input readUInt32]];
        break;
      }
      case 66: {
        [self setContent:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasType {
  return result.hasType;
}
- (EnvelopeType) type {
  return result.type;
}
- (EnvelopeBuilder*) setType:(EnvelopeType) value {
  result.hasType = YES;
  result.type = value;
  return self;
}
- (EnvelopeBuilder*) clearType {
  result.hasType = NO;
  result.type = EnvelopeTypeUnknown;
  return self;
}
- (BOOL) hasSource {
  return result.hasSource;
}
- (NSString*) source {
  return result.source;
}
- (EnvelopeBuilder*) setSource:(NSString*) value {
  result.hasSource = YES;
  result.source = value;
  return self;
}
- (EnvelopeBuilder*) clearSource {
  result.hasSource = NO;
  result.source = @"";
  return self;
}
- (BOOL) hasSourceDevice {
  return result.hasSourceDevice;
}
- (UInt32) sourceDevice {
  return result.sourceDevice;
}
- (EnvelopeBuilder*) setSourceDevice:(UInt32) value {
  result.hasSourceDevice = YES;
  result.sourceDevice = value;
  return self;
}
- (EnvelopeBuilder*) clearSourceDevice {
  result.hasSourceDevice = NO;
  result.sourceDevice = 0;
  return self;
}
- (BOOL) hasRelay {
  return result.hasRelay;
}
- (NSString*) relay {
  return result.relay;
}
- (EnvelopeBuilder*) setRelay:(NSString*) value {
  result.hasRelay = YES;
  result.relay = value;
  return self;
}
- (EnvelopeBuilder*) clearRelay {
  result.hasRelay = NO;
  result.relay = @"";
  return self;
}
- (BOOL) hasTimestamp {
  return result.hasTimestamp;
}
- (UInt64) timestamp {
  return result.timestamp;
}
- (EnvelopeBuilder*) setTimestamp:(UInt64) value {
  result.hasTimestamp = YES;
  result.timestamp = value;
  return self;
}
- (EnvelopeBuilder*) clearTimestamp {
  result.hasTimestamp = NO;
  result.timestamp = 0L;
  return self;
}
- (BOOL) hasLegacyMessage {
  return result.hasLegacyMessage;
}
- (NSData*) legacyMessage {
  return result.legacyMessage;
}
- (EnvelopeBuilder*) setLegacyMessage:(NSData*) value {
  result.hasLegacyMessage = YES;
  result.legacyMessage = value;
  return self;
}
- (EnvelopeBuilder*) clearLegacyMessage {
  result.hasLegacyMessage = NO;
  result.legacyMessage = [NSData data];
  return self;
}
- (BOOL) hasContent {
  return result.hasContent;
}
- (NSData*) content {
  return result.content;
}
- (EnvelopeBuilder*) setContent:(NSData*) value {
  result.hasContent = YES;
  result.content = value;
  return self;
}
- (EnvelopeBuilder*) clearContent {
  result.hasContent = NO;
  result.content = [NSData data];
  return self;
}
@end

@interface Content ()
@property (strong) DataMessage* dataMessage;
@property (strong) SyncMessage* syncMessage;
@end

@implementation Content

- (BOOL) hasDataMessage {
  return !!hasDataMessage_;
}
- (void) setHasDataMessage:(BOOL) value_ {
  hasDataMessage_ = !!value_;
}
@synthesize dataMessage;
- (BOOL) hasSyncMessage {
  return !!hasSyncMessage_;
}
- (void) setHasSyncMessage:(BOOL) value_ {
  hasSyncMessage_ = !!value_;
}
@synthesize syncMessage;
- (id) init {
  if ((self = [super init])) {
    self.dataMessage = [DataMessage defaultInstance];
    self.syncMessage = [SyncMessage defaultInstance];
  }
  return self;
}
static Content* defaultContentInstance = nil;
+ (void) initialize {
  if (self == [Content class]) {
    defaultContentInstance = [[Content alloc] init];
  }
}
+ (Content*) defaultInstance {
  return defaultContentInstance;
}
- (Content*) defaultInstance {
  return defaultContentInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasDataMessage) {
    [output writeMessage:1 value:self.dataMessage];
  }
  if (self.hasSyncMessage) {
    [output writeMessage:2 value:self.syncMessage];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasDataMessage) {
    size_ += computeMessageSize(1, self.dataMessage);
  }
  if (self.hasSyncMessage) {
    size_ += computeMessageSize(2, self.syncMessage);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (Content*) parseFromData:(NSData*) data {
  return (Content*)[[[Content builder] mergeFromData:data] build];
}
+ (Content*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (Content*)[[[Content builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (Content*) parseFromInputStream:(NSInputStream*) input {
  return (Content*)[[[Content builder] mergeFromInputStream:input] build];
}
+ (Content*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (Content*)[[[Content builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (Content*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (Content*)[[[Content builder] mergeFromCodedInputStream:input] build];
}
+ (Content*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (Content*)[[[Content builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ContentBuilder*) builder {
  return [[ContentBuilder alloc] init];
}
+ (ContentBuilder*) builderWithPrototype:(Content*) prototype {
  return [[Content builder] mergeFrom:prototype];
}
- (ContentBuilder*) builder {
  return [Content builder];
}
- (ContentBuilder*) toBuilder {
  return [Content builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasDataMessage) {
    [output appendFormat:@"%@%@ {\n", indent, @"dataMessage"];
    [self.dataMessage writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  if (self.hasSyncMessage) {
    [output appendFormat:@"%@%@ {\n", indent, @"syncMessage"];
    [self.syncMessage writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[Content class]]) {
    return NO;
  }
  Content *otherMessage = other;
  return
      self.hasDataMessage == otherMessage.hasDataMessage &&
      (!self.hasDataMessage || [self.dataMessage isEqual:otherMessage.dataMessage]) &&
      self.hasSyncMessage == otherMessage.hasSyncMessage &&
      (!self.hasSyncMessage || [self.syncMessage isEqual:otherMessage.syncMessage]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasDataMessage) {
    hashCode = hashCode * 31 + [self.dataMessage hash];
  }
  if (self.hasSyncMessage) {
    hashCode = hashCode * 31 + [self.syncMessage hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface ContentBuilder()
@property (strong) Content* result;
@end

@implementation ContentBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[Content alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ContentBuilder*) clear {
  self.result = [[Content alloc] init];
  return self;
}
- (ContentBuilder*) clone {
  return [Content builderWithPrototype:result];
}
- (Content*) defaultInstance {
  return [Content defaultInstance];
}
- (Content*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (Content*) buildPartial {
  Content* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ContentBuilder*) mergeFrom:(Content*) other {
  if (other == [Content defaultInstance]) {
    return self;
  }
  if (other.hasDataMessage) {
    [self mergeDataMessage:other.dataMessage];
  }
  if (other.hasSyncMessage) {
    [self mergeSyncMessage:other.syncMessage];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ContentBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ContentBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        DataMessageBuilder* subBuilder = [DataMessage builder];
        if (self.hasDataMessage) {
          [subBuilder mergeFrom:self.dataMessage];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setDataMessage:[subBuilder buildPartial]];
        break;
      }
      case 18: {
        SyncMessageBuilder* subBuilder = [SyncMessage builder];
        if (self.hasSyncMessage) {
          [subBuilder mergeFrom:self.syncMessage];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setSyncMessage:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasDataMessage {
  return result.hasDataMessage;
}
- (DataMessage*) dataMessage {
  return result.dataMessage;
}
- (ContentBuilder*) setDataMessage:(DataMessage*) value {
  result.hasDataMessage = YES;
  result.dataMessage = value;
  return self;
}
- (ContentBuilder*) setDataMessageBuilder:(DataMessageBuilder*) builderForValue {
  return [self setDataMessage:[builderForValue build]];
}
- (ContentBuilder*) mergeDataMessage:(DataMessage*) value {
  if (result.hasDataMessage &&
      result.dataMessage != [DataMessage defaultInstance]) {
    result.dataMessage =
      [[[DataMessage builderWithPrototype:result.dataMessage] mergeFrom:value] buildPartial];
  } else {
    result.dataMessage = value;
  }
  result.hasDataMessage = YES;
  return self;
}
- (ContentBuilder*) clearDataMessage {
  result.hasDataMessage = NO;
  result.dataMessage = [DataMessage defaultInstance];
  return self;
}
- (BOOL) hasSyncMessage {
  return result.hasSyncMessage;
}
- (SyncMessage*) syncMessage {
  return result.syncMessage;
}
- (ContentBuilder*) setSyncMessage:(SyncMessage*) value {
  result.hasSyncMessage = YES;
  result.syncMessage = value;
  return self;
}
- (ContentBuilder*) setSyncMessageBuilder:(SyncMessageBuilder*) builderForValue {
  return [self setSyncMessage:[builderForValue build]];
}
- (ContentBuilder*) mergeSyncMessage:(SyncMessage*) value {
  if (result.hasSyncMessage &&
      result.syncMessage != [SyncMessage defaultInstance]) {
    result.syncMessage =
      [[[SyncMessage builderWithPrototype:result.syncMessage] mergeFrom:value] buildPartial];
  } else {
    result.syncMessage = value;
  }
  result.hasSyncMessage = YES;
  return self;
}
- (ContentBuilder*) clearSyncMessage {
  result.hasSyncMessage = NO;
  result.syncMessage = [SyncMessage defaultInstance];
  return self;
}
@end

@interface DataMessage ()
@property (strong) NSString* body;
@property (strong) NSMutableArray * attachmentsArray;
@property (strong) GroupContext* group;
@property UInt32 flags;
@end

@implementation DataMessage

- (BOOL) hasBody {
  return !!hasBody_;
}
- (void) setHasBody:(BOOL) value_ {
  hasBody_ = !!value_;
}
@synthesize body;
@synthesize attachmentsArray;
@dynamic attachments;
- (BOOL) hasGroup {
  return !!hasGroup_;
}
- (void) setHasGroup:(BOOL) value_ {
  hasGroup_ = !!value_;
}
@synthesize group;
- (BOOL) hasFlags {
  return !!hasFlags_;
}
- (void) setHasFlags:(BOOL) value_ {
  hasFlags_ = !!value_;
}
@synthesize flags;
- (id) init {
  if ((self = [super init])) {
    self.body = @"";
    self.group = [GroupContext defaultInstance];
    self.flags = 0;
  }
  return self;
}
static DataMessage* defaultDataMessageInstance = nil;
+ (void) initialize {
  if (self == [DataMessage class]) {
    defaultDataMessageInstance = [[DataMessage alloc] init];
  }
}
+ (DataMessage*) defaultInstance {
  return defaultDataMessageInstance;
}
- (DataMessage*) defaultInstance {
  return defaultDataMessageInstance;
}
- (NSArray *)attachments {
  return attachmentsArray;
}
- (AttachmentPointer*)attachmentsAtIndex:(NSUInteger)index {
  return [attachmentsArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasBody) {
    [output writeString:1 value:self.body];
  }
  [self.attachmentsArray enumerateObjectsUsingBlock:^(AttachmentPointer *element, NSUInteger idx, BOOL *stop) {
    [output writeMessage:2 value:element];
  }];
  if (self.hasGroup) {
    [output writeMessage:3 value:self.group];
  }
  if (self.hasFlags) {
    [output writeUInt32:4 value:self.flags];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasBody) {
    size_ += computeStringSize(1, self.body);
  }
  [self.attachmentsArray enumerateObjectsUsingBlock:^(AttachmentPointer *element, NSUInteger idx, BOOL *stop) {
    size_ += computeMessageSize(2, element);
  }];
  if (self.hasGroup) {
    size_ += computeMessageSize(3, self.group);
  }
  if (self.hasFlags) {
    size_ += computeUInt32Size(4, self.flags);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (DataMessage*) parseFromData:(NSData*) data {
  return (DataMessage*)[[[DataMessage builder] mergeFromData:data] build];
}
+ (DataMessage*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (DataMessage*)[[[DataMessage builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (DataMessage*) parseFromInputStream:(NSInputStream*) input {
  return (DataMessage*)[[[DataMessage builder] mergeFromInputStream:input] build];
}
+ (DataMessage*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (DataMessage*)[[[DataMessage builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (DataMessage*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (DataMessage*)[[[DataMessage builder] mergeFromCodedInputStream:input] build];
}
+ (DataMessage*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (DataMessage*)[[[DataMessage builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (DataMessageBuilder*) builder {
  return [[DataMessageBuilder alloc] init];
}
+ (DataMessageBuilder*) builderWithPrototype:(DataMessage*) prototype {
  return [[DataMessage builder] mergeFrom:prototype];
}
- (DataMessageBuilder*) builder {
  return [DataMessage builder];
}
- (DataMessageBuilder*) toBuilder {
  return [DataMessage builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasBody) {
    [output appendFormat:@"%@%@: %@\n", indent, @"body", self.body];
  }
  [self.attachmentsArray enumerateObjectsUsingBlock:^(AttachmentPointer *element, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@ {\n", indent, @"attachments"];
    [element writeDescriptionTo:output
                     withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }];
  if (self.hasGroup) {
    [output appendFormat:@"%@%@ {\n", indent, @"group"];
    [self.group writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  if (self.hasFlags) {
    [output appendFormat:@"%@%@: %@\n", indent, @"flags", [NSNumber numberWithInteger:self.flags]];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[DataMessage class]]) {
    return NO;
  }
  DataMessage *otherMessage = other;
  return
      self.hasBody == otherMessage.hasBody &&
      (!self.hasBody || [self.body isEqual:otherMessage.body]) &&
      [self.attachmentsArray isEqualToArray:otherMessage.attachmentsArray] &&
      self.hasGroup == otherMessage.hasGroup &&
      (!self.hasGroup || [self.group isEqual:otherMessage.group]) &&
      self.hasFlags == otherMessage.hasFlags &&
      (!self.hasFlags || self.flags == otherMessage.flags) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasBody) {
    hashCode = hashCode * 31 + [self.body hash];
  }
  [self.attachmentsArray enumerateObjectsUsingBlock:^(AttachmentPointer *element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasGroup) {
    hashCode = hashCode * 31 + [self.group hash];
  }
  if (self.hasFlags) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.flags] hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

BOOL DataMessageFlagsIsValidValue(DataMessageFlags value) {
  switch (value) {
    case DataMessageFlagsEndSession:
      return YES;
    default:
      return NO;
  }
}
@interface DataMessageBuilder()
@property (strong) DataMessage* result;
@end

@implementation DataMessageBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[DataMessage alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (DataMessageBuilder*) clear {
  self.result = [[DataMessage alloc] init];
  return self;
}
- (DataMessageBuilder*) clone {
  return [DataMessage builderWithPrototype:result];
}
- (DataMessage*) defaultInstance {
  return [DataMessage defaultInstance];
}
- (DataMessage*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (DataMessage*) buildPartial {
  DataMessage* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (DataMessageBuilder*) mergeFrom:(DataMessage*) other {
  if (other == [DataMessage defaultInstance]) {
    return self;
  }
  if (other.hasBody) {
    [self setBody:other.body];
  }
  if (other.attachmentsArray.count > 0) {
    if (result.attachmentsArray == nil) {
      result.attachmentsArray = [[NSMutableArray alloc] initWithArray:other.attachmentsArray];
    } else {
      [result.attachmentsArray addObjectsFromArray:other.attachmentsArray];
    }
  }
  if (other.hasGroup) {
    [self mergeGroup:other.group];
  }
  if (other.hasFlags) {
    [self setFlags:other.flags];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (DataMessageBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (DataMessageBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self setBody:[input readString]];
        break;
      }
      case 18: {
        AttachmentPointerBuilder* subBuilder = [AttachmentPointer builder];
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self addAttachments:[subBuilder buildPartial]];
        break;
      }
      case 26: {
        GroupContextBuilder* subBuilder = [GroupContext builder];
        if (self.hasGroup) {
          [subBuilder mergeFrom:self.group];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setGroup:[subBuilder buildPartial]];
        break;
      }
      case 32: {
        [self setFlags:[input readUInt32]];
        break;
      }
    }
  }
}
- (BOOL) hasBody {
  return result.hasBody;
}
- (NSString*) body {
  return result.body;
}
- (DataMessageBuilder*) setBody:(NSString*) value {
  result.hasBody = YES;
  result.body = value;
  return self;
}
- (DataMessageBuilder*) clearBody {
  result.hasBody = NO;
  result.body = @"";
  return self;
}
- (NSMutableArray *)attachments {
  return result.attachmentsArray;
}
- (AttachmentPointer*)attachmentsAtIndex:(NSUInteger)index {
  return [result attachmentsAtIndex:index];
}
- (DataMessageBuilder *)addAttachments:(AttachmentPointer*)value {
  if (result.attachmentsArray == nil) {
    result.attachmentsArray = [[NSMutableArray alloc]init];
  }
  [result.attachmentsArray addObject:value];
  return self;
}
- (DataMessageBuilder *)setAttachmentsArray:(NSArray *)array {
  result.attachmentsArray = [[NSMutableArray alloc]initWithArray:array];
  return self;
}
- (DataMessageBuilder *)clearAttachments {
  result.attachmentsArray = nil;
  return self;
}
- (BOOL) hasGroup {
  return result.hasGroup;
}
- (GroupContext*) group {
  return result.group;
}
- (DataMessageBuilder*) setGroup:(GroupContext*) value {
  result.hasGroup = YES;
  result.group = value;
  return self;
}
- (DataMessageBuilder*) setGroupBuilder:(GroupContextBuilder*) builderForValue {
  return [self setGroup:[builderForValue build]];
}
- (DataMessageBuilder*) mergeGroup:(GroupContext*) value {
  if (result.hasGroup &&
      result.group != [GroupContext defaultInstance]) {
    result.group =
      [[[GroupContext builderWithPrototype:result.group] mergeFrom:value] buildPartial];
  } else {
    result.group = value;
  }
  result.hasGroup = YES;
  return self;
}
- (DataMessageBuilder*) clearGroup {
  result.hasGroup = NO;
  result.group = [GroupContext defaultInstance];
  return self;
}
- (BOOL) hasFlags {
  return result.hasFlags;
}
- (UInt32) flags {
  return result.flags;
}
- (DataMessageBuilder*) setFlags:(UInt32) value {
  result.hasFlags = YES;
  result.flags = value;
  return self;
}
- (DataMessageBuilder*) clearFlags {
  result.hasFlags = NO;
  result.flags = 0;
  return self;
}
@end

@interface SyncMessage ()
@property (strong) SyncMessageSent* sent;
@property (strong) SyncMessageContacts* contacts;
@property (strong) SyncMessageGroups* groups;
@property (strong) SyncMessageRequest* request;
@end

@implementation SyncMessage

- (BOOL) hasSent {
  return !!hasSent_;
}
- (void) setHasSent:(BOOL) value_ {
  hasSent_ = !!value_;
}
@synthesize sent;
- (BOOL) hasContacts {
  return !!hasContacts_;
}
- (void) setHasContacts:(BOOL) value_ {
  hasContacts_ = !!value_;
}
@synthesize contacts;
- (BOOL) hasGroups {
  return !!hasGroups_;
}
- (void) setHasGroups:(BOOL) value_ {
  hasGroups_ = !!value_;
}
@synthesize groups;
- (BOOL) hasRequest {
  return !!hasRequest_;
}
- (void) setHasRequest:(BOOL) value_ {
  hasRequest_ = !!value_;
}
@synthesize request;
- (id) init {
  if ((self = [super init])) {
    self.sent = [SyncMessageSent defaultInstance];
    self.contacts = [SyncMessageContacts defaultInstance];
    self.groups = [SyncMessageGroups defaultInstance];
    self.request = [SyncMessageRequest defaultInstance];
  }
  return self;
}
static SyncMessage* defaultSyncMessageInstance = nil;
+ (void) initialize {
  if (self == [SyncMessage class]) {
    defaultSyncMessageInstance = [[SyncMessage alloc] init];
  }
}
+ (SyncMessage*) defaultInstance {
  return defaultSyncMessageInstance;
}
- (SyncMessage*) defaultInstance {
  return defaultSyncMessageInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasSent) {
    [output writeMessage:1 value:self.sent];
  }
  if (self.hasContacts) {
    [output writeMessage:2 value:self.contacts];
  }
  if (self.hasGroups) {
    [output writeMessage:3 value:self.groups];
  }
  if (self.hasRequest) {
    [output writeMessage:4 value:self.request];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasSent) {
    size_ += computeMessageSize(1, self.sent);
  }
  if (self.hasContacts) {
    size_ += computeMessageSize(2, self.contacts);
  }
  if (self.hasGroups) {
    size_ += computeMessageSize(3, self.groups);
  }
  if (self.hasRequest) {
    size_ += computeMessageSize(4, self.request);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (SyncMessage*) parseFromData:(NSData*) data {
  return (SyncMessage*)[[[SyncMessage builder] mergeFromData:data] build];
}
+ (SyncMessage*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessage*)[[[SyncMessage builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (SyncMessage*) parseFromInputStream:(NSInputStream*) input {
  return (SyncMessage*)[[[SyncMessage builder] mergeFromInputStream:input] build];
}
+ (SyncMessage*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessage*)[[[SyncMessage builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessage*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (SyncMessage*)[[[SyncMessage builder] mergeFromCodedInputStream:input] build];
}
+ (SyncMessage*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessage*)[[[SyncMessage builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageBuilder*) builder {
  return [[SyncMessageBuilder alloc] init];
}
+ (SyncMessageBuilder*) builderWithPrototype:(SyncMessage*) prototype {
  return [[SyncMessage builder] mergeFrom:prototype];
}
- (SyncMessageBuilder*) builder {
  return [SyncMessage builder];
}
- (SyncMessageBuilder*) toBuilder {
  return [SyncMessage builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasSent) {
    [output appendFormat:@"%@%@ {\n", indent, @"sent"];
    [self.sent writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  if (self.hasContacts) {
    [output appendFormat:@"%@%@ {\n", indent, @"contacts"];
    [self.contacts writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  if (self.hasGroups) {
    [output appendFormat:@"%@%@ {\n", indent, @"groups"];
    [self.groups writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  if (self.hasRequest) {
    [output appendFormat:@"%@%@ {\n", indent, @"request"];
    [self.request writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[SyncMessage class]]) {
    return NO;
  }
  SyncMessage *otherMessage = other;
  return
      self.hasSent == otherMessage.hasSent &&
      (!self.hasSent || [self.sent isEqual:otherMessage.sent]) &&
      self.hasContacts == otherMessage.hasContacts &&
      (!self.hasContacts || [self.contacts isEqual:otherMessage.contacts]) &&
      self.hasGroups == otherMessage.hasGroups &&
      (!self.hasGroups || [self.groups isEqual:otherMessage.groups]) &&
      self.hasRequest == otherMessage.hasRequest &&
      (!self.hasRequest || [self.request isEqual:otherMessage.request]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasSent) {
    hashCode = hashCode * 31 + [self.sent hash];
  }
  if (self.hasContacts) {
    hashCode = hashCode * 31 + [self.contacts hash];
  }
  if (self.hasGroups) {
    hashCode = hashCode * 31 + [self.groups hash];
  }
  if (self.hasRequest) {
    hashCode = hashCode * 31 + [self.request hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface SyncMessageSent ()
@property (strong) NSString* destination;
@property UInt64 timestamp;
@property (strong) DataMessage* message;
@end

@implementation SyncMessageSent

- (BOOL) hasDestination {
  return !!hasDestination_;
}
- (void) setHasDestination:(BOOL) value_ {
  hasDestination_ = !!value_;
}
@synthesize destination;
- (BOOL) hasTimestamp {
  return !!hasTimestamp_;
}
- (void) setHasTimestamp:(BOOL) value_ {
  hasTimestamp_ = !!value_;
}
@synthesize timestamp;
- (BOOL) hasMessage {
  return !!hasMessage_;
}
- (void) setHasMessage:(BOOL) value_ {
  hasMessage_ = !!value_;
}
@synthesize message;
- (id) init {
  if ((self = [super init])) {
    self.destination = @"";
    self.timestamp = 0L;
    self.message = [DataMessage defaultInstance];
  }
  return self;
}
static SyncMessageSent* defaultSyncMessageSentInstance = nil;
+ (void) initialize {
  if (self == [SyncMessageSent class]) {
    defaultSyncMessageSentInstance = [[SyncMessageSent alloc] init];
  }
}
+ (SyncMessageSent*) defaultInstance {
  return defaultSyncMessageSentInstance;
}
- (SyncMessageSent*) defaultInstance {
  return defaultSyncMessageSentInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasDestination) {
    [output writeString:1 value:self.destination];
  }
  if (self.hasTimestamp) {
    [output writeUInt64:2 value:self.timestamp];
  }
  if (self.hasMessage) {
    [output writeMessage:3 value:self.message];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasDestination) {
    size_ += computeStringSize(1, self.destination);
  }
  if (self.hasTimestamp) {
    size_ += computeUInt64Size(2, self.timestamp);
  }
  if (self.hasMessage) {
    size_ += computeMessageSize(3, self.message);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (SyncMessageSent*) parseFromData:(NSData*) data {
  return (SyncMessageSent*)[[[SyncMessageSent builder] mergeFromData:data] build];
}
+ (SyncMessageSent*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageSent*)[[[SyncMessageSent builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageSent*) parseFromInputStream:(NSInputStream*) input {
  return (SyncMessageSent*)[[[SyncMessageSent builder] mergeFromInputStream:input] build];
}
+ (SyncMessageSent*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageSent*)[[[SyncMessageSent builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageSent*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (SyncMessageSent*)[[[SyncMessageSent builder] mergeFromCodedInputStream:input] build];
}
+ (SyncMessageSent*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageSent*)[[[SyncMessageSent builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageSentBuilder*) builder {
  return [[SyncMessageSentBuilder alloc] init];
}
+ (SyncMessageSentBuilder*) builderWithPrototype:(SyncMessageSent*) prototype {
  return [[SyncMessageSent builder] mergeFrom:prototype];
}
- (SyncMessageSentBuilder*) builder {
  return [SyncMessageSent builder];
}
- (SyncMessageSentBuilder*) toBuilder {
  return [SyncMessageSent builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasDestination) {
    [output appendFormat:@"%@%@: %@\n", indent, @"destination", self.destination];
  }
  if (self.hasTimestamp) {
    [output appendFormat:@"%@%@: %@\n", indent, @"timestamp", [NSNumber numberWithLongLong:self.timestamp]];
  }
  if (self.hasMessage) {
    [output appendFormat:@"%@%@ {\n", indent, @"message"];
    [self.message writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[SyncMessageSent class]]) {
    return NO;
  }
  SyncMessageSent *otherMessage = other;
  return
      self.hasDestination == otherMessage.hasDestination &&
      (!self.hasDestination || [self.destination isEqual:otherMessage.destination]) &&
      self.hasTimestamp == otherMessage.hasTimestamp &&
      (!self.hasTimestamp || self.timestamp == otherMessage.timestamp) &&
      self.hasMessage == otherMessage.hasMessage &&
      (!self.hasMessage || [self.message isEqual:otherMessage.message]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasDestination) {
    hashCode = hashCode * 31 + [self.destination hash];
  }
  if (self.hasTimestamp) {
    hashCode = hashCode * 31 + [[NSNumber numberWithLongLong:self.timestamp] hash];
  }
  if (self.hasMessage) {
    hashCode = hashCode * 31 + [self.message hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface SyncMessageSentBuilder()
@property (strong) SyncMessageSent* result;
@end

@implementation SyncMessageSentBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[SyncMessageSent alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (SyncMessageSentBuilder*) clear {
  self.result = [[SyncMessageSent alloc] init];
  return self;
}
- (SyncMessageSentBuilder*) clone {
  return [SyncMessageSent builderWithPrototype:result];
}
- (SyncMessageSent*) defaultInstance {
  return [SyncMessageSent defaultInstance];
}
- (SyncMessageSent*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (SyncMessageSent*) buildPartial {
  SyncMessageSent* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (SyncMessageSentBuilder*) mergeFrom:(SyncMessageSent*) other {
  if (other == [SyncMessageSent defaultInstance]) {
    return self;
  }
  if (other.hasDestination) {
    [self setDestination:other.destination];
  }
  if (other.hasTimestamp) {
    [self setTimestamp:other.timestamp];
  }
  if (other.hasMessage) {
    [self mergeMessage:other.message];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (SyncMessageSentBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (SyncMessageSentBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self setDestination:[input readString]];
        break;
      }
      case 16: {
        [self setTimestamp:[input readUInt64]];
        break;
      }
      case 26: {
        DataMessageBuilder* subBuilder = [DataMessage builder];
        if (self.hasMessage) {
          [subBuilder mergeFrom:self.message];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setMessage:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasDestination {
  return result.hasDestination;
}
- (NSString*) destination {
  return result.destination;
}
- (SyncMessageSentBuilder*) setDestination:(NSString*) value {
  result.hasDestination = YES;
  result.destination = value;
  return self;
}
- (SyncMessageSentBuilder*) clearDestination {
  result.hasDestination = NO;
  result.destination = @"";
  return self;
}
- (BOOL) hasTimestamp {
  return result.hasTimestamp;
}
- (UInt64) timestamp {
  return result.timestamp;
}
- (SyncMessageSentBuilder*) setTimestamp:(UInt64) value {
  result.hasTimestamp = YES;
  result.timestamp = value;
  return self;
}
- (SyncMessageSentBuilder*) clearTimestamp {
  result.hasTimestamp = NO;
  result.timestamp = 0L;
  return self;
}
- (BOOL) hasMessage {
  return result.hasMessage;
}
- (DataMessage*) message {
  return result.message;
}
- (SyncMessageSentBuilder*) setMessage:(DataMessage*) value {
  result.hasMessage = YES;
  result.message = value;
  return self;
}
- (SyncMessageSentBuilder*) setMessageBuilder:(DataMessageBuilder*) builderForValue {
  return [self setMessage:[builderForValue build]];
}
- (SyncMessageSentBuilder*) mergeMessage:(DataMessage*) value {
  if (result.hasMessage &&
      result.message != [DataMessage defaultInstance]) {
    result.message =
      [[[DataMessage builderWithPrototype:result.message] mergeFrom:value] buildPartial];
  } else {
    result.message = value;
  }
  result.hasMessage = YES;
  return self;
}
- (SyncMessageSentBuilder*) clearMessage {
  result.hasMessage = NO;
  result.message = [DataMessage defaultInstance];
  return self;
}
@end

@interface SyncMessageContacts ()
@property (strong) AttachmentPointer* blob;
@end

@implementation SyncMessageContacts

- (BOOL) hasBlob {
  return !!hasBlob_;
}
- (void) setHasBlob:(BOOL) value_ {
  hasBlob_ = !!value_;
}
@synthesize blob;
- (id) init {
  if ((self = [super init])) {
    self.blob = [AttachmentPointer defaultInstance];
  }
  return self;
}
static SyncMessageContacts* defaultSyncMessageContactsInstance = nil;
+ (void) initialize {
  if (self == [SyncMessageContacts class]) {
    defaultSyncMessageContactsInstance = [[SyncMessageContacts alloc] init];
  }
}
+ (SyncMessageContacts*) defaultInstance {
  return defaultSyncMessageContactsInstance;
}
- (SyncMessageContacts*) defaultInstance {
  return defaultSyncMessageContactsInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasBlob) {
    [output writeMessage:1 value:self.blob];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasBlob) {
    size_ += computeMessageSize(1, self.blob);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (SyncMessageContacts*) parseFromData:(NSData*) data {
  return (SyncMessageContacts*)[[[SyncMessageContacts builder] mergeFromData:data] build];
}
+ (SyncMessageContacts*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageContacts*)[[[SyncMessageContacts builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageContacts*) parseFromInputStream:(NSInputStream*) input {
  return (SyncMessageContacts*)[[[SyncMessageContacts builder] mergeFromInputStream:input] build];
}
+ (SyncMessageContacts*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageContacts*)[[[SyncMessageContacts builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageContacts*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (SyncMessageContacts*)[[[SyncMessageContacts builder] mergeFromCodedInputStream:input] build];
}
+ (SyncMessageContacts*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageContacts*)[[[SyncMessageContacts builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageContactsBuilder*) builder {
  return [[SyncMessageContactsBuilder alloc] init];
}
+ (SyncMessageContactsBuilder*) builderWithPrototype:(SyncMessageContacts*) prototype {
  return [[SyncMessageContacts builder] mergeFrom:prototype];
}
- (SyncMessageContactsBuilder*) builder {
  return [SyncMessageContacts builder];
}
- (SyncMessageContactsBuilder*) toBuilder {
  return [SyncMessageContacts builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasBlob) {
    [output appendFormat:@"%@%@ {\n", indent, @"blob"];
    [self.blob writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[SyncMessageContacts class]]) {
    return NO;
  }
  SyncMessageContacts *otherMessage = other;
  return
      self.hasBlob == otherMessage.hasBlob &&
      (!self.hasBlob || [self.blob isEqual:otherMessage.blob]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasBlob) {
    hashCode = hashCode * 31 + [self.blob hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface SyncMessageContactsBuilder()
@property (strong) SyncMessageContacts* result;
@end

@implementation SyncMessageContactsBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[SyncMessageContacts alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (SyncMessageContactsBuilder*) clear {
  self.result = [[SyncMessageContacts alloc] init];
  return self;
}
- (SyncMessageContactsBuilder*) clone {
  return [SyncMessageContacts builderWithPrototype:result];
}
- (SyncMessageContacts*) defaultInstance {
  return [SyncMessageContacts defaultInstance];
}
- (SyncMessageContacts*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (SyncMessageContacts*) buildPartial {
  SyncMessageContacts* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (SyncMessageContactsBuilder*) mergeFrom:(SyncMessageContacts*) other {
  if (other == [SyncMessageContacts defaultInstance]) {
    return self;
  }
  if (other.hasBlob) {
    [self mergeBlob:other.blob];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (SyncMessageContactsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (SyncMessageContactsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        AttachmentPointerBuilder* subBuilder = [AttachmentPointer builder];
        if (self.hasBlob) {
          [subBuilder mergeFrom:self.blob];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setBlob:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasBlob {
  return result.hasBlob;
}
- (AttachmentPointer*) blob {
  return result.blob;
}
- (SyncMessageContactsBuilder*) setBlob:(AttachmentPointer*) value {
  result.hasBlob = YES;
  result.blob = value;
  return self;
}
- (SyncMessageContactsBuilder*) setBlobBuilder:(AttachmentPointerBuilder*) builderForValue {
  return [self setBlob:[builderForValue build]];
}
- (SyncMessageContactsBuilder*) mergeBlob:(AttachmentPointer*) value {
  if (result.hasBlob &&
      result.blob != [AttachmentPointer defaultInstance]) {
    result.blob =
      [[[AttachmentPointer builderWithPrototype:result.blob] mergeFrom:value] buildPartial];
  } else {
    result.blob = value;
  }
  result.hasBlob = YES;
  return self;
}
- (SyncMessageContactsBuilder*) clearBlob {
  result.hasBlob = NO;
  result.blob = [AttachmentPointer defaultInstance];
  return self;
}
@end

@interface SyncMessageGroups ()
@property (strong) AttachmentPointer* blob;
@end

@implementation SyncMessageGroups

- (BOOL) hasBlob {
  return !!hasBlob_;
}
- (void) setHasBlob:(BOOL) value_ {
  hasBlob_ = !!value_;
}
@synthesize blob;
- (id) init {
  if ((self = [super init])) {
    self.blob = [AttachmentPointer defaultInstance];
  }
  return self;
}
static SyncMessageGroups* defaultSyncMessageGroupsInstance = nil;
+ (void) initialize {
  if (self == [SyncMessageGroups class]) {
    defaultSyncMessageGroupsInstance = [[SyncMessageGroups alloc] init];
  }
}
+ (SyncMessageGroups*) defaultInstance {
  return defaultSyncMessageGroupsInstance;
}
- (SyncMessageGroups*) defaultInstance {
  return defaultSyncMessageGroupsInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasBlob) {
    [output writeMessage:1 value:self.blob];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasBlob) {
    size_ += computeMessageSize(1, self.blob);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (SyncMessageGroups*) parseFromData:(NSData*) data {
  return (SyncMessageGroups*)[[[SyncMessageGroups builder] mergeFromData:data] build];
}
+ (SyncMessageGroups*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageGroups*)[[[SyncMessageGroups builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageGroups*) parseFromInputStream:(NSInputStream*) input {
  return (SyncMessageGroups*)[[[SyncMessageGroups builder] mergeFromInputStream:input] build];
}
+ (SyncMessageGroups*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageGroups*)[[[SyncMessageGroups builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageGroups*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (SyncMessageGroups*)[[[SyncMessageGroups builder] mergeFromCodedInputStream:input] build];
}
+ (SyncMessageGroups*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageGroups*)[[[SyncMessageGroups builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageGroupsBuilder*) builder {
  return [[SyncMessageGroupsBuilder alloc] init];
}
+ (SyncMessageGroupsBuilder*) builderWithPrototype:(SyncMessageGroups*) prototype {
  return [[SyncMessageGroups builder] mergeFrom:prototype];
}
- (SyncMessageGroupsBuilder*) builder {
  return [SyncMessageGroups builder];
}
- (SyncMessageGroupsBuilder*) toBuilder {
  return [SyncMessageGroups builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasBlob) {
    [output appendFormat:@"%@%@ {\n", indent, @"blob"];
    [self.blob writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[SyncMessageGroups class]]) {
    return NO;
  }
  SyncMessageGroups *otherMessage = other;
  return
      self.hasBlob == otherMessage.hasBlob &&
      (!self.hasBlob || [self.blob isEqual:otherMessage.blob]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasBlob) {
    hashCode = hashCode * 31 + [self.blob hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface SyncMessageGroupsBuilder()
@property (strong) SyncMessageGroups* result;
@end

@implementation SyncMessageGroupsBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[SyncMessageGroups alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (SyncMessageGroupsBuilder*) clear {
  self.result = [[SyncMessageGroups alloc] init];
  return self;
}
- (SyncMessageGroupsBuilder*) clone {
  return [SyncMessageGroups builderWithPrototype:result];
}
- (SyncMessageGroups*) defaultInstance {
  return [SyncMessageGroups defaultInstance];
}
- (SyncMessageGroups*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (SyncMessageGroups*) buildPartial {
  SyncMessageGroups* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (SyncMessageGroupsBuilder*) mergeFrom:(SyncMessageGroups*) other {
  if (other == [SyncMessageGroups defaultInstance]) {
    return self;
  }
  if (other.hasBlob) {
    [self mergeBlob:other.blob];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (SyncMessageGroupsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (SyncMessageGroupsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        AttachmentPointerBuilder* subBuilder = [AttachmentPointer builder];
        if (self.hasBlob) {
          [subBuilder mergeFrom:self.blob];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setBlob:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasBlob {
  return result.hasBlob;
}
- (AttachmentPointer*) blob {
  return result.blob;
}
- (SyncMessageGroupsBuilder*) setBlob:(AttachmentPointer*) value {
  result.hasBlob = YES;
  result.blob = value;
  return self;
}
- (SyncMessageGroupsBuilder*) setBlobBuilder:(AttachmentPointerBuilder*) builderForValue {
  return [self setBlob:[builderForValue build]];
}
- (SyncMessageGroupsBuilder*) mergeBlob:(AttachmentPointer*) value {
  if (result.hasBlob &&
      result.blob != [AttachmentPointer defaultInstance]) {
    result.blob =
      [[[AttachmentPointer builderWithPrototype:result.blob] mergeFrom:value] buildPartial];
  } else {
    result.blob = value;
  }
  result.hasBlob = YES;
  return self;
}
- (SyncMessageGroupsBuilder*) clearBlob {
  result.hasBlob = NO;
  result.blob = [AttachmentPointer defaultInstance];
  return self;
}
@end

@interface SyncMessageRequest ()
@property SyncMessageRequestType type;
@end

@implementation SyncMessageRequest

- (BOOL) hasType {
  return !!hasType_;
}
- (void) setHasType:(BOOL) value_ {
  hasType_ = !!value_;
}
@synthesize type;
- (id) init {
  if ((self = [super init])) {
    self.type = SyncMessageRequestTypeUnknown;
  }
  return self;
}
static SyncMessageRequest* defaultSyncMessageRequestInstance = nil;
+ (void) initialize {
  if (self == [SyncMessageRequest class]) {
    defaultSyncMessageRequestInstance = [[SyncMessageRequest alloc] init];
  }
}
+ (SyncMessageRequest*) defaultInstance {
  return defaultSyncMessageRequestInstance;
}
- (SyncMessageRequest*) defaultInstance {
  return defaultSyncMessageRequestInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasType) {
    [output writeEnum:1 value:self.type];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasType) {
    size_ += computeEnumSize(1, self.type);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (SyncMessageRequest*) parseFromData:(NSData*) data {
  return (SyncMessageRequest*)[[[SyncMessageRequest builder] mergeFromData:data] build];
}
+ (SyncMessageRequest*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageRequest*)[[[SyncMessageRequest builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageRequest*) parseFromInputStream:(NSInputStream*) input {
  return (SyncMessageRequest*)[[[SyncMessageRequest builder] mergeFromInputStream:input] build];
}
+ (SyncMessageRequest*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageRequest*)[[[SyncMessageRequest builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageRequest*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (SyncMessageRequest*)[[[SyncMessageRequest builder] mergeFromCodedInputStream:input] build];
}
+ (SyncMessageRequest*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (SyncMessageRequest*)[[[SyncMessageRequest builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (SyncMessageRequestBuilder*) builder {
  return [[SyncMessageRequestBuilder alloc] init];
}
+ (SyncMessageRequestBuilder*) builderWithPrototype:(SyncMessageRequest*) prototype {
  return [[SyncMessageRequest builder] mergeFrom:prototype];
}
- (SyncMessageRequestBuilder*) builder {
  return [SyncMessageRequest builder];
}
- (SyncMessageRequestBuilder*) toBuilder {
  return [SyncMessageRequest builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"type", self.type];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[SyncMessageRequest class]]) {
    return NO;
  }
  SyncMessageRequest *otherMessage = other;
  return
      self.hasType == otherMessage.hasType &&
      (!self.hasType || self.type == otherMessage.type) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasType) {
    hashCode = hashCode * 31 + self.type;
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

BOOL SyncMessageRequestTypeIsValidValue(SyncMessageRequestType value) {
  switch (value) {
    case SyncMessageRequestTypeUnknown:
    case SyncMessageRequestTypeContacts:
    case SyncMessageRequestTypeGroups:
      return YES;
    default:
      return NO;
  }
}
@interface SyncMessageRequestBuilder()
@property (strong) SyncMessageRequest* result;
@end

@implementation SyncMessageRequestBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[SyncMessageRequest alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (SyncMessageRequestBuilder*) clear {
  self.result = [[SyncMessageRequest alloc] init];
  return self;
}
- (SyncMessageRequestBuilder*) clone {
  return [SyncMessageRequest builderWithPrototype:result];
}
- (SyncMessageRequest*) defaultInstance {
  return [SyncMessageRequest defaultInstance];
}
- (SyncMessageRequest*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (SyncMessageRequest*) buildPartial {
  SyncMessageRequest* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (SyncMessageRequestBuilder*) mergeFrom:(SyncMessageRequest*) other {
  if (other == [SyncMessageRequest defaultInstance]) {
    return self;
  }
  if (other.hasType) {
    [self setType:other.type];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (SyncMessageRequestBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (SyncMessageRequestBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        SyncMessageRequestType value = (SyncMessageRequestType)[input readEnum];
        if (SyncMessageRequestTypeIsValidValue(value)) {
          [self setType:value];
        } else {
          [unknownFields mergeVarintField:1 value:value];
        }
        break;
      }
    }
  }
}
- (BOOL) hasType {
  return result.hasType;
}
- (SyncMessageRequestType) type {
  return result.type;
}
- (SyncMessageRequestBuilder*) setType:(SyncMessageRequestType) value {
  result.hasType = YES;
  result.type = value;
  return self;
}
- (SyncMessageRequestBuilder*) clearType {
  result.hasType = NO;
  result.type = SyncMessageRequestTypeUnknown;
  return self;
}
@end

@interface SyncMessageBuilder()
@property (strong) SyncMessage* result;
@end

@implementation SyncMessageBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[SyncMessage alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (SyncMessageBuilder*) clear {
  self.result = [[SyncMessage alloc] init];
  return self;
}
- (SyncMessageBuilder*) clone {
  return [SyncMessage builderWithPrototype:result];
}
- (SyncMessage*) defaultInstance {
  return [SyncMessage defaultInstance];
}
- (SyncMessage*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (SyncMessage*) buildPartial {
  SyncMessage* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (SyncMessageBuilder*) mergeFrom:(SyncMessage*) other {
  if (other == [SyncMessage defaultInstance]) {
    return self;
  }
  if (other.hasSent) {
    [self mergeSent:other.sent];
  }
  if (other.hasContacts) {
    [self mergeContacts:other.contacts];
  }
  if (other.hasGroups) {
    [self mergeGroups:other.groups];
  }
  if (other.hasRequest) {
    [self mergeRequest:other.request];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (SyncMessageBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (SyncMessageBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        SyncMessageSentBuilder* subBuilder = [SyncMessageSent builder];
        if (self.hasSent) {
          [subBuilder mergeFrom:self.sent];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setSent:[subBuilder buildPartial]];
        break;
      }
      case 18: {
        SyncMessageContactsBuilder* subBuilder = [SyncMessageContacts builder];
        if (self.hasContacts) {
          [subBuilder mergeFrom:self.contacts];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setContacts:[subBuilder buildPartial]];
        break;
      }
      case 26: {
        SyncMessageGroupsBuilder* subBuilder = [SyncMessageGroups builder];
        if (self.hasGroups) {
          [subBuilder mergeFrom:self.groups];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setGroups:[subBuilder buildPartial]];
        break;
      }
      case 34: {
        SyncMessageRequestBuilder* subBuilder = [SyncMessageRequest builder];
        if (self.hasRequest) {
          [subBuilder mergeFrom:self.request];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setRequest:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasSent {
  return result.hasSent;
}
- (SyncMessageSent*) sent {
  return result.sent;
}
- (SyncMessageBuilder*) setSent:(SyncMessageSent*) value {
  result.hasSent = YES;
  result.sent = value;
  return self;
}
- (SyncMessageBuilder*) setSentBuilder:(SyncMessageSentBuilder*) builderForValue {
  return [self setSent:[builderForValue build]];
}
- (SyncMessageBuilder*) mergeSent:(SyncMessageSent*) value {
  if (result.hasSent &&
      result.sent != [SyncMessageSent defaultInstance]) {
    result.sent =
      [[[SyncMessageSent builderWithPrototype:result.sent] mergeFrom:value] buildPartial];
  } else {
    result.sent = value;
  }
  result.hasSent = YES;
  return self;
}
- (SyncMessageBuilder*) clearSent {
  result.hasSent = NO;
  result.sent = [SyncMessageSent defaultInstance];
  return self;
}
- (BOOL) hasContacts {
  return result.hasContacts;
}
- (SyncMessageContacts*) contacts {
  return result.contacts;
}
- (SyncMessageBuilder*) setContacts:(SyncMessageContacts*) value {
  result.hasContacts = YES;
  result.contacts = value;
  return self;
}
- (SyncMessageBuilder*) setContactsBuilder:(SyncMessageContactsBuilder*) builderForValue {
  return [self setContacts:[builderForValue build]];
}
- (SyncMessageBuilder*) mergeContacts:(SyncMessageContacts*) value {
  if (result.hasContacts &&
      result.contacts != [SyncMessageContacts defaultInstance]) {
    result.contacts =
      [[[SyncMessageContacts builderWithPrototype:result.contacts] mergeFrom:value] buildPartial];
  } else {
    result.contacts = value;
  }
  result.hasContacts = YES;
  return self;
}
- (SyncMessageBuilder*) clearContacts {
  result.hasContacts = NO;
  result.contacts = [SyncMessageContacts defaultInstance];
  return self;
}
- (BOOL) hasGroups {
  return result.hasGroups;
}
- (SyncMessageGroups*) groups {
  return result.groups;
}
- (SyncMessageBuilder*) setGroups:(SyncMessageGroups*) value {
  result.hasGroups = YES;
  result.groups = value;
  return self;
}
- (SyncMessageBuilder*) setGroupsBuilder:(SyncMessageGroupsBuilder*) builderForValue {
  return [self setGroups:[builderForValue build]];
}
- (SyncMessageBuilder*) mergeGroups:(SyncMessageGroups*) value {
  if (result.hasGroups &&
      result.groups != [SyncMessageGroups defaultInstance]) {
    result.groups =
      [[[SyncMessageGroups builderWithPrototype:result.groups] mergeFrom:value] buildPartial];
  } else {
    result.groups = value;
  }
  result.hasGroups = YES;
  return self;
}
- (SyncMessageBuilder*) clearGroups {
  result.hasGroups = NO;
  result.groups = [SyncMessageGroups defaultInstance];
  return self;
}
- (BOOL) hasRequest {
  return result.hasRequest;
}
- (SyncMessageRequest*) request {
  return result.request;
}
- (SyncMessageBuilder*) setRequest:(SyncMessageRequest*) value {
  result.hasRequest = YES;
  result.request = value;
  return self;
}
- (SyncMessageBuilder*) setRequestBuilder:(SyncMessageRequestBuilder*) builderForValue {
  return [self setRequest:[builderForValue build]];
}
- (SyncMessageBuilder*) mergeRequest:(SyncMessageRequest*) value {
  if (result.hasRequest &&
      result.request != [SyncMessageRequest defaultInstance]) {
    result.request =
      [[[SyncMessageRequest builderWithPrototype:result.request] mergeFrom:value] buildPartial];
  } else {
    result.request = value;
  }
  result.hasRequest = YES;
  return self;
}
- (SyncMessageBuilder*) clearRequest {
  result.hasRequest = NO;
  result.request = [SyncMessageRequest defaultInstance];
  return self;
}
@end

@interface AttachmentPointer ()
@property UInt64 id;
@property (strong) NSString* contentType;
@property (strong) NSData* key;
@property UInt32 size;
@property (strong) NSData* thumbnail;
@end

@implementation AttachmentPointer

- (BOOL) hasId {
  return !!hasId_;
}
- (void) setHasId:(BOOL) value_ {
  hasId_ = !!value_;
}
@synthesize id;
- (BOOL) hasContentType {
  return !!hasContentType_;
}
- (void) setHasContentType:(BOOL) value_ {
  hasContentType_ = !!value_;
}
@synthesize contentType;
- (BOOL) hasKey {
  return !!hasKey_;
}
- (void) setHasKey:(BOOL) value_ {
  hasKey_ = !!value_;
}
@synthesize key;
- (BOOL) hasSize {
  return !!hasSize_;
}
- (void) setHasSize:(BOOL) value_ {
  hasSize_ = !!value_;
}
@synthesize size;
- (BOOL) hasThumbnail {
  return !!hasThumbnail_;
}
- (void) setHasThumbnail:(BOOL) value_ {
  hasThumbnail_ = !!value_;
}
@synthesize thumbnail;
- (id) init {
  if ((self = [super init])) {
    self.id = 0L;
    self.contentType = @"";
    self.key = [NSData data];
    self.size = 0;
    self.thumbnail = [NSData data];
  }
  return self;
}
static AttachmentPointer* defaultAttachmentPointerInstance = nil;
+ (void) initialize {
  if (self == [AttachmentPointer class]) {
    defaultAttachmentPointerInstance = [[AttachmentPointer alloc] init];
  }
}
+ (AttachmentPointer*) defaultInstance {
  return defaultAttachmentPointerInstance;
}
- (AttachmentPointer*) defaultInstance {
  return defaultAttachmentPointerInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasId) {
    [output writeFixed64:1 value:self.id];
  }
  if (self.hasContentType) {
    [output writeString:2 value:self.contentType];
  }
  if (self.hasKey) {
    [output writeData:3 value:self.key];
  }
  if (self.hasSize) {
    [output writeUInt32:4 value:self.size];
  }
  if (self.hasThumbnail) {
    [output writeData:5 value:self.thumbnail];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasId) {
    size_ += computeFixed64Size(1, self.id);
  }
  if (self.hasContentType) {
    size_ += computeStringSize(2, self.contentType);
  }
  if (self.hasKey) {
    size_ += computeDataSize(3, self.key);
  }
  if (self.hasSize) {
    size_ += computeUInt32Size(4, self.size);
  }
  if (self.hasThumbnail) {
    size_ += computeDataSize(5, self.thumbnail);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (AttachmentPointer*) parseFromData:(NSData*) data {
  return (AttachmentPointer*)[[[AttachmentPointer builder] mergeFromData:data] build];
}
+ (AttachmentPointer*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (AttachmentPointer*)[[[AttachmentPointer builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (AttachmentPointer*) parseFromInputStream:(NSInputStream*) input {
  return (AttachmentPointer*)[[[AttachmentPointer builder] mergeFromInputStream:input] build];
}
+ (AttachmentPointer*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (AttachmentPointer*)[[[AttachmentPointer builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (AttachmentPointer*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (AttachmentPointer*)[[[AttachmentPointer builder] mergeFromCodedInputStream:input] build];
}
+ (AttachmentPointer*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (AttachmentPointer*)[[[AttachmentPointer builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (AttachmentPointerBuilder*) builder {
  return [[AttachmentPointerBuilder alloc] init];
}
+ (AttachmentPointerBuilder*) builderWithPrototype:(AttachmentPointer*) prototype {
  return [[AttachmentPointer builder] mergeFrom:prototype];
}
- (AttachmentPointerBuilder*) builder {
  return [AttachmentPointer builder];
}
- (AttachmentPointerBuilder*) toBuilder {
  return [AttachmentPointer builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"id", [NSNumber numberWithLongLong:self.id]];
  }
  if (self.hasContentType) {
    [output appendFormat:@"%@%@: %@\n", indent, @"contentType", self.contentType];
  }
  if (self.hasKey) {
    [output appendFormat:@"%@%@: %@\n", indent, @"key", self.key];
  }
  if (self.hasSize) {
    [output appendFormat:@"%@%@: %@\n", indent, @"size", [NSNumber numberWithInteger:self.size]];
  }
  if (self.hasThumbnail) {
    [output appendFormat:@"%@%@: %@\n", indent, @"thumbnail", self.thumbnail];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[AttachmentPointer class]]) {
    return NO;
  }
  AttachmentPointer *otherMessage = other;
  return
      self.hasId == otherMessage.hasId &&
      (!self.hasId || self.id == otherMessage.id) &&
      self.hasContentType == otherMessage.hasContentType &&
      (!self.hasContentType || [self.contentType isEqual:otherMessage.contentType]) &&
      self.hasKey == otherMessage.hasKey &&
      (!self.hasKey || [self.key isEqual:otherMessage.key]) &&
      self.hasSize == otherMessage.hasSize &&
      (!self.hasSize || self.size == otherMessage.size) &&
      self.hasThumbnail == otherMessage.hasThumbnail &&
      (!self.hasThumbnail || [self.thumbnail isEqual:otherMessage.thumbnail]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithLongLong:self.id] hash];
  }
  if (self.hasContentType) {
    hashCode = hashCode * 31 + [self.contentType hash];
  }
  if (self.hasKey) {
    hashCode = hashCode * 31 + [self.key hash];
  }
  if (self.hasSize) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.size] hash];
  }
  if (self.hasThumbnail) {
    hashCode = hashCode * 31 + [self.thumbnail hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface AttachmentPointerBuilder()
@property (strong) AttachmentPointer* result;
@end

@implementation AttachmentPointerBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[AttachmentPointer alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (AttachmentPointerBuilder*) clear {
  self.result = [[AttachmentPointer alloc] init];
  return self;
}
- (AttachmentPointerBuilder*) clone {
  return [AttachmentPointer builderWithPrototype:result];
}
- (AttachmentPointer*) defaultInstance {
  return [AttachmentPointer defaultInstance];
}
- (AttachmentPointer*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (AttachmentPointer*) buildPartial {
  AttachmentPointer* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (AttachmentPointerBuilder*) mergeFrom:(AttachmentPointer*) other {
  if (other == [AttachmentPointer defaultInstance]) {
    return self;
  }
  if (other.hasId) {
    [self setId:other.id];
  }
  if (other.hasContentType) {
    [self setContentType:other.contentType];
  }
  if (other.hasKey) {
    [self setKey:other.key];
  }
  if (other.hasSize) {
    [self setSize:other.size];
  }
  if (other.hasThumbnail) {
    [self setThumbnail:other.thumbnail];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (AttachmentPointerBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (AttachmentPointerBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 9: {
        [self setId:[input readFixed64]];
        break;
      }
      case 18: {
        [self setContentType:[input readString]];
        break;
      }
      case 26: {
        [self setKey:[input readData]];
        break;
      }
      case 32: {
        [self setSize:[input readUInt32]];
        break;
      }
      case 42: {
        [self setThumbnail:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasId {
  return result.hasId;
}
- (UInt64) id {
  return result.id;
}
- (AttachmentPointerBuilder*) setId:(UInt64) value {
  result.hasId = YES;
  result.id = value;
  return self;
}
- (AttachmentPointerBuilder*) clearId {
  result.hasId = NO;
  result.id = 0L;
  return self;
}
- (BOOL) hasContentType {
  return result.hasContentType;
}
- (NSString*) contentType {
  return result.contentType;
}
- (AttachmentPointerBuilder*) setContentType:(NSString*) value {
  result.hasContentType = YES;
  result.contentType = value;
  return self;
}
- (AttachmentPointerBuilder*) clearContentType {
  result.hasContentType = NO;
  result.contentType = @"";
  return self;
}
- (BOOL) hasKey {
  return result.hasKey;
}
- (NSData*) key {
  return result.key;
}
- (AttachmentPointerBuilder*) setKey:(NSData*) value {
  result.hasKey = YES;
  result.key = value;
  return self;
}
- (AttachmentPointerBuilder*) clearKey {
  result.hasKey = NO;
  result.key = [NSData data];
  return self;
}
- (BOOL) hasSize {
  return result.hasSize;
}
- (UInt32) size {
  return result.size;
}
- (AttachmentPointerBuilder*) setSize:(UInt32) value {
  result.hasSize = YES;
  result.size = value;
  return self;
}
- (AttachmentPointerBuilder*) clearSize {
  result.hasSize = NO;
  result.size = 0;
  return self;
}
- (BOOL) hasThumbnail {
  return result.hasThumbnail;
}
- (NSData*) thumbnail {
  return result.thumbnail;
}
- (AttachmentPointerBuilder*) setThumbnail:(NSData*) value {
  result.hasThumbnail = YES;
  result.thumbnail = value;
  return self;
}
- (AttachmentPointerBuilder*) clearThumbnail {
  result.hasThumbnail = NO;
  result.thumbnail = [NSData data];
  return self;
}
@end

@interface GroupContext ()
@property (strong) NSData* id;
@property GroupContextType type;
@property (strong) NSString* name;
@property (strong) NSMutableArray * membersArray;
@property (strong) AttachmentPointer* avatar;
@end

@implementation GroupContext

- (BOOL) hasId {
  return !!hasId_;
}
- (void) setHasId:(BOOL) value_ {
  hasId_ = !!value_;
}
@synthesize id;
- (BOOL) hasType {
  return !!hasType_;
}
- (void) setHasType:(BOOL) value_ {
  hasType_ = !!value_;
}
@synthesize type;
- (BOOL) hasName {
  return !!hasName_;
}
- (void) setHasName:(BOOL) value_ {
  hasName_ = !!value_;
}
@synthesize name;
@synthesize membersArray;
@dynamic members;
- (BOOL) hasAvatar {
  return !!hasAvatar_;
}
- (void) setHasAvatar:(BOOL) value_ {
  hasAvatar_ = !!value_;
}
@synthesize avatar;
- (id) init {
  if ((self = [super init])) {
    self.id = [NSData data];
    self.type = GroupContextTypeUnknown;
    self.name = @"";
    self.avatar = [AttachmentPointer defaultInstance];
  }
  return self;
}
static GroupContext* defaultGroupContextInstance = nil;
+ (void) initialize {
  if (self == [GroupContext class]) {
    defaultGroupContextInstance = [[GroupContext alloc] init];
  }
}
+ (GroupContext*) defaultInstance {
  return defaultGroupContextInstance;
}
- (GroupContext*) defaultInstance {
  return defaultGroupContextInstance;
}
- (NSArray *)members {
  return membersArray;
}
- (NSString*)membersAtIndex:(NSUInteger)index {
  return [membersArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasId) {
    [output writeData:1 value:self.id];
  }
  if (self.hasType) {
    [output writeEnum:2 value:self.type];
  }
  if (self.hasName) {
    [output writeString:3 value:self.name];
  }
  [self.membersArray enumerateObjectsUsingBlock:^(NSString *element, NSUInteger idx, BOOL *stop) {
    [output writeString:4 value:element];
  }];
  if (self.hasAvatar) {
    [output writeMessage:5 value:self.avatar];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasId) {
    size_ += computeDataSize(1, self.id);
  }
  if (self.hasType) {
    size_ += computeEnumSize(2, self.type);
  }
  if (self.hasName) {
    size_ += computeStringSize(3, self.name);
  }
  {
    __block SInt32 dataSize = 0;
    const NSUInteger count = self.membersArray.count;
    [self.membersArray enumerateObjectsUsingBlock:^(NSString *element, NSUInteger idx, BOOL *stop) {
      dataSize += computeStringSizeNoTag(element);
    }];
    size_ += dataSize;
    size_ += (SInt32)(1 * count);
  }
  if (self.hasAvatar) {
    size_ += computeMessageSize(5, self.avatar);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (GroupContext*) parseFromData:(NSData*) data {
  return (GroupContext*)[[[GroupContext builder] mergeFromData:data] build];
}
+ (GroupContext*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupContext*)[[[GroupContext builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (GroupContext*) parseFromInputStream:(NSInputStream*) input {
  return (GroupContext*)[[[GroupContext builder] mergeFromInputStream:input] build];
}
+ (GroupContext*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupContext*)[[[GroupContext builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (GroupContext*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (GroupContext*)[[[GroupContext builder] mergeFromCodedInputStream:input] build];
}
+ (GroupContext*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupContext*)[[[GroupContext builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (GroupContextBuilder*) builder {
  return [[GroupContextBuilder alloc] init];
}
+ (GroupContextBuilder*) builderWithPrototype:(GroupContext*) prototype {
  return [[GroupContext builder] mergeFrom:prototype];
}
- (GroupContextBuilder*) builder {
  return [GroupContext builder];
}
- (GroupContextBuilder*) toBuilder {
  return [GroupContext builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"id", self.id];
  }
  if (self.hasType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"type", self.type];
  }
  if (self.hasName) {
    [output appendFormat:@"%@%@: %@\n", indent, @"name", self.name];
  }
  [self.membersArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@: %@\n", indent, @"members", obj];
  }];
  if (self.hasAvatar) {
    [output appendFormat:@"%@%@ {\n", indent, @"avatar"];
    [self.avatar writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[GroupContext class]]) {
    return NO;
  }
  GroupContext *otherMessage = other;
  return
      self.hasId == otherMessage.hasId &&
      (!self.hasId || [self.id isEqual:otherMessage.id]) &&
      self.hasType == otherMessage.hasType &&
      (!self.hasType || self.type == otherMessage.type) &&
      self.hasName == otherMessage.hasName &&
      (!self.hasName || [self.name isEqual:otherMessage.name]) &&
      [self.membersArray isEqualToArray:otherMessage.membersArray] &&
      self.hasAvatar == otherMessage.hasAvatar &&
      (!self.hasAvatar || [self.avatar isEqual:otherMessage.avatar]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasId) {
    hashCode = hashCode * 31 + [self.id hash];
  }
  if (self.hasType) {
    hashCode = hashCode * 31 + self.type;
  }
  if (self.hasName) {
    hashCode = hashCode * 31 + [self.name hash];
  }
  [self.membersArray enumerateObjectsUsingBlock:^(id element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasAvatar) {
    hashCode = hashCode * 31 + [self.avatar hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

BOOL GroupContextTypeIsValidValue(GroupContextType value) {
  switch (value) {
    case GroupContextTypeUnknown:
    case GroupContextTypeUpdate:
    case GroupContextTypeDeliver:
    case GroupContextTypeQuit:
      return YES;
    default:
      return NO;
  }
}
@interface GroupContextBuilder()
@property (strong) GroupContext* result;
@end

@implementation GroupContextBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[GroupContext alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (GroupContextBuilder*) clear {
  self.result = [[GroupContext alloc] init];
  return self;
}
- (GroupContextBuilder*) clone {
  return [GroupContext builderWithPrototype:result];
}
- (GroupContext*) defaultInstance {
  return [GroupContext defaultInstance];
}
- (GroupContext*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (GroupContext*) buildPartial {
  GroupContext* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (GroupContextBuilder*) mergeFrom:(GroupContext*) other {
  if (other == [GroupContext defaultInstance]) {
    return self;
  }
  if (other.hasId) {
    [self setId:other.id];
  }
  if (other.hasType) {
    [self setType:other.type];
  }
  if (other.hasName) {
    [self setName:other.name];
  }
  if (other.membersArray.count > 0) {
    if (result.membersArray == nil) {
      result.membersArray = [[NSMutableArray alloc] initWithArray:other.membersArray];
    } else {
      [result.membersArray addObjectsFromArray:other.membersArray];
    }
  }
  if (other.hasAvatar) {
    [self mergeAvatar:other.avatar];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (GroupContextBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (GroupContextBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self setId:[input readData]];
        break;
      }
      case 16: {
        GroupContextType value = (GroupContextType)[input readEnum];
        if (GroupContextTypeIsValidValue(value)) {
          [self setType:value];
        } else {
          [unknownFields mergeVarintField:2 value:value];
        }
        break;
      }
      case 26: {
        [self setName:[input readString]];
        break;
      }
      case 34: {
        [self addMembers:[input readString]];
        break;
      }
      case 42: {
        AttachmentPointerBuilder* subBuilder = [AttachmentPointer builder];
        if (self.hasAvatar) {
          [subBuilder mergeFrom:self.avatar];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setAvatar:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasId {
  return result.hasId;
}
- (NSData*) id {
  return result.id;
}
- (GroupContextBuilder*) setId:(NSData*) value {
  result.hasId = YES;
  result.id = value;
  return self;
}
- (GroupContextBuilder*) clearId {
  result.hasId = NO;
  result.id = [NSData data];
  return self;
}
- (BOOL) hasType {
  return result.hasType;
}
- (GroupContextType) type {
  return result.type;
}
- (GroupContextBuilder*) setType:(GroupContextType) value {
  result.hasType = YES;
  result.type = value;
  return self;
}
- (GroupContextBuilder*) clearType {
  result.hasType = NO;
  result.type = GroupContextTypeUnknown;
  return self;
}
- (BOOL) hasName {
  return result.hasName;
}
- (NSString*) name {
  return result.name;
}
- (GroupContextBuilder*) setName:(NSString*) value {
  result.hasName = YES;
  result.name = value;
  return self;
}
- (GroupContextBuilder*) clearName {
  result.hasName = NO;
  result.name = @"";
  return self;
}
- (NSMutableArray *)members {
  return result.membersArray;
}
- (NSString*)membersAtIndex:(NSUInteger)index {
  return [result membersAtIndex:index];
}
- (GroupContextBuilder *)addMembers:(NSString*)value {
  if (result.membersArray == nil) {
    result.membersArray = [[NSMutableArray alloc]init];
  }
  [result.membersArray addObject:value];
  return self;
}
- (GroupContextBuilder *)setMembersArray:(NSArray *)array {
  result.membersArray = [[NSMutableArray alloc] initWithArray:array];
  return self;
}
- (GroupContextBuilder *)clearMembers {
  result.membersArray = nil;
  return self;
}
- (BOOL) hasAvatar {
  return result.hasAvatar;
}
- (AttachmentPointer*) avatar {
  return result.avatar;
}
- (GroupContextBuilder*) setAvatar:(AttachmentPointer*) value {
  result.hasAvatar = YES;
  result.avatar = value;
  return self;
}
- (GroupContextBuilder*) setAvatarBuilder:(AttachmentPointerBuilder*) builderForValue {
  return [self setAvatar:[builderForValue build]];
}
- (GroupContextBuilder*) mergeAvatar:(AttachmentPointer*) value {
  if (result.hasAvatar &&
      result.avatar != [AttachmentPointer defaultInstance]) {
    result.avatar =
      [[[AttachmentPointer builderWithPrototype:result.avatar] mergeFrom:value] buildPartial];
  } else {
    result.avatar = value;
  }
  result.hasAvatar = YES;
  return self;
}
- (GroupContextBuilder*) clearAvatar {
  result.hasAvatar = NO;
  result.avatar = [AttachmentPointer defaultInstance];
  return self;
}
@end

@interface ContactDetails ()
@property (strong) NSString* number;
@property (strong) NSString* name;
@property (strong) ContactDetailsAvatar* avatar;
@end

@implementation ContactDetails

- (BOOL) hasNumber {
  return !!hasNumber_;
}
- (void) setHasNumber:(BOOL) value_ {
  hasNumber_ = !!value_;
}
@synthesize number;
- (BOOL) hasName {
  return !!hasName_;
}
- (void) setHasName:(BOOL) value_ {
  hasName_ = !!value_;
}
@synthesize name;
- (BOOL) hasAvatar {
  return !!hasAvatar_;
}
- (void) setHasAvatar:(BOOL) value_ {
  hasAvatar_ = !!value_;
}
@synthesize avatar;
- (id) init {
  if ((self = [super init])) {
    self.number = @"";
    self.name = @"";
    self.avatar = [ContactDetailsAvatar defaultInstance];
  }
  return self;
}
static ContactDetails* defaultContactDetailsInstance = nil;
+ (void) initialize {
  if (self == [ContactDetails class]) {
    defaultContactDetailsInstance = [[ContactDetails alloc] init];
  }
}
+ (ContactDetails*) defaultInstance {
  return defaultContactDetailsInstance;
}
- (ContactDetails*) defaultInstance {
  return defaultContactDetailsInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasNumber) {
    [output writeString:1 value:self.number];
  }
  if (self.hasName) {
    [output writeString:2 value:self.name];
  }
  if (self.hasAvatar) {
    [output writeMessage:3 value:self.avatar];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasNumber) {
    size_ += computeStringSize(1, self.number);
  }
  if (self.hasName) {
    size_ += computeStringSize(2, self.name);
  }
  if (self.hasAvatar) {
    size_ += computeMessageSize(3, self.avatar);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (ContactDetails*) parseFromData:(NSData*) data {
  return (ContactDetails*)[[[ContactDetails builder] mergeFromData:data] build];
}
+ (ContactDetails*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ContactDetails*)[[[ContactDetails builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (ContactDetails*) parseFromInputStream:(NSInputStream*) input {
  return (ContactDetails*)[[[ContactDetails builder] mergeFromInputStream:input] build];
}
+ (ContactDetails*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ContactDetails*)[[[ContactDetails builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ContactDetails*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (ContactDetails*)[[[ContactDetails builder] mergeFromCodedInputStream:input] build];
}
+ (ContactDetails*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ContactDetails*)[[[ContactDetails builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ContactDetailsBuilder*) builder {
  return [[ContactDetailsBuilder alloc] init];
}
+ (ContactDetailsBuilder*) builderWithPrototype:(ContactDetails*) prototype {
  return [[ContactDetails builder] mergeFrom:prototype];
}
- (ContactDetailsBuilder*) builder {
  return [ContactDetails builder];
}
- (ContactDetailsBuilder*) toBuilder {
  return [ContactDetails builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasNumber) {
    [output appendFormat:@"%@%@: %@\n", indent, @"number", self.number];
  }
  if (self.hasName) {
    [output appendFormat:@"%@%@: %@\n", indent, @"name", self.name];
  }
  if (self.hasAvatar) {
    [output appendFormat:@"%@%@ {\n", indent, @"avatar"];
    [self.avatar writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[ContactDetails class]]) {
    return NO;
  }
  ContactDetails *otherMessage = other;
  return
      self.hasNumber == otherMessage.hasNumber &&
      (!self.hasNumber || [self.number isEqual:otherMessage.number]) &&
      self.hasName == otherMessage.hasName &&
      (!self.hasName || [self.name isEqual:otherMessage.name]) &&
      self.hasAvatar == otherMessage.hasAvatar &&
      (!self.hasAvatar || [self.avatar isEqual:otherMessage.avatar]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasNumber) {
    hashCode = hashCode * 31 + [self.number hash];
  }
  if (self.hasName) {
    hashCode = hashCode * 31 + [self.name hash];
  }
  if (self.hasAvatar) {
    hashCode = hashCode * 31 + [self.avatar hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface ContactDetailsAvatar ()
@property (strong) NSString* contentType;
@property UInt32 length;
@end

@implementation ContactDetailsAvatar

- (BOOL) hasContentType {
  return !!hasContentType_;
}
- (void) setHasContentType:(BOOL) value_ {
  hasContentType_ = !!value_;
}
@synthesize contentType;
- (BOOL) hasLength {
  return !!hasLength_;
}
- (void) setHasLength:(BOOL) value_ {
  hasLength_ = !!value_;
}
@synthesize length;
- (id) init {
  if ((self = [super init])) {
    self.contentType = @"";
    self.length = 0;
  }
  return self;
}
static ContactDetailsAvatar* defaultContactDetailsAvatarInstance = nil;
+ (void) initialize {
  if (self == [ContactDetailsAvatar class]) {
    defaultContactDetailsAvatarInstance = [[ContactDetailsAvatar alloc] init];
  }
}
+ (ContactDetailsAvatar*) defaultInstance {
  return defaultContactDetailsAvatarInstance;
}
- (ContactDetailsAvatar*) defaultInstance {
  return defaultContactDetailsAvatarInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasContentType) {
    [output writeString:1 value:self.contentType];
  }
  if (self.hasLength) {
    [output writeUInt32:2 value:self.length];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasContentType) {
    size_ += computeStringSize(1, self.contentType);
  }
  if (self.hasLength) {
    size_ += computeUInt32Size(2, self.length);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (ContactDetailsAvatar*) parseFromData:(NSData*) data {
  return (ContactDetailsAvatar*)[[[ContactDetailsAvatar builder] mergeFromData:data] build];
}
+ (ContactDetailsAvatar*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ContactDetailsAvatar*)[[[ContactDetailsAvatar builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (ContactDetailsAvatar*) parseFromInputStream:(NSInputStream*) input {
  return (ContactDetailsAvatar*)[[[ContactDetailsAvatar builder] mergeFromInputStream:input] build];
}
+ (ContactDetailsAvatar*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ContactDetailsAvatar*)[[[ContactDetailsAvatar builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ContactDetailsAvatar*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (ContactDetailsAvatar*)[[[ContactDetailsAvatar builder] mergeFromCodedInputStream:input] build];
}
+ (ContactDetailsAvatar*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ContactDetailsAvatar*)[[[ContactDetailsAvatar builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ContactDetailsAvatarBuilder*) builder {
  return [[ContactDetailsAvatarBuilder alloc] init];
}
+ (ContactDetailsAvatarBuilder*) builderWithPrototype:(ContactDetailsAvatar*) prototype {
  return [[ContactDetailsAvatar builder] mergeFrom:prototype];
}
- (ContactDetailsAvatarBuilder*) builder {
  return [ContactDetailsAvatar builder];
}
- (ContactDetailsAvatarBuilder*) toBuilder {
  return [ContactDetailsAvatar builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasContentType) {
    [output appendFormat:@"%@%@: %@\n", indent, @"contentType", self.contentType];
  }
  if (self.hasLength) {
    [output appendFormat:@"%@%@: %@\n", indent, @"length", [NSNumber numberWithInteger:self.length]];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[ContactDetailsAvatar class]]) {
    return NO;
  }
  ContactDetailsAvatar *otherMessage = other;
  return
      self.hasContentType == otherMessage.hasContentType &&
      (!self.hasContentType || [self.contentType isEqual:otherMessage.contentType]) &&
      self.hasLength == otherMessage.hasLength &&
      (!self.hasLength || self.length == otherMessage.length) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasContentType) {
    hashCode = hashCode * 31 + [self.contentType hash];
  }
  if (self.hasLength) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.length] hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface ContactDetailsAvatarBuilder()
@property (strong) ContactDetailsAvatar* result;
@end

@implementation ContactDetailsAvatarBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ContactDetailsAvatar alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ContactDetailsAvatarBuilder*) clear {
  self.result = [[ContactDetailsAvatar alloc] init];
  return self;
}
- (ContactDetailsAvatarBuilder*) clone {
  return [ContactDetailsAvatar builderWithPrototype:result];
}
- (ContactDetailsAvatar*) defaultInstance {
  return [ContactDetailsAvatar defaultInstance];
}
- (ContactDetailsAvatar*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ContactDetailsAvatar*) buildPartial {
  ContactDetailsAvatar* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ContactDetailsAvatarBuilder*) mergeFrom:(ContactDetailsAvatar*) other {
  if (other == [ContactDetailsAvatar defaultInstance]) {
    return self;
  }
  if (other.hasContentType) {
    [self setContentType:other.contentType];
  }
  if (other.hasLength) {
    [self setLength:other.length];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ContactDetailsAvatarBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ContactDetailsAvatarBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self setContentType:[input readString]];
        break;
      }
      case 16: {
        [self setLength:[input readUInt32]];
        break;
      }
    }
  }
}
- (BOOL) hasContentType {
  return result.hasContentType;
}
- (NSString*) contentType {
  return result.contentType;
}
- (ContactDetailsAvatarBuilder*) setContentType:(NSString*) value {
  result.hasContentType = YES;
  result.contentType = value;
  return self;
}
- (ContactDetailsAvatarBuilder*) clearContentType {
  result.hasContentType = NO;
  result.contentType = @"";
  return self;
}
- (BOOL) hasLength {
  return result.hasLength;
}
- (UInt32) length {
  return result.length;
}
- (ContactDetailsAvatarBuilder*) setLength:(UInt32) value {
  result.hasLength = YES;
  result.length = value;
  return self;
}
- (ContactDetailsAvatarBuilder*) clearLength {
  result.hasLength = NO;
  result.length = 0;
  return self;
}
@end

@interface ContactDetailsBuilder()
@property (strong) ContactDetails* result;
@end

@implementation ContactDetailsBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ContactDetails alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ContactDetailsBuilder*) clear {
  self.result = [[ContactDetails alloc] init];
  return self;
}
- (ContactDetailsBuilder*) clone {
  return [ContactDetails builderWithPrototype:result];
}
- (ContactDetails*) defaultInstance {
  return [ContactDetails defaultInstance];
}
- (ContactDetails*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ContactDetails*) buildPartial {
  ContactDetails* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ContactDetailsBuilder*) mergeFrom:(ContactDetails*) other {
  if (other == [ContactDetails defaultInstance]) {
    return self;
  }
  if (other.hasNumber) {
    [self setNumber:other.number];
  }
  if (other.hasName) {
    [self setName:other.name];
  }
  if (other.hasAvatar) {
    [self mergeAvatar:other.avatar];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ContactDetailsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ContactDetailsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self setNumber:[input readString]];
        break;
      }
      case 18: {
        [self setName:[input readString]];
        break;
      }
      case 26: {
        ContactDetailsAvatarBuilder* subBuilder = [ContactDetailsAvatar builder];
        if (self.hasAvatar) {
          [subBuilder mergeFrom:self.avatar];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setAvatar:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasNumber {
  return result.hasNumber;
}
- (NSString*) number {
  return result.number;
}
- (ContactDetailsBuilder*) setNumber:(NSString*) value {
  result.hasNumber = YES;
  result.number = value;
  return self;
}
- (ContactDetailsBuilder*) clearNumber {
  result.hasNumber = NO;
  result.number = @"";
  return self;
}
- (BOOL) hasName {
  return result.hasName;
}
- (NSString*) name {
  return result.name;
}
- (ContactDetailsBuilder*) setName:(NSString*) value {
  result.hasName = YES;
  result.name = value;
  return self;
}
- (ContactDetailsBuilder*) clearName {
  result.hasName = NO;
  result.name = @"";
  return self;
}
- (BOOL) hasAvatar {
  return result.hasAvatar;
}
- (ContactDetailsAvatar*) avatar {
  return result.avatar;
}
- (ContactDetailsBuilder*) setAvatar:(ContactDetailsAvatar*) value {
  result.hasAvatar = YES;
  result.avatar = value;
  return self;
}
- (ContactDetailsBuilder*) setAvatarBuilder:(ContactDetailsAvatarBuilder*) builderForValue {
  return [self setAvatar:[builderForValue build]];
}
- (ContactDetailsBuilder*) mergeAvatar:(ContactDetailsAvatar*) value {
  if (result.hasAvatar &&
      result.avatar != [ContactDetailsAvatar defaultInstance]) {
    result.avatar =
      [[[ContactDetailsAvatar builderWithPrototype:result.avatar] mergeFrom:value] buildPartial];
  } else {
    result.avatar = value;
  }
  result.hasAvatar = YES;
  return self;
}
- (ContactDetailsBuilder*) clearAvatar {
  result.hasAvatar = NO;
  result.avatar = [ContactDetailsAvatar defaultInstance];
  return self;
}
@end

@interface GroupDetails ()
@property (strong) NSData* id;
@property (strong) NSString* name;
@property (strong) NSMutableArray * membersArray;
@property (strong) GroupDetailsAvatar* avatar;
@end

@implementation GroupDetails

- (BOOL) hasId {
  return !!hasId_;
}
- (void) setHasId:(BOOL) value_ {
  hasId_ = !!value_;
}
@synthesize id;
- (BOOL) hasName {
  return !!hasName_;
}
- (void) setHasName:(BOOL) value_ {
  hasName_ = !!value_;
}
@synthesize name;
@synthesize membersArray;
@dynamic members;
- (BOOL) hasAvatar {
  return !!hasAvatar_;
}
- (void) setHasAvatar:(BOOL) value_ {
  hasAvatar_ = !!value_;
}
@synthesize avatar;
- (id) init {
  if ((self = [super init])) {
    self.id = [NSData data];
    self.name = @"";
    self.avatar = [GroupDetailsAvatar defaultInstance];
  }
  return self;
}
static GroupDetails* defaultGroupDetailsInstance = nil;
+ (void) initialize {
  if (self == [GroupDetails class]) {
    defaultGroupDetailsInstance = [[GroupDetails alloc] init];
  }
}
+ (GroupDetails*) defaultInstance {
  return defaultGroupDetailsInstance;
}
- (GroupDetails*) defaultInstance {
  return defaultGroupDetailsInstance;
}
- (NSArray *)members {
  return membersArray;
}
- (NSString*)membersAtIndex:(NSUInteger)index {
  return [membersArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasId) {
    [output writeData:1 value:self.id];
  }
  if (self.hasName) {
    [output writeString:2 value:self.name];
  }
  [self.membersArray enumerateObjectsUsingBlock:^(NSString *element, NSUInteger idx, BOOL *stop) {
    [output writeString:3 value:element];
  }];
  if (self.hasAvatar) {
    [output writeMessage:4 value:self.avatar];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasId) {
    size_ += computeDataSize(1, self.id);
  }
  if (self.hasName) {
    size_ += computeStringSize(2, self.name);
  }
  {
    __block SInt32 dataSize = 0;
    const NSUInteger count = self.membersArray.count;
    [self.membersArray enumerateObjectsUsingBlock:^(NSString *element, NSUInteger idx, BOOL *stop) {
      dataSize += computeStringSizeNoTag(element);
    }];
    size_ += dataSize;
    size_ += (SInt32)(1 * count);
  }
  if (self.hasAvatar) {
    size_ += computeMessageSize(4, self.avatar);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (GroupDetails*) parseFromData:(NSData*) data {
  return (GroupDetails*)[[[GroupDetails builder] mergeFromData:data] build];
}
+ (GroupDetails*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupDetails*)[[[GroupDetails builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (GroupDetails*) parseFromInputStream:(NSInputStream*) input {
  return (GroupDetails*)[[[GroupDetails builder] mergeFromInputStream:input] build];
}
+ (GroupDetails*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupDetails*)[[[GroupDetails builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (GroupDetails*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (GroupDetails*)[[[GroupDetails builder] mergeFromCodedInputStream:input] build];
}
+ (GroupDetails*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupDetails*)[[[GroupDetails builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (GroupDetailsBuilder*) builder {
  return [[GroupDetailsBuilder alloc] init];
}
+ (GroupDetailsBuilder*) builderWithPrototype:(GroupDetails*) prototype {
  return [[GroupDetails builder] mergeFrom:prototype];
}
- (GroupDetailsBuilder*) builder {
  return [GroupDetails builder];
}
- (GroupDetailsBuilder*) toBuilder {
  return [GroupDetails builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"id", self.id];
  }
  if (self.hasName) {
    [output appendFormat:@"%@%@: %@\n", indent, @"name", self.name];
  }
  [self.membersArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@: %@\n", indent, @"members", obj];
  }];
  if (self.hasAvatar) {
    [output appendFormat:@"%@%@ {\n", indent, @"avatar"];
    [self.avatar writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[GroupDetails class]]) {
    return NO;
  }
  GroupDetails *otherMessage = other;
  return
      self.hasId == otherMessage.hasId &&
      (!self.hasId || [self.id isEqual:otherMessage.id]) &&
      self.hasName == otherMessage.hasName &&
      (!self.hasName || [self.name isEqual:otherMessage.name]) &&
      [self.membersArray isEqualToArray:otherMessage.membersArray] &&
      self.hasAvatar == otherMessage.hasAvatar &&
      (!self.hasAvatar || [self.avatar isEqual:otherMessage.avatar]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasId) {
    hashCode = hashCode * 31 + [self.id hash];
  }
  if (self.hasName) {
    hashCode = hashCode * 31 + [self.name hash];
  }
  [self.membersArray enumerateObjectsUsingBlock:^(id element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasAvatar) {
    hashCode = hashCode * 31 + [self.avatar hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface GroupDetailsAvatar ()
@property (strong) NSString* contentType;
@property UInt32 length;
@end

@implementation GroupDetailsAvatar

- (BOOL) hasContentType {
  return !!hasContentType_;
}
- (void) setHasContentType:(BOOL) value_ {
  hasContentType_ = !!value_;
}
@synthesize contentType;
- (BOOL) hasLength {
  return !!hasLength_;
}
- (void) setHasLength:(BOOL) value_ {
  hasLength_ = !!value_;
}
@synthesize length;
- (id) init {
  if ((self = [super init])) {
    self.contentType = @"";
    self.length = 0;
  }
  return self;
}
static GroupDetailsAvatar* defaultGroupDetailsAvatarInstance = nil;
+ (void) initialize {
  if (self == [GroupDetailsAvatar class]) {
    defaultGroupDetailsAvatarInstance = [[GroupDetailsAvatar alloc] init];
  }
}
+ (GroupDetailsAvatar*) defaultInstance {
  return defaultGroupDetailsAvatarInstance;
}
- (GroupDetailsAvatar*) defaultInstance {
  return defaultGroupDetailsAvatarInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasContentType) {
    [output writeString:1 value:self.contentType];
  }
  if (self.hasLength) {
    [output writeUInt32:2 value:self.length];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasContentType) {
    size_ += computeStringSize(1, self.contentType);
  }
  if (self.hasLength) {
    size_ += computeUInt32Size(2, self.length);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (GroupDetailsAvatar*) parseFromData:(NSData*) data {
  return (GroupDetailsAvatar*)[[[GroupDetailsAvatar builder] mergeFromData:data] build];
}
+ (GroupDetailsAvatar*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupDetailsAvatar*)[[[GroupDetailsAvatar builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (GroupDetailsAvatar*) parseFromInputStream:(NSInputStream*) input {
  return (GroupDetailsAvatar*)[[[GroupDetailsAvatar builder] mergeFromInputStream:input] build];
}
+ (GroupDetailsAvatar*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupDetailsAvatar*)[[[GroupDetailsAvatar builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (GroupDetailsAvatar*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (GroupDetailsAvatar*)[[[GroupDetailsAvatar builder] mergeFromCodedInputStream:input] build];
}
+ (GroupDetailsAvatar*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (GroupDetailsAvatar*)[[[GroupDetailsAvatar builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (GroupDetailsAvatarBuilder*) builder {
  return [[GroupDetailsAvatarBuilder alloc] init];
}
+ (GroupDetailsAvatarBuilder*) builderWithPrototype:(GroupDetailsAvatar*) prototype {
  return [[GroupDetailsAvatar builder] mergeFrom:prototype];
}
- (GroupDetailsAvatarBuilder*) builder {
  return [GroupDetailsAvatar builder];
}
- (GroupDetailsAvatarBuilder*) toBuilder {
  return [GroupDetailsAvatar builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasContentType) {
    [output appendFormat:@"%@%@: %@\n", indent, @"contentType", self.contentType];
  }
  if (self.hasLength) {
    [output appendFormat:@"%@%@: %@\n", indent, @"length", [NSNumber numberWithInteger:self.length]];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[GroupDetailsAvatar class]]) {
    return NO;
  }
  GroupDetailsAvatar *otherMessage = other;
  return
      self.hasContentType == otherMessage.hasContentType &&
      (!self.hasContentType || [self.contentType isEqual:otherMessage.contentType]) &&
      self.hasLength == otherMessage.hasLength &&
      (!self.hasLength || self.length == otherMessage.length) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasContentType) {
    hashCode = hashCode * 31 + [self.contentType hash];
  }
  if (self.hasLength) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.length] hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface GroupDetailsAvatarBuilder()
@property (strong) GroupDetailsAvatar* result;
@end

@implementation GroupDetailsAvatarBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[GroupDetailsAvatar alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (GroupDetailsAvatarBuilder*) clear {
  self.result = [[GroupDetailsAvatar alloc] init];
  return self;
}
- (GroupDetailsAvatarBuilder*) clone {
  return [GroupDetailsAvatar builderWithPrototype:result];
}
- (GroupDetailsAvatar*) defaultInstance {
  return [GroupDetailsAvatar defaultInstance];
}
- (GroupDetailsAvatar*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (GroupDetailsAvatar*) buildPartial {
  GroupDetailsAvatar* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (GroupDetailsAvatarBuilder*) mergeFrom:(GroupDetailsAvatar*) other {
  if (other == [GroupDetailsAvatar defaultInstance]) {
    return self;
  }
  if (other.hasContentType) {
    [self setContentType:other.contentType];
  }
  if (other.hasLength) {
    [self setLength:other.length];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (GroupDetailsAvatarBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (GroupDetailsAvatarBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self setContentType:[input readString]];
        break;
      }
      case 16: {
        [self setLength:[input readUInt32]];
        break;
      }
    }
  }
}
- (BOOL) hasContentType {
  return result.hasContentType;
}
- (NSString*) contentType {
  return result.contentType;
}
- (GroupDetailsAvatarBuilder*) setContentType:(NSString*) value {
  result.hasContentType = YES;
  result.contentType = value;
  return self;
}
- (GroupDetailsAvatarBuilder*) clearContentType {
  result.hasContentType = NO;
  result.contentType = @"";
  return self;
}
- (BOOL) hasLength {
  return result.hasLength;
}
- (UInt32) length {
  return result.length;
}
- (GroupDetailsAvatarBuilder*) setLength:(UInt32) value {
  result.hasLength = YES;
  result.length = value;
  return self;
}
- (GroupDetailsAvatarBuilder*) clearLength {
  result.hasLength = NO;
  result.length = 0;
  return self;
}
@end

@interface GroupDetailsBuilder()
@property (strong) GroupDetails* result;
@end

@implementation GroupDetailsBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[GroupDetails alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (GroupDetailsBuilder*) clear {
  self.result = [[GroupDetails alloc] init];
  return self;
}
- (GroupDetailsBuilder*) clone {
  return [GroupDetails builderWithPrototype:result];
}
- (GroupDetails*) defaultInstance {
  return [GroupDetails defaultInstance];
}
- (GroupDetails*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (GroupDetails*) buildPartial {
  GroupDetails* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (GroupDetailsBuilder*) mergeFrom:(GroupDetails*) other {
  if (other == [GroupDetails defaultInstance]) {
    return self;
  }
  if (other.hasId) {
    [self setId:other.id];
  }
  if (other.hasName) {
    [self setName:other.name];
  }
  if (other.membersArray.count > 0) {
    if (result.membersArray == nil) {
      result.membersArray = [[NSMutableArray alloc] initWithArray:other.membersArray];
    } else {
      [result.membersArray addObjectsFromArray:other.membersArray];
    }
  }
  if (other.hasAvatar) {
    [self mergeAvatar:other.avatar];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (GroupDetailsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (GroupDetailsBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self setId:[input readData]];
        break;
      }
      case 18: {
        [self setName:[input readString]];
        break;
      }
      case 26: {
        [self addMembers:[input readString]];
        break;
      }
      case 34: {
        GroupDetailsAvatarBuilder* subBuilder = [GroupDetailsAvatar builder];
        if (self.hasAvatar) {
          [subBuilder mergeFrom:self.avatar];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setAvatar:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasId {
  return result.hasId;
}
- (NSData*) id {
  return result.id;
}
- (GroupDetailsBuilder*) setId:(NSData*) value {
  result.hasId = YES;
  result.id = value;
  return self;
}
- (GroupDetailsBuilder*) clearId {
  result.hasId = NO;
  result.id = [NSData data];
  return self;
}
- (BOOL) hasName {
  return result.hasName;
}
- (NSString*) name {
  return result.name;
}
- (GroupDetailsBuilder*) setName:(NSString*) value {
  result.hasName = YES;
  result.name = value;
  return self;
}
- (GroupDetailsBuilder*) clearName {
  result.hasName = NO;
  result.name = @"";
  return self;
}
- (NSMutableArray *)members {
  return result.membersArray;
}
- (NSString*)membersAtIndex:(NSUInteger)index {
  return [result membersAtIndex:index];
}
- (GroupDetailsBuilder *)addMembers:(NSString*)value {
  if (result.membersArray == nil) {
    result.membersArray = [[NSMutableArray alloc]init];
  }
  [result.membersArray addObject:value];
  return self;
}
- (GroupDetailsBuilder *)setMembersArray:(NSArray *)array {
  result.membersArray = [[NSMutableArray alloc] initWithArray:array];
  return self;
}
- (GroupDetailsBuilder *)clearMembers {
  result.membersArray = nil;
  return self;
}
- (BOOL) hasAvatar {
  return result.hasAvatar;
}
- (GroupDetailsAvatar*) avatar {
  return result.avatar;
}
- (GroupDetailsBuilder*) setAvatar:(GroupDetailsAvatar*) value {
  result.hasAvatar = YES;
  result.avatar = value;
  return self;
}
- (GroupDetailsBuilder*) setAvatarBuilder:(GroupDetailsAvatarBuilder*) builderForValue {
  return [self setAvatar:[builderForValue build]];
}
- (GroupDetailsBuilder*) mergeAvatar:(GroupDetailsAvatar*) value {
  if (result.hasAvatar &&
      result.avatar != [GroupDetailsAvatar defaultInstance]) {
    result.avatar =
      [[[GroupDetailsAvatar builderWithPrototype:result.avatar] mergeFrom:value] buildPartial];
  } else {
    result.avatar = value;
  }
  result.hasAvatar = YES;
  return self;
}
- (GroupDetailsBuilder*) clearAvatar {
  result.hasAvatar = NO;
  result.avatar = [GroupDetailsAvatar defaultInstance];
  return self;
}
@end


// @@protoc_insertion_point(global_scope)