#!/usr/bin/env python
#
# Copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#


from . import ProtocolBuffer
import array

__pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
                   unusednames=printElemNumber,debug_strs no-special"""

if hasattr(ProtocolBuffer, "ExtendableProtocolMessage"):
    _extension_runtime = True
    _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
else:
    _extension_runtime = False
    _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage


class PropertyValue_ReferenceValuePathElement(ProtocolBuffer.ProtocolMessage):
    has_type_ = 0
    type_ = ""
    has_id_ = 0
    id_ = 0
    has_name_ = 0
    name_ = ""

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def type(self):
        return self.type_

    def set_type(self, x):
        self.has_type_ = 1
        self.type_ = x

    def clear_type(self):
        if self.has_type_:
            self.has_type_ = 0
            self.type_ = ""

    def has_type(self):
        return self.has_type_

    def id(self):
        return self.id_

    def set_id(self, x):
        self.has_id_ = 1
        self.id_ = x

    def clear_id(self):
        if self.has_id_:
            self.has_id_ = 0
            self.id_ = 0

    def has_id(self):
        return self.has_id_

    def name(self):
        return self.name_

    def set_name(self, x):
        self.has_name_ = 1
        self.name_ = x

    def clear_name(self):
        if self.has_name_:
            self.has_name_ = 0
            self.name_ = ""

    def has_name(self):
        return self.has_name_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_type():
            self.set_type(x.type())
        if x.has_id():
            self.set_id(x.id())
        if x.has_name():
            self.set_name(x.name())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_type_ != x.has_type_:
            return 0
        if self.has_type_ and self.type_ != x.type_:
            return 0
        if self.has_id_ != x.has_id_:
            return 0
        if self.has_id_ and self.id_ != x.id_:
            return 0
        if self.has_name_ != x.has_name_:
            return 0
        if self.has_name_ and self.name_ != x.name_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_type_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: type not set.")
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.type_))
        if self.has_id_:
            n += 2 + self.lengthVarInt64(self.id_)
        if self.has_name_:
            n += 2 + self.lengthString(len(self.name_))
        return n + 1

    def ByteSizePartial(self):
        n = 0
        if self.has_type_:
            n += 1
            n += self.lengthString(len(self.type_))
        if self.has_id_:
            n += 2 + self.lengthVarInt64(self.id_)
        if self.has_name_:
            n += 2 + self.lengthString(len(self.name_))
        return n

    def Clear(self):
        self.clear_type()
        self.clear_id()
        self.clear_name()

    def OutputUnchecked(self, out):
        out.putVarInt32(122)
        out.putPrefixedString(self.type_)
        if self.has_id_:
            out.putVarInt32(128)
            out.putVarInt64(self.id_)
        if self.has_name_:
            out.putVarInt32(138)
            out.putPrefixedString(self.name_)

    def OutputPartial(self, out):
        if self.has_type_:
            out.putVarInt32(122)
            out.putPrefixedString(self.type_)
        if self.has_id_:
            out.putVarInt32(128)
            out.putVarInt64(self.id_)
        if self.has_name_:
            out.putVarInt32(138)
            out.putPrefixedString(self.name_)

    def TryMerge(self, d):
        while 1:
            tt = d.getVarInt32()
            if tt == 116:
                break
            if tt == 122:
                self.set_type(d.getPrefixedString())
                continue
            if tt == 128:
                self.set_id(d.getVarInt64())
                continue
            if tt == 138:
                self.set_name(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_type_:
            res += prefix + ("type: %s\n" % self.DebugFormatString(self.type_))
        if self.has_id_:
            res += prefix + ("id: %s\n" % self.DebugFormatInt64(self.id_))
        if self.has_name_:
            res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
        return res


class PropertyValue_PointValue(ProtocolBuffer.ProtocolMessage):
    has_x_ = 0
    x_ = 0.0
    has_y_ = 0
    y_ = 0.0

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def x(self):
        return self.x_

    def set_x(self, x):
        self.has_x_ = 1
        self.x_ = x

    def clear_x(self):
        if self.has_x_:
            self.has_x_ = 0
            self.x_ = 0.0

    def has_x(self):
        return self.has_x_

    def y(self):
        return self.y_

    def set_y(self, x):
        self.has_y_ = 1
        self.y_ = x

    def clear_y(self):
        if self.has_y_:
            self.has_y_ = 0
            self.y_ = 0.0

    def has_y(self):
        return self.has_y_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_x():
            self.set_x(x.x())
        if x.has_y():
            self.set_y(x.y())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_x_ != x.has_x_:
            return 0
        if self.has_x_ and self.x_ != x.x_:
            return 0
        if self.has_y_ != x.has_y_:
            return 0
        if self.has_y_ and self.y_ != x.y_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_x_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: x not set.")
        if not self.has_y_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: y not set.")
        return initialized

    def ByteSize(self):
        n = 0
        return n + 18

    def ByteSizePartial(self):
        n = 0
        if self.has_x_:
            n += 9
        if self.has_y_:
            n += 9
        return n

    def Clear(self):
        self.clear_x()
        self.clear_y()

    def OutputUnchecked(self, out):
        out.putVarInt32(49)
        out.putDouble(self.x_)
        out.putVarInt32(57)
        out.putDouble(self.y_)

    def OutputPartial(self, out):
        if self.has_x_:
            out.putVarInt32(49)
            out.putDouble(self.x_)
        if self.has_y_:
            out.putVarInt32(57)
            out.putDouble(self.y_)

    def TryMerge(self, d):
        while 1:
            tt = d.getVarInt32()
            if tt == 44:
                break
            if tt == 49:
                self.set_x(d.getDouble())
                continue
            if tt == 57:
                self.set_y(d.getDouble())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_x_:
            res += prefix + ("x: %s\n" % self.DebugFormat(self.x_))
        if self.has_y_:
            res += prefix + ("y: %s\n" % self.DebugFormat(self.y_))
        return res


class PropertyValue_UserValue(ProtocolBuffer.ProtocolMessage):
    has_email_ = 0
    email_ = ""
    has_auth_domain_ = 0
    auth_domain_ = ""
    has_nickname_ = 0
    nickname_ = ""
    has_gaiaid_ = 0
    gaiaid_ = 0
    has_obfuscated_gaiaid_ = 0
    obfuscated_gaiaid_ = ""
    has_federated_identity_ = 0
    federated_identity_ = ""
    has_federated_provider_ = 0
    federated_provider_ = ""

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def email(self):
        return self.email_

    def set_email(self, x):
        self.has_email_ = 1
        self.email_ = x

    def clear_email(self):
        if self.has_email_:
            self.has_email_ = 0
            self.email_ = ""

    def has_email(self):
        return self.has_email_

    def auth_domain(self):
        return self.auth_domain_

    def set_auth_domain(self, x):
        self.has_auth_domain_ = 1
        self.auth_domain_ = x

    def clear_auth_domain(self):
        if self.has_auth_domain_:
            self.has_auth_domain_ = 0
            self.auth_domain_ = ""

    def has_auth_domain(self):
        return self.has_auth_domain_

    def nickname(self):
        return self.nickname_

    def set_nickname(self, x):
        self.has_nickname_ = 1
        self.nickname_ = x

    def clear_nickname(self):
        if self.has_nickname_:
            self.has_nickname_ = 0
            self.nickname_ = ""

    def has_nickname(self):
        return self.has_nickname_

    def gaiaid(self):
        return self.gaiaid_

    def set_gaiaid(self, x):
        self.has_gaiaid_ = 1
        self.gaiaid_ = x

    def clear_gaiaid(self):
        if self.has_gaiaid_:
            self.has_gaiaid_ = 0
            self.gaiaid_ = 0

    def has_gaiaid(self):
        return self.has_gaiaid_

    def obfuscated_gaiaid(self):
        return self.obfuscated_gaiaid_

    def set_obfuscated_gaiaid(self, x):
        self.has_obfuscated_gaiaid_ = 1
        self.obfuscated_gaiaid_ = x

    def clear_obfuscated_gaiaid(self):
        if self.has_obfuscated_gaiaid_:
            self.has_obfuscated_gaiaid_ = 0
            self.obfuscated_gaiaid_ = ""

    def has_obfuscated_gaiaid(self):
        return self.has_obfuscated_gaiaid_

    def federated_identity(self):
        return self.federated_identity_

    def set_federated_identity(self, x):
        self.has_federated_identity_ = 1
        self.federated_identity_ = x

    def clear_federated_identity(self):
        if self.has_federated_identity_:
            self.has_federated_identity_ = 0
            self.federated_identity_ = ""

    def has_federated_identity(self):
        return self.has_federated_identity_

    def federated_provider(self):
        return self.federated_provider_

    def set_federated_provider(self, x):
        self.has_federated_provider_ = 1
        self.federated_provider_ = x

    def clear_federated_provider(self):
        if self.has_federated_provider_:
            self.has_federated_provider_ = 0
            self.federated_provider_ = ""

    def has_federated_provider(self):
        return self.has_federated_provider_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_email():
            self.set_email(x.email())
        if x.has_auth_domain():
            self.set_auth_domain(x.auth_domain())
        if x.has_nickname():
            self.set_nickname(x.nickname())
        if x.has_gaiaid():
            self.set_gaiaid(x.gaiaid())
        if x.has_obfuscated_gaiaid():
            self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
        if x.has_federated_identity():
            self.set_federated_identity(x.federated_identity())
        if x.has_federated_provider():
            self.set_federated_provider(x.federated_provider())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_email_ != x.has_email_:
            return 0
        if self.has_email_ and self.email_ != x.email_:
            return 0
        if self.has_auth_domain_ != x.has_auth_domain_:
            return 0
        if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_:
            return 0
        if self.has_nickname_ != x.has_nickname_:
            return 0
        if self.has_nickname_ and self.nickname_ != x.nickname_:
            return 0
        if self.has_gaiaid_ != x.has_gaiaid_:
            return 0
        if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_:
            return 0
        if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_:
            return 0
        if (
            self.has_obfuscated_gaiaid_
            and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_
        ):
            return 0
        if self.has_federated_identity_ != x.has_federated_identity_:
            return 0
        if (
            self.has_federated_identity_
            and self.federated_identity_ != x.federated_identity_
        ):
            return 0
        if self.has_federated_provider_ != x.has_federated_provider_:
            return 0
        if (
            self.has_federated_provider_
            and self.federated_provider_ != x.federated_provider_
        ):
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_email_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: email not set.")
        if not self.has_auth_domain_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: auth_domain not set.")
        if not self.has_gaiaid_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: gaiaid not set.")
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.email_))
        n += self.lengthString(len(self.auth_domain_))
        if self.has_nickname_:
            n += 1 + self.lengthString(len(self.nickname_))
        n += self.lengthVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            n += 2 + self.lengthString(len(self.obfuscated_gaiaid_))
        if self.has_federated_identity_:
            n += 2 + self.lengthString(len(self.federated_identity_))
        if self.has_federated_provider_:
            n += 2 + self.lengthString(len(self.federated_provider_))
        return n + 4

    def ByteSizePartial(self):
        n = 0
        if self.has_email_:
            n += 1
            n += self.lengthString(len(self.email_))
        if self.has_auth_domain_:
            n += 1
            n += self.lengthString(len(self.auth_domain_))
        if self.has_nickname_:
            n += 1 + self.lengthString(len(self.nickname_))
        if self.has_gaiaid_:
            n += 2
            n += self.lengthVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            n += 2 + self.lengthString(len(self.obfuscated_gaiaid_))
        if self.has_federated_identity_:
            n += 2 + self.lengthString(len(self.federated_identity_))
        if self.has_federated_provider_:
            n += 2 + self.lengthString(len(self.federated_provider_))
        return n

    def Clear(self):
        self.clear_email()
        self.clear_auth_domain()
        self.clear_nickname()
        self.clear_gaiaid()
        self.clear_obfuscated_gaiaid()
        self.clear_federated_identity()
        self.clear_federated_provider()

    def OutputUnchecked(self, out):
        out.putVarInt32(74)
        out.putPrefixedString(self.email_)
        out.putVarInt32(82)
        out.putPrefixedString(self.auth_domain_)
        if self.has_nickname_:
            out.putVarInt32(90)
            out.putPrefixedString(self.nickname_)
        out.putVarInt32(144)
        out.putVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            out.putVarInt32(154)
            out.putPrefixedString(self.obfuscated_gaiaid_)
        if self.has_federated_identity_:
            out.putVarInt32(170)
            out.putPrefixedString(self.federated_identity_)
        if self.has_federated_provider_:
            out.putVarInt32(178)
            out.putPrefixedString(self.federated_provider_)

    def OutputPartial(self, out):
        if self.has_email_:
            out.putVarInt32(74)
            out.putPrefixedString(self.email_)
        if self.has_auth_domain_:
            out.putVarInt32(82)
            out.putPrefixedString(self.auth_domain_)
        if self.has_nickname_:
            out.putVarInt32(90)
            out.putPrefixedString(self.nickname_)
        if self.has_gaiaid_:
            out.putVarInt32(144)
            out.putVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            out.putVarInt32(154)
            out.putPrefixedString(self.obfuscated_gaiaid_)
        if self.has_federated_identity_:
            out.putVarInt32(170)
            out.putPrefixedString(self.federated_identity_)
        if self.has_federated_provider_:
            out.putVarInt32(178)
            out.putPrefixedString(self.federated_provider_)

    def TryMerge(self, d):
        while 1:
            tt = d.getVarInt32()
            if tt == 68:
                break
            if tt == 74:
                self.set_email(d.getPrefixedString())
                continue
            if tt == 82:
                self.set_auth_domain(d.getPrefixedString())
                continue
            if tt == 90:
                self.set_nickname(d.getPrefixedString())
                continue
            if tt == 144:
                self.set_gaiaid(d.getVarInt64())
                continue
            if tt == 154:
                self.set_obfuscated_gaiaid(d.getPrefixedString())
                continue
            if tt == 170:
                self.set_federated_identity(d.getPrefixedString())
                continue
            if tt == 178:
                self.set_federated_provider(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_email_:
            res += prefix + ("email: %s\n" % self.DebugFormatString(self.email_))
        if self.has_auth_domain_:
            res += prefix + (
                "auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_)
            )
        if self.has_nickname_:
            res += prefix + ("nickname: %s\n" % self.DebugFormatString(self.nickname_))
        if self.has_gaiaid_:
            res += prefix + ("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
        if self.has_obfuscated_gaiaid_:
            res += prefix + (
                "obfuscated_gaiaid: %s\n"
                % self.DebugFormatString(self.obfuscated_gaiaid_)
            )
        if self.has_federated_identity_:
            res += prefix + (
                "federated_identity: %s\n"
                % self.DebugFormatString(self.federated_identity_)
            )
        if self.has_federated_provider_:
            res += prefix + (
                "federated_provider: %s\n"
                % self.DebugFormatString(self.federated_provider_)
            )
        return res


class PropertyValue_ReferenceValue(ProtocolBuffer.ProtocolMessage):
    has_app_ = 0
    app_ = ""
    has_name_space_ = 0
    name_space_ = ""

    def __init__(self, contents=None):
        self.pathelement_ = []
        if contents is not None:
            self.MergeFromString(contents)

    def app(self):
        return self.app_

    def set_app(self, x):
        self.has_app_ = 1
        self.app_ = x

    def clear_app(self):
        if self.has_app_:
            self.has_app_ = 0
            self.app_ = ""

    def has_app(self):
        return self.has_app_

    def name_space(self):
        return self.name_space_

    def set_name_space(self, x):
        self.has_name_space_ = 1
        self.name_space_ = x

    def clear_name_space(self):
        if self.has_name_space_:
            self.has_name_space_ = 0
            self.name_space_ = ""

    def has_name_space(self):
        return self.has_name_space_

    def pathelement_size(self):
        return len(self.pathelement_)

    def pathelement_list(self):
        return self.pathelement_

    def pathelement(self, i):
        return self.pathelement_[i]

    def mutable_pathelement(self, i):
        return self.pathelement_[i]

    def add_pathelement(self):
        x = PropertyValue_ReferenceValuePathElement()
        self.pathelement_.append(x)
        return x

    def clear_pathelement(self):
        self.pathelement_ = []

    def MergeFrom(self, x):
        assert x is not self
        if x.has_app():
            self.set_app(x.app())
        if x.has_name_space():
            self.set_name_space(x.name_space())
        for i in range(x.pathelement_size()):
            self.add_pathelement().CopyFrom(x.pathelement(i))

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_app_ != x.has_app_:
            return 0
        if self.has_app_ and self.app_ != x.app_:
            return 0
        if self.has_name_space_ != x.has_name_space_:
            return 0
        if self.has_name_space_ and self.name_space_ != x.name_space_:
            return 0
        if len(self.pathelement_) != len(x.pathelement_):
            return 0
        for e1, e2 in zip(self.pathelement_, x.pathelement_):
            if e1 != e2:
                return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_app_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: app not set.")
        for p in self.pathelement_:
            if not p.IsInitialized(debug_strs):
                initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.app_))
        if self.has_name_space_:
            n += 2 + self.lengthString(len(self.name_space_))
        n += 2 * len(self.pathelement_)
        for i in range(len(self.pathelement_)):
            n += self.pathelement_[i].ByteSize()
        return n + 1

    def ByteSizePartial(self):
        n = 0
        if self.has_app_:
            n += 1
            n += self.lengthString(len(self.app_))
        if self.has_name_space_:
            n += 2 + self.lengthString(len(self.name_space_))
        n += 2 * len(self.pathelement_)
        for i in range(len(self.pathelement_)):
            n += self.pathelement_[i].ByteSizePartial()
        return n

    def Clear(self):
        self.clear_app()
        self.clear_name_space()
        self.clear_pathelement()

    def OutputUnchecked(self, out):
        out.putVarInt32(106)
        out.putPrefixedString(self.app_)
        for i in range(len(self.pathelement_)):
            out.putVarInt32(115)
            self.pathelement_[i].OutputUnchecked(out)
            out.putVarInt32(116)
        if self.has_name_space_:
            out.putVarInt32(162)
            out.putPrefixedString(self.name_space_)

    def OutputPartial(self, out):
        if self.has_app_:
            out.putVarInt32(106)
            out.putPrefixedString(self.app_)
        for i in range(len(self.pathelement_)):
            out.putVarInt32(115)
            self.pathelement_[i].OutputPartial(out)
            out.putVarInt32(116)
        if self.has_name_space_:
            out.putVarInt32(162)
            out.putPrefixedString(self.name_space_)

    def TryMerge(self, d):
        while 1:
            tt = d.getVarInt32()
            if tt == 100:
                break
            if tt == 106:
                self.set_app(d.getPrefixedString())
                continue
            if tt == 115:
                self.add_pathelement().TryMerge(d)
                continue
            if tt == 162:
                self.set_name_space(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_app_:
            res += prefix + ("app: %s\n" % self.DebugFormatString(self.app_))
        if self.has_name_space_:
            res += prefix + (
                "name_space: %s\n" % self.DebugFormatString(self.name_space_)
            )
        cnt = 0
        for e in self.pathelement_:
            elm = ""
            if printElemNumber:
                elm = "(%d)" % cnt
            res += prefix + ("PathElement%s {\n" % elm)
            res += e.__str__(prefix + "  ", printElemNumber)
            res += prefix + "}\n"
            cnt += 1
        return res


class PropertyValue(ProtocolBuffer.ProtocolMessage):
    has_int64value_ = 0
    int64value_ = 0
    has_booleanvalue_ = 0
    booleanvalue_ = 0
    has_stringvalue_ = 0
    stringvalue_ = ""
    has_doublevalue_ = 0
    doublevalue_ = 0.0
    has_pointvalue_ = 0
    pointvalue_ = None
    has_uservalue_ = 0
    uservalue_ = None
    has_referencevalue_ = 0
    referencevalue_ = None

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def int64value(self):
        return self.int64value_

    def set_int64value(self, x):
        self.has_int64value_ = 1
        self.int64value_ = x

    def clear_int64value(self):
        if self.has_int64value_:
            self.has_int64value_ = 0
            self.int64value_ = 0

    def has_int64value(self):
        return self.has_int64value_

    def booleanvalue(self):
        return self.booleanvalue_

    def set_booleanvalue(self, x):
        self.has_booleanvalue_ = 1
        self.booleanvalue_ = x

    def clear_booleanvalue(self):
        if self.has_booleanvalue_:
            self.has_booleanvalue_ = 0
            self.booleanvalue_ = 0

    def has_booleanvalue(self):
        return self.has_booleanvalue_

    def stringvalue(self):
        return self.stringvalue_

    def set_stringvalue(self, x):
        self.has_stringvalue_ = 1
        self.stringvalue_ = x

    def clear_stringvalue(self):
        if self.has_stringvalue_:
            self.has_stringvalue_ = 0
            self.stringvalue_ = ""

    def has_stringvalue(self):
        return self.has_stringvalue_

    def doublevalue(self):
        return self.doublevalue_

    def set_doublevalue(self, x):
        self.has_doublevalue_ = 1
        self.doublevalue_ = x

    def clear_doublevalue(self):
        if self.has_doublevalue_:
            self.has_doublevalue_ = 0
            self.doublevalue_ = 0.0

    def has_doublevalue(self):
        return self.has_doublevalue_

    def pointvalue(self):
        if self.pointvalue_ is None:
            self.pointvalue_ = PropertyValue_PointValue()
        return self.pointvalue_

    def mutable_pointvalue(self):
        self.has_pointvalue_ = 1
        return self.pointvalue()

    def clear_pointvalue(self):

        if self.has_pointvalue_:
            self.has_pointvalue_ = 0
            if self.pointvalue_ is not None:
                self.pointvalue_.Clear()

    def has_pointvalue(self):
        return self.has_pointvalue_

    def uservalue(self):
        if self.uservalue_ is None:
            self.uservalue_ = PropertyValue_UserValue()
        return self.uservalue_

    def mutable_uservalue(self):
        self.has_uservalue_ = 1
        return self.uservalue()

    def clear_uservalue(self):

        if self.has_uservalue_:
            self.has_uservalue_ = 0
            if self.uservalue_ is not None:
                self.uservalue_.Clear()

    def has_uservalue(self):
        return self.has_uservalue_

    def referencevalue(self):
        if self.referencevalue_ is None:
            self.referencevalue_ = PropertyValue_ReferenceValue()
        return self.referencevalue_

    def mutable_referencevalue(self):
        self.has_referencevalue_ = 1
        return self.referencevalue()

    def clear_referencevalue(self):

        if self.has_referencevalue_:
            self.has_referencevalue_ = 0
            if self.referencevalue_ is not None:
                self.referencevalue_.Clear()

    def has_referencevalue(self):
        return self.has_referencevalue_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_int64value():
            self.set_int64value(x.int64value())
        if x.has_booleanvalue():
            self.set_booleanvalue(x.booleanvalue())
        if x.has_stringvalue():
            self.set_stringvalue(x.stringvalue())
        if x.has_doublevalue():
            self.set_doublevalue(x.doublevalue())
        if x.has_pointvalue():
            self.mutable_pointvalue().MergeFrom(x.pointvalue())
        if x.has_uservalue():
            self.mutable_uservalue().MergeFrom(x.uservalue())
        if x.has_referencevalue():
            self.mutable_referencevalue().MergeFrom(x.referencevalue())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_int64value_ != x.has_int64value_:
            return 0
        if self.has_int64value_ and self.int64value_ != x.int64value_:
            return 0
        if self.has_booleanvalue_ != x.has_booleanvalue_:
            return 0
        if self.has_booleanvalue_ and self.booleanvalue_ != x.booleanvalue_:
            return 0
        if self.has_stringvalue_ != x.has_stringvalue_:
            return 0
        if self.has_stringvalue_ and self.stringvalue_ != x.stringvalue_:
            return 0
        if self.has_doublevalue_ != x.has_doublevalue_:
            return 0
        if self.has_doublevalue_ and self.doublevalue_ != x.doublevalue_:
            return 0
        if self.has_pointvalue_ != x.has_pointvalue_:
            return 0
        if self.has_pointvalue_ and self.pointvalue_ != x.pointvalue_:
            return 0
        if self.has_uservalue_ != x.has_uservalue_:
            return 0
        if self.has_uservalue_ and self.uservalue_ != x.uservalue_:
            return 0
        if self.has_referencevalue_ != x.has_referencevalue_:
            return 0
        if self.has_referencevalue_ and self.referencevalue_ != x.referencevalue_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if self.has_pointvalue_ and not self.pointvalue_.IsInitialized(debug_strs):
            initialized = 0
        if self.has_uservalue_ and not self.uservalue_.IsInitialized(debug_strs):
            initialized = 0
        if self.has_referencevalue_ and not self.referencevalue_.IsInitialized(
            debug_strs
        ):
            initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        if self.has_int64value_:
            n += 1 + self.lengthVarInt64(self.int64value_)
        if self.has_booleanvalue_:
            n += 2
        if self.has_stringvalue_:
            n += 1 + self.lengthString(len(self.stringvalue_))
        if self.has_doublevalue_:
            n += 9
        if self.has_pointvalue_:
            n += 2 + self.pointvalue_.ByteSize()
        if self.has_uservalue_:
            n += 2 + self.uservalue_.ByteSize()
        if self.has_referencevalue_:
            n += 2 + self.referencevalue_.ByteSize()
        return n

    def ByteSizePartial(self):
        n = 0
        if self.has_int64value_:
            n += 1 + self.lengthVarInt64(self.int64value_)
        if self.has_booleanvalue_:
            n += 2
        if self.has_stringvalue_:
            n += 1 + self.lengthString(len(self.stringvalue_))
        if self.has_doublevalue_:
            n += 9
        if self.has_pointvalue_:
            n += 2 + self.pointvalue_.ByteSizePartial()
        if self.has_uservalue_:
            n += 2 + self.uservalue_.ByteSizePartial()
        if self.has_referencevalue_:
            n += 2 + self.referencevalue_.ByteSizePartial()
        return n

    def Clear(self):
        self.clear_int64value()
        self.clear_booleanvalue()
        self.clear_stringvalue()
        self.clear_doublevalue()
        self.clear_pointvalue()
        self.clear_uservalue()
        self.clear_referencevalue()

    def OutputUnchecked(self, out):
        if self.has_int64value_:
            out.putVarInt32(8)
            out.putVarInt64(self.int64value_)
        if self.has_booleanvalue_:
            out.putVarInt32(16)
            out.putBoolean(self.booleanvalue_)
        if self.has_stringvalue_:
            out.putVarInt32(26)
            out.putPrefixedString(self.stringvalue_)
        if self.has_doublevalue_:
            out.putVarInt32(33)
            out.putDouble(self.doublevalue_)
        if self.has_pointvalue_:
            out.putVarInt32(43)
            self.pointvalue_.OutputUnchecked(out)
            out.putVarInt32(44)
        if self.has_uservalue_:
            out.putVarInt32(67)
            self.uservalue_.OutputUnchecked(out)
            out.putVarInt32(68)
        if self.has_referencevalue_:
            out.putVarInt32(99)
            self.referencevalue_.OutputUnchecked(out)
            out.putVarInt32(100)

    def OutputPartial(self, out):
        if self.has_int64value_:
            out.putVarInt32(8)
            out.putVarInt64(self.int64value_)
        if self.has_booleanvalue_:
            out.putVarInt32(16)
            out.putBoolean(self.booleanvalue_)
        if self.has_stringvalue_:
            out.putVarInt32(26)
            out.putPrefixedString(self.stringvalue_)
        if self.has_doublevalue_:
            out.putVarInt32(33)
            out.putDouble(self.doublevalue_)
        if self.has_pointvalue_:
            out.putVarInt32(43)
            self.pointvalue_.OutputPartial(out)
            out.putVarInt32(44)
        if self.has_uservalue_:
            out.putVarInt32(67)
            self.uservalue_.OutputPartial(out)
            out.putVarInt32(68)
        if self.has_referencevalue_:
            out.putVarInt32(99)
            self.referencevalue_.OutputPartial(out)
            out.putVarInt32(100)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 8:
                self.set_int64value(d.getVarInt64())
                continue
            if tt == 16:
                self.set_booleanvalue(d.getBoolean())
                continue
            if tt == 26:
                self.set_stringvalue(d.getPrefixedString())
                continue
            if tt == 33:
                self.set_doublevalue(d.getDouble())
                continue
            if tt == 43:
                self.mutable_pointvalue().TryMerge(d)
                continue
            if tt == 67:
                self.mutable_uservalue().TryMerge(d)
                continue
            if tt == 99:
                self.mutable_referencevalue().TryMerge(d)
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_int64value_:
            res += prefix + (
                "int64Value: %s\n" % self.DebugFormatInt64(self.int64value_)
            )
        if self.has_booleanvalue_:
            res += prefix + (
                "booleanValue: %s\n" % self.DebugFormatBool(self.booleanvalue_)
            )
        if self.has_stringvalue_:
            res += prefix + (
                "stringValue: %s\n" % self.DebugFormatString(self.stringvalue_)
            )
        if self.has_doublevalue_:
            res += prefix + ("doubleValue: %s\n" % self.DebugFormat(self.doublevalue_))
        if self.has_pointvalue_:
            res += prefix + "PointValue {\n"
            res += self.pointvalue_.__str__(prefix + "  ", printElemNumber)
            res += prefix + "}\n"
        if self.has_uservalue_:
            res += prefix + "UserValue {\n"
            res += self.uservalue_.__str__(prefix + "  ", printElemNumber)
            res += prefix + "}\n"
        if self.has_referencevalue_:
            res += prefix + "ReferenceValue {\n"
            res += self.referencevalue_.__str__(prefix + "  ", printElemNumber)
            res += prefix + "}\n"
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kint64Value = 1
    kbooleanValue = 2
    kstringValue = 3
    kdoubleValue = 4
    kPointValueGroup = 5
    kPointValuex = 6
    kPointValuey = 7
    kUserValueGroup = 8
    kUserValueemail = 9
    kUserValueauth_domain = 10
    kUserValuenickname = 11
    kUserValuegaiaid = 18
    kUserValueobfuscated_gaiaid = 19
    kUserValuefederated_identity = 21
    kUserValuefederated_provider = 22
    kReferenceValueGroup = 12
    kReferenceValueapp = 13
    kReferenceValuename_space = 20
    kReferenceValuePathElementGroup = 14
    kReferenceValuePathElementtype = 15
    kReferenceValuePathElementid = 16
    kReferenceValuePathElementname = 17

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "int64Value",
            2: "booleanValue",
            3: "stringValue",
            4: "doubleValue",
            5: "PointValue",
            6: "x",
            7: "y",
            8: "UserValue",
            9: "email",
            10: "auth_domain",
            11: "nickname",
            12: "ReferenceValue",
            13: "app",
            14: "PathElement",
            15: "type",
            16: "id",
            17: "name",
            18: "gaiaid",
            19: "obfuscated_gaiaid",
            20: "name_space",
            21: "federated_identity",
            22: "federated_provider",
        },
        22,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.NUMERIC,
            2: ProtocolBuffer.Encoder.NUMERIC,
            3: ProtocolBuffer.Encoder.STRING,
            4: ProtocolBuffer.Encoder.DOUBLE,
            5: ProtocolBuffer.Encoder.STARTGROUP,
            6: ProtocolBuffer.Encoder.DOUBLE,
            7: ProtocolBuffer.Encoder.DOUBLE,
            8: ProtocolBuffer.Encoder.STARTGROUP,
            9: ProtocolBuffer.Encoder.STRING,
            10: ProtocolBuffer.Encoder.STRING,
            11: ProtocolBuffer.Encoder.STRING,
            12: ProtocolBuffer.Encoder.STARTGROUP,
            13: ProtocolBuffer.Encoder.STRING,
            14: ProtocolBuffer.Encoder.STARTGROUP,
            15: ProtocolBuffer.Encoder.STRING,
            16: ProtocolBuffer.Encoder.NUMERIC,
            17: ProtocolBuffer.Encoder.STRING,
            18: ProtocolBuffer.Encoder.NUMERIC,
            19: ProtocolBuffer.Encoder.STRING,
            20: ProtocolBuffer.Encoder.STRING,
            21: ProtocolBuffer.Encoder.STRING,
            22: ProtocolBuffer.Encoder.STRING,
        },
        22,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.PropertyValue"


class Property(ProtocolBuffer.ProtocolMessage):

    NO_MEANING = 0
    BLOB = 14
    TEXT = 15
    BYTESTRING = 16
    ATOM_CATEGORY = 1
    ATOM_LINK = 2
    ATOM_TITLE = 3
    ATOM_CONTENT = 4
    ATOM_SUMMARY = 5
    ATOM_AUTHOR = 6
    GD_WHEN = 7
    GD_EMAIL = 8
    GEORSS_POINT = 9
    GD_IM = 10
    GD_PHONENUMBER = 11
    GD_POSTALADDRESS = 12
    GD_RATING = 13
    BLOBKEY = 17
    ENTITY_PROTO = 19
    INDEX_VALUE = 18

    _Meaning_NAMES = {
        0: "NO_MEANING",
        14: "BLOB",
        15: "TEXT",
        16: "BYTESTRING",
        1: "ATOM_CATEGORY",
        2: "ATOM_LINK",
        3: "ATOM_TITLE",
        4: "ATOM_CONTENT",
        5: "ATOM_SUMMARY",
        6: "ATOM_AUTHOR",
        7: "GD_WHEN",
        8: "GD_EMAIL",
        9: "GEORSS_POINT",
        10: "GD_IM",
        11: "GD_PHONENUMBER",
        12: "GD_POSTALADDRESS",
        13: "GD_RATING",
        17: "BLOBKEY",
        19: "ENTITY_PROTO",
        18: "INDEX_VALUE",
    }

    def Meaning_Name(cls, x):
        return cls._Meaning_NAMES.get(x, "")

    Meaning_Name = classmethod(Meaning_Name)

    HTML = 1
    ATOM = 2

    _FtsTokenizationOption_NAMES = {
        1: "HTML",
        2: "ATOM",
    }

    def FtsTokenizationOption_Name(cls, x):
        return cls._FtsTokenizationOption_NAMES.get(x, "")

    FtsTokenizationOption_Name = classmethod(FtsTokenizationOption_Name)

    has_meaning_ = 0
    meaning_ = 0
    has_meaning_uri_ = 0
    meaning_uri_ = ""
    has_name_ = 0
    name_ = ""
    has_value_ = 0
    has_multiple_ = 0
    multiple_ = 0
    has_searchable_ = 0
    searchable_ = 0
    has_fts_tokenization_option_ = 0
    fts_tokenization_option_ = 0
    has_locale_ = 0
    locale_ = "en"

    def __init__(self, contents=None):
        self.value_ = PropertyValue()
        if contents is not None:
            self.MergeFromString(contents)

    def meaning(self):
        return self.meaning_

    def set_meaning(self, x):
        self.has_meaning_ = 1
        self.meaning_ = x

    def clear_meaning(self):
        if self.has_meaning_:
            self.has_meaning_ = 0
            self.meaning_ = 0

    def has_meaning(self):
        return self.has_meaning_

    def meaning_uri(self):
        return self.meaning_uri_

    def set_meaning_uri(self, x):
        self.has_meaning_uri_ = 1
        self.meaning_uri_ = x

    def clear_meaning_uri(self):
        if self.has_meaning_uri_:
            self.has_meaning_uri_ = 0
            self.meaning_uri_ = ""

    def has_meaning_uri(self):
        return self.has_meaning_uri_

    def name(self):
        return self.name_

    def set_name(self, x):
        self.has_name_ = 1
        self.name_ = x

    def clear_name(self):
        if self.has_name_:
            self.has_name_ = 0
            self.name_ = ""

    def has_name(self):
        return self.has_name_

    def value(self):
        return self.value_

    def mutable_value(self):
        self.has_value_ = 1
        return self.value_

    def clear_value(self):
        self.has_value_ = 0
        self.value_.Clear()

    def has_value(self):
        return self.has_value_

    def multiple(self):
        return self.multiple_

    def set_multiple(self, x):
        self.has_multiple_ = 1
        self.multiple_ = x

    def clear_multiple(self):
        if self.has_multiple_:
            self.has_multiple_ = 0
            self.multiple_ = 0

    def has_multiple(self):
        return self.has_multiple_

    def searchable(self):
        return self.searchable_

    def set_searchable(self, x):
        self.has_searchable_ = 1
        self.searchable_ = x

    def clear_searchable(self):
        if self.has_searchable_:
            self.has_searchable_ = 0
            self.searchable_ = 0

    def has_searchable(self):
        return self.has_searchable_

    def fts_tokenization_option(self):
        return self.fts_tokenization_option_

    def set_fts_tokenization_option(self, x):
        self.has_fts_tokenization_option_ = 1
        self.fts_tokenization_option_ = x

    def clear_fts_tokenization_option(self):
        if self.has_fts_tokenization_option_:
            self.has_fts_tokenization_option_ = 0
            self.fts_tokenization_option_ = 0

    def has_fts_tokenization_option(self):
        return self.has_fts_tokenization_option_

    def locale(self):
        return self.locale_

    def set_locale(self, x):
        self.has_locale_ = 1
        self.locale_ = x

    def clear_locale(self):
        if self.has_locale_:
            self.has_locale_ = 0
            self.locale_ = "en"

    def has_locale(self):
        return self.has_locale_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_meaning():
            self.set_meaning(x.meaning())
        if x.has_meaning_uri():
            self.set_meaning_uri(x.meaning_uri())
        if x.has_name():
            self.set_name(x.name())
        if x.has_value():
            self.mutable_value().MergeFrom(x.value())
        if x.has_multiple():
            self.set_multiple(x.multiple())
        if x.has_searchable():
            self.set_searchable(x.searchable())
        if x.has_fts_tokenization_option():
            self.set_fts_tokenization_option(x.fts_tokenization_option())
        if x.has_locale():
            self.set_locale(x.locale())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_meaning_ != x.has_meaning_:
            return 0
        if self.has_meaning_ and self.meaning_ != x.meaning_:
            return 0
        if self.has_meaning_uri_ != x.has_meaning_uri_:
            return 0
        if self.has_meaning_uri_ and self.meaning_uri_ != x.meaning_uri_:
            return 0
        if self.has_name_ != x.has_name_:
            return 0
        if self.has_name_ and self.name_ != x.name_:
            return 0
        if self.has_value_ != x.has_value_:
            return 0
        if self.has_value_ and self.value_ != x.value_:
            return 0
        if self.has_multiple_ != x.has_multiple_:
            return 0
        if self.has_multiple_ and self.multiple_ != x.multiple_:
            return 0
        if self.has_searchable_ != x.has_searchable_:
            return 0
        if self.has_searchable_ and self.searchable_ != x.searchable_:
            return 0
        if self.has_fts_tokenization_option_ != x.has_fts_tokenization_option_:
            return 0
        if (
            self.has_fts_tokenization_option_
            and self.fts_tokenization_option_ != x.fts_tokenization_option_
        ):
            return 0
        if self.has_locale_ != x.has_locale_:
            return 0
        if self.has_locale_ and self.locale_ != x.locale_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_name_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: name not set.")
        if not self.has_value_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: value not set.")
        elif not self.value_.IsInitialized(debug_strs):
            initialized = 0
        if not self.has_multiple_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: multiple not set.")
        return initialized

    def ByteSize(self):
        n = 0
        if self.has_meaning_:
            n += 1 + self.lengthVarInt64(self.meaning_)
        if self.has_meaning_uri_:
            n += 1 + self.lengthString(len(self.meaning_uri_))
        n += self.lengthString(len(self.name_))
        n += self.lengthString(self.value_.ByteSize())
        if self.has_searchable_:
            n += 2
        if self.has_fts_tokenization_option_:
            n += 1 + self.lengthVarInt64(self.fts_tokenization_option_)
        if self.has_locale_:
            n += 1 + self.lengthString(len(self.locale_))
        return n + 4

    def ByteSizePartial(self):
        n = 0
        if self.has_meaning_:
            n += 1 + self.lengthVarInt64(self.meaning_)
        if self.has_meaning_uri_:
            n += 1 + self.lengthString(len(self.meaning_uri_))
        if self.has_name_:
            n += 1
            n += self.lengthString(len(self.name_))
        if self.has_value_:
            n += 1
            n += self.lengthString(self.value_.ByteSizePartial())
        if self.has_multiple_:
            n += 2
        if self.has_searchable_:
            n += 2
        if self.has_fts_tokenization_option_:
            n += 1 + self.lengthVarInt64(self.fts_tokenization_option_)
        if self.has_locale_:
            n += 1 + self.lengthString(len(self.locale_))
        return n

    def Clear(self):
        self.clear_meaning()
        self.clear_meaning_uri()
        self.clear_name()
        self.clear_value()
        self.clear_multiple()
        self.clear_searchable()
        self.clear_fts_tokenization_option()
        self.clear_locale()

    def OutputUnchecked(self, out):
        if self.has_meaning_:
            out.putVarInt32(8)
            out.putVarInt32(self.meaning_)
        if self.has_meaning_uri_:
            out.putVarInt32(18)
            out.putPrefixedString(self.meaning_uri_)
        out.putVarInt32(26)
        out.putPrefixedString(self.name_)
        out.putVarInt32(32)
        out.putBoolean(self.multiple_)
        out.putVarInt32(42)
        out.putVarInt32(self.value_.ByteSize())
        self.value_.OutputUnchecked(out)
        if self.has_searchable_:
            out.putVarInt32(48)
            out.putBoolean(self.searchable_)
        if self.has_fts_tokenization_option_:
            out.putVarInt32(64)
            out.putVarInt32(self.fts_tokenization_option_)
        if self.has_locale_:
            out.putVarInt32(74)
            out.putPrefixedString(self.locale_)

    def OutputPartial(self, out):
        if self.has_meaning_:
            out.putVarInt32(8)
            out.putVarInt32(self.meaning_)
        if self.has_meaning_uri_:
            out.putVarInt32(18)
            out.putPrefixedString(self.meaning_uri_)
        if self.has_name_:
            out.putVarInt32(26)
            out.putPrefixedString(self.name_)
        if self.has_multiple_:
            out.putVarInt32(32)
            out.putBoolean(self.multiple_)
        if self.has_value_:
            out.putVarInt32(42)
            out.putVarInt32(self.value_.ByteSizePartial())
            self.value_.OutputPartial(out)
        if self.has_searchable_:
            out.putVarInt32(48)
            out.putBoolean(self.searchable_)
        if self.has_fts_tokenization_option_:
            out.putVarInt32(64)
            out.putVarInt32(self.fts_tokenization_option_)
        if self.has_locale_:
            out.putVarInt32(74)
            out.putPrefixedString(self.locale_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 8:
                self.set_meaning(d.getVarInt32())
                continue
            if tt == 18:
                self.set_meaning_uri(d.getPrefixedString())
                continue
            if tt == 26:
                self.set_name(d.getPrefixedString())
                continue
            if tt == 32:
                self.set_multiple(d.getBoolean())
                continue
            if tt == 42:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_value().TryMerge(tmp)
                continue
            if tt == 48:
                self.set_searchable(d.getBoolean())
                continue
            if tt == 64:
                self.set_fts_tokenization_option(d.getVarInt32())
                continue
            if tt == 74:
                self.set_locale(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_meaning_:
            res += prefix + ("meaning: %s\n" % self.DebugFormatInt32(self.meaning_))
        if self.has_meaning_uri_:
            res += prefix + (
                "meaning_uri: %s\n" % self.DebugFormatString(self.meaning_uri_)
            )
        if self.has_name_:
            res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
        if self.has_value_:
            res += prefix + "value <\n"
            res += self.value_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_multiple_:
            res += prefix + ("multiple: %s\n" % self.DebugFormatBool(self.multiple_))
        if self.has_searchable_:
            res += prefix + (
                "searchable: %s\n" % self.DebugFormatBool(self.searchable_)
            )
        if self.has_fts_tokenization_option_:
            res += prefix + (
                "fts_tokenization_option: %s\n"
                % self.DebugFormatInt32(self.fts_tokenization_option_)
            )
        if self.has_locale_:
            res += prefix + ("locale: %s\n" % self.DebugFormatString(self.locale_))
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kmeaning = 1
    kmeaning_uri = 2
    kname = 3
    kvalue = 5
    kmultiple = 4
    ksearchable = 6
    kfts_tokenization_option = 8
    klocale = 9

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "meaning",
            2: "meaning_uri",
            3: "name",
            4: "multiple",
            5: "value",
            6: "searchable",
            8: "fts_tokenization_option",
            9: "locale",
        },
        9,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.NUMERIC,
            2: ProtocolBuffer.Encoder.STRING,
            3: ProtocolBuffer.Encoder.STRING,
            4: ProtocolBuffer.Encoder.NUMERIC,
            5: ProtocolBuffer.Encoder.STRING,
            6: ProtocolBuffer.Encoder.NUMERIC,
            8: ProtocolBuffer.Encoder.NUMERIC,
            9: ProtocolBuffer.Encoder.STRING,
        },
        9,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Property"


class Path_Element(ProtocolBuffer.ProtocolMessage):
    has_type_ = 0
    type_ = ""
    has_id_ = 0
    id_ = 0
    has_name_ = 0
    name_ = ""

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def type(self):
        return self.type_

    def set_type(self, x):
        self.has_type_ = 1
        self.type_ = x

    def clear_type(self):
        if self.has_type_:
            self.has_type_ = 0
            self.type_ = ""

    def has_type(self):
        return self.has_type_

    def id(self):
        return self.id_

    def set_id(self, x):
        self.has_id_ = 1
        self.id_ = x

    def clear_id(self):
        if self.has_id_:
            self.has_id_ = 0
            self.id_ = 0

    def has_id(self):
        return self.has_id_

    def name(self):
        return self.name_

    def set_name(self, x):
        self.has_name_ = 1
        self.name_ = x

    def clear_name(self):
        if self.has_name_:
            self.has_name_ = 0
            self.name_ = ""

    def has_name(self):
        return self.has_name_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_type():
            self.set_type(x.type())
        if x.has_id():
            self.set_id(x.id())
        if x.has_name():
            self.set_name(x.name())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_type_ != x.has_type_:
            return 0
        if self.has_type_ and self.type_ != x.type_:
            return 0
        if self.has_id_ != x.has_id_:
            return 0
        if self.has_id_ and self.id_ != x.id_:
            return 0
        if self.has_name_ != x.has_name_:
            return 0
        if self.has_name_ and self.name_ != x.name_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_type_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: type not set.")
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.type_))
        if self.has_id_:
            n += 1 + self.lengthVarInt64(self.id_)
        if self.has_name_:
            n += 1 + self.lengthString(len(self.name_))
        return n + 1

    def ByteSizePartial(self):
        n = 0
        if self.has_type_:
            n += 1
            n += self.lengthString(len(self.type_))
        if self.has_id_:
            n += 1 + self.lengthVarInt64(self.id_)
        if self.has_name_:
            n += 1 + self.lengthString(len(self.name_))
        return n

    def Clear(self):
        self.clear_type()
        self.clear_id()
        self.clear_name()

    def OutputUnchecked(self, out):
        out.putVarInt32(18)
        out.putPrefixedString(self.type_)
        if self.has_id_:
            out.putVarInt32(24)
            out.putVarInt64(self.id_)
        if self.has_name_:
            out.putVarInt32(34)
            out.putPrefixedString(self.name_)

    def OutputPartial(self, out):
        if self.has_type_:
            out.putVarInt32(18)
            out.putPrefixedString(self.type_)
        if self.has_id_:
            out.putVarInt32(24)
            out.putVarInt64(self.id_)
        if self.has_name_:
            out.putVarInt32(34)
            out.putPrefixedString(self.name_)

    def TryMerge(self, d):
        while 1:
            tt = d.getVarInt32()
            if tt == 12:
                break
            if tt == 18:
                self.set_type(d.getPrefixedString())
                continue
            if tt == 24:
                self.set_id(d.getVarInt64())
                continue
            if tt == 34:
                self.set_name(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_type_:
            res += prefix + ("type: %s\n" % self.DebugFormatString(self.type_))
        if self.has_id_:
            res += prefix + ("id: %s\n" % self.DebugFormatInt64(self.id_))
        if self.has_name_:
            res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
        return res


class Path(ProtocolBuffer.ProtocolMessage):
    def __init__(self, contents=None):
        self.element_ = []
        if contents is not None:
            self.MergeFromString(contents)

    def element_size(self):
        return len(self.element_)

    def element_list(self):
        return self.element_

    def element(self, i):
        return self.element_[i]

    def mutable_element(self, i):
        return self.element_[i]

    def add_element(self):
        x = Path_Element()
        self.element_.append(x)
        return x

    def clear_element(self):
        self.element_ = []

    def MergeFrom(self, x):
        assert x is not self
        for i in range(x.element_size()):
            self.add_element().CopyFrom(x.element(i))

    def Equals(self, x):
        if x is self:
            return 1
        if len(self.element_) != len(x.element_):
            return 0
        for e1, e2 in zip(self.element_, x.element_):
            if e1 != e2:
                return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        for p in self.element_:
            if not p.IsInitialized(debug_strs):
                initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += 2 * len(self.element_)
        for i in range(len(self.element_)):
            n += self.element_[i].ByteSize()
        return n

    def ByteSizePartial(self):
        n = 0
        n += 2 * len(self.element_)
        for i in range(len(self.element_)):
            n += self.element_[i].ByteSizePartial()
        return n

    def Clear(self):
        self.clear_element()

    def OutputUnchecked(self, out):
        for i in range(len(self.element_)):
            out.putVarInt32(11)
            self.element_[i].OutputUnchecked(out)
            out.putVarInt32(12)

    def OutputPartial(self, out):
        for i in range(len(self.element_)):
            out.putVarInt32(11)
            self.element_[i].OutputPartial(out)
            out.putVarInt32(12)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 11:
                self.add_element().TryMerge(d)
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        cnt = 0
        for e in self.element_:
            elm = ""
            if printElemNumber:
                elm = "(%d)" % cnt
            res += prefix + ("Element%s {\n" % elm)
            res += e.__str__(prefix + "  ", printElemNumber)
            res += prefix + "}\n"
            cnt += 1
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kElementGroup = 1
    kElementtype = 2
    kElementid = 3
    kElementname = 4

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "Element",
            2: "type",
            3: "id",
            4: "name",
        },
        4,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STARTGROUP,
            2: ProtocolBuffer.Encoder.STRING,
            3: ProtocolBuffer.Encoder.NUMERIC,
            4: ProtocolBuffer.Encoder.STRING,
        },
        4,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Path"


class Reference(ProtocolBuffer.ProtocolMessage):
    has_app_ = 0
    app_ = ""
    has_name_space_ = 0
    name_space_ = ""
    has_path_ = 0

    def __init__(self, contents=None):
        self.path_ = Path()
        if contents is not None:
            self.MergeFromString(contents)

    def app(self):
        return self.app_

    def set_app(self, x):
        self.has_app_ = 1
        self.app_ = x

    def clear_app(self):
        if self.has_app_:
            self.has_app_ = 0
            self.app_ = ""

    def has_app(self):
        return self.has_app_

    def name_space(self):
        return self.name_space_

    def set_name_space(self, x):
        self.has_name_space_ = 1
        self.name_space_ = x

    def clear_name_space(self):
        if self.has_name_space_:
            self.has_name_space_ = 0
            self.name_space_ = ""

    def has_name_space(self):
        return self.has_name_space_

    def path(self):
        return self.path_

    def mutable_path(self):
        self.has_path_ = 1
        return self.path_

    def clear_path(self):
        self.has_path_ = 0
        self.path_.Clear()

    def has_path(self):
        return self.has_path_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_app():
            self.set_app(x.app())
        if x.has_name_space():
            self.set_name_space(x.name_space())
        if x.has_path():
            self.mutable_path().MergeFrom(x.path())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_app_ != x.has_app_:
            return 0
        if self.has_app_ and self.app_ != x.app_:
            return 0
        if self.has_name_space_ != x.has_name_space_:
            return 0
        if self.has_name_space_ and self.name_space_ != x.name_space_:
            return 0
        if self.has_path_ != x.has_path_:
            return 0
        if self.has_path_ and self.path_ != x.path_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_app_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: app not set.")
        if not self.has_path_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: path not set.")
        elif not self.path_.IsInitialized(debug_strs):
            initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.app_))
        if self.has_name_space_:
            n += 2 + self.lengthString(len(self.name_space_))
        n += self.lengthString(self.path_.ByteSize())
        return n + 2

    def ByteSizePartial(self):
        n = 0
        if self.has_app_:
            n += 1
            n += self.lengthString(len(self.app_))
        if self.has_name_space_:
            n += 2 + self.lengthString(len(self.name_space_))
        if self.has_path_:
            n += 1
            n += self.lengthString(self.path_.ByteSizePartial())
        return n

    def Clear(self):
        self.clear_app()
        self.clear_name_space()
        self.clear_path()

    def OutputUnchecked(self, out):
        out.putVarInt32(106)
        out.putPrefixedString(self.app_)
        out.putVarInt32(114)
        out.putVarInt32(self.path_.ByteSize())
        self.path_.OutputUnchecked(out)
        if self.has_name_space_:
            out.putVarInt32(162)
            out.putPrefixedString(self.name_space_)

    def OutputPartial(self, out):
        if self.has_app_:
            out.putVarInt32(106)
            out.putPrefixedString(self.app_)
        if self.has_path_:
            out.putVarInt32(114)
            out.putVarInt32(self.path_.ByteSizePartial())
            self.path_.OutputPartial(out)
        if self.has_name_space_:
            out.putVarInt32(162)
            out.putPrefixedString(self.name_space_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 106:
                self.set_app(d.getPrefixedString())
                continue
            if tt == 114:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_path().TryMerge(tmp)
                continue
            if tt == 162:
                self.set_name_space(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_app_:
            res += prefix + ("app: %s\n" % self.DebugFormatString(self.app_))
        if self.has_name_space_:
            res += prefix + (
                "name_space: %s\n" % self.DebugFormatString(self.name_space_)
            )
        if self.has_path_:
            res += prefix + "path <\n"
            res += self.path_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kapp = 13
    kname_space = 20
    kpath = 14

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            13: "app",
            14: "path",
            20: "name_space",
        },
        20,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            13: ProtocolBuffer.Encoder.STRING,
            14: ProtocolBuffer.Encoder.STRING,
            20: ProtocolBuffer.Encoder.STRING,
        },
        20,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Reference"


class User(ProtocolBuffer.ProtocolMessage):
    has_email_ = 0
    email_ = ""
    has_auth_domain_ = 0
    auth_domain_ = ""
    has_nickname_ = 0
    nickname_ = ""
    has_gaiaid_ = 0
    gaiaid_ = 0
    has_obfuscated_gaiaid_ = 0
    obfuscated_gaiaid_ = ""
    has_federated_identity_ = 0
    federated_identity_ = ""
    has_federated_provider_ = 0
    federated_provider_ = ""

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def email(self):
        return self.email_

    def set_email(self, x):
        self.has_email_ = 1
        self.email_ = x

    def clear_email(self):
        if self.has_email_:
            self.has_email_ = 0
            self.email_ = ""

    def has_email(self):
        return self.has_email_

    def auth_domain(self):
        return self.auth_domain_

    def set_auth_domain(self, x):
        self.has_auth_domain_ = 1
        self.auth_domain_ = x

    def clear_auth_domain(self):
        if self.has_auth_domain_:
            self.has_auth_domain_ = 0
            self.auth_domain_ = ""

    def has_auth_domain(self):
        return self.has_auth_domain_

    def nickname(self):
        return self.nickname_

    def set_nickname(self, x):
        self.has_nickname_ = 1
        self.nickname_ = x

    def clear_nickname(self):
        if self.has_nickname_:
            self.has_nickname_ = 0
            self.nickname_ = ""

    def has_nickname(self):
        return self.has_nickname_

    def gaiaid(self):
        return self.gaiaid_

    def set_gaiaid(self, x):
        self.has_gaiaid_ = 1
        self.gaiaid_ = x

    def clear_gaiaid(self):
        if self.has_gaiaid_:
            self.has_gaiaid_ = 0
            self.gaiaid_ = 0

    def has_gaiaid(self):
        return self.has_gaiaid_

    def obfuscated_gaiaid(self):
        return self.obfuscated_gaiaid_

    def set_obfuscated_gaiaid(self, x):
        self.has_obfuscated_gaiaid_ = 1
        self.obfuscated_gaiaid_ = x

    def clear_obfuscated_gaiaid(self):
        if self.has_obfuscated_gaiaid_:
            self.has_obfuscated_gaiaid_ = 0
            self.obfuscated_gaiaid_ = ""

    def has_obfuscated_gaiaid(self):
        return self.has_obfuscated_gaiaid_

    def federated_identity(self):
        return self.federated_identity_

    def set_federated_identity(self, x):
        self.has_federated_identity_ = 1
        self.federated_identity_ = x

    def clear_federated_identity(self):
        if self.has_federated_identity_:
            self.has_federated_identity_ = 0
            self.federated_identity_ = ""

    def has_federated_identity(self):
        return self.has_federated_identity_

    def federated_provider(self):
        return self.federated_provider_

    def set_federated_provider(self, x):
        self.has_federated_provider_ = 1
        self.federated_provider_ = x

    def clear_federated_provider(self):
        if self.has_federated_provider_:
            self.has_federated_provider_ = 0
            self.federated_provider_ = ""

    def has_federated_provider(self):
        return self.has_federated_provider_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_email():
            self.set_email(x.email())
        if x.has_auth_domain():
            self.set_auth_domain(x.auth_domain())
        if x.has_nickname():
            self.set_nickname(x.nickname())
        if x.has_gaiaid():
            self.set_gaiaid(x.gaiaid())
        if x.has_obfuscated_gaiaid():
            self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
        if x.has_federated_identity():
            self.set_federated_identity(x.federated_identity())
        if x.has_federated_provider():
            self.set_federated_provider(x.federated_provider())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_email_ != x.has_email_:
            return 0
        if self.has_email_ and self.email_ != x.email_:
            return 0
        if self.has_auth_domain_ != x.has_auth_domain_:
            return 0
        if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_:
            return 0
        if self.has_nickname_ != x.has_nickname_:
            return 0
        if self.has_nickname_ and self.nickname_ != x.nickname_:
            return 0
        if self.has_gaiaid_ != x.has_gaiaid_:
            return 0
        if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_:
            return 0
        if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_:
            return 0
        if (
            self.has_obfuscated_gaiaid_
            and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_
        ):
            return 0
        if self.has_federated_identity_ != x.has_federated_identity_:
            return 0
        if (
            self.has_federated_identity_
            and self.federated_identity_ != x.federated_identity_
        ):
            return 0
        if self.has_federated_provider_ != x.has_federated_provider_:
            return 0
        if (
            self.has_federated_provider_
            and self.federated_provider_ != x.federated_provider_
        ):
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_email_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: email not set.")
        if not self.has_auth_domain_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: auth_domain not set.")
        if not self.has_gaiaid_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: gaiaid not set.")
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.email_))
        n += self.lengthString(len(self.auth_domain_))
        if self.has_nickname_:
            n += 1 + self.lengthString(len(self.nickname_))
        n += self.lengthVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
        if self.has_federated_identity_:
            n += 1 + self.lengthString(len(self.federated_identity_))
        if self.has_federated_provider_:
            n += 1 + self.lengthString(len(self.federated_provider_))
        return n + 3

    def ByteSizePartial(self):
        n = 0
        if self.has_email_:
            n += 1
            n += self.lengthString(len(self.email_))
        if self.has_auth_domain_:
            n += 1
            n += self.lengthString(len(self.auth_domain_))
        if self.has_nickname_:
            n += 1 + self.lengthString(len(self.nickname_))
        if self.has_gaiaid_:
            n += 1
            n += self.lengthVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
        if self.has_federated_identity_:
            n += 1 + self.lengthString(len(self.federated_identity_))
        if self.has_federated_provider_:
            n += 1 + self.lengthString(len(self.federated_provider_))
        return n

    def Clear(self):
        self.clear_email()
        self.clear_auth_domain()
        self.clear_nickname()
        self.clear_gaiaid()
        self.clear_obfuscated_gaiaid()
        self.clear_federated_identity()
        self.clear_federated_provider()

    def OutputUnchecked(self, out):
        out.putVarInt32(10)
        out.putPrefixedString(self.email_)
        out.putVarInt32(18)
        out.putPrefixedString(self.auth_domain_)
        if self.has_nickname_:
            out.putVarInt32(26)
            out.putPrefixedString(self.nickname_)
        out.putVarInt32(32)
        out.putVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            out.putVarInt32(42)
            out.putPrefixedString(self.obfuscated_gaiaid_)
        if self.has_federated_identity_:
            out.putVarInt32(50)
            out.putPrefixedString(self.federated_identity_)
        if self.has_federated_provider_:
            out.putVarInt32(58)
            out.putPrefixedString(self.federated_provider_)

    def OutputPartial(self, out):
        if self.has_email_:
            out.putVarInt32(10)
            out.putPrefixedString(self.email_)
        if self.has_auth_domain_:
            out.putVarInt32(18)
            out.putPrefixedString(self.auth_domain_)
        if self.has_nickname_:
            out.putVarInt32(26)
            out.putPrefixedString(self.nickname_)
        if self.has_gaiaid_:
            out.putVarInt32(32)
            out.putVarInt64(self.gaiaid_)
        if self.has_obfuscated_gaiaid_:
            out.putVarInt32(42)
            out.putPrefixedString(self.obfuscated_gaiaid_)
        if self.has_federated_identity_:
            out.putVarInt32(50)
            out.putPrefixedString(self.federated_identity_)
        if self.has_federated_provider_:
            out.putVarInt32(58)
            out.putPrefixedString(self.federated_provider_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                self.set_email(d.getPrefixedString())
                continue
            if tt == 18:
                self.set_auth_domain(d.getPrefixedString())
                continue
            if tt == 26:
                self.set_nickname(d.getPrefixedString())
                continue
            if tt == 32:
                self.set_gaiaid(d.getVarInt64())
                continue
            if tt == 42:
                self.set_obfuscated_gaiaid(d.getPrefixedString())
                continue
            if tt == 50:
                self.set_federated_identity(d.getPrefixedString())
                continue
            if tt == 58:
                self.set_federated_provider(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_email_:
            res += prefix + ("email: %s\n" % self.DebugFormatString(self.email_))
        if self.has_auth_domain_:
            res += prefix + (
                "auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_)
            )
        if self.has_nickname_:
            res += prefix + ("nickname: %s\n" % self.DebugFormatString(self.nickname_))
        if self.has_gaiaid_:
            res += prefix + ("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
        if self.has_obfuscated_gaiaid_:
            res += prefix + (
                "obfuscated_gaiaid: %s\n"
                % self.DebugFormatString(self.obfuscated_gaiaid_)
            )
        if self.has_federated_identity_:
            res += prefix + (
                "federated_identity: %s\n"
                % self.DebugFormatString(self.federated_identity_)
            )
        if self.has_federated_provider_:
            res += prefix + (
                "federated_provider: %s\n"
                % self.DebugFormatString(self.federated_provider_)
            )
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kemail = 1
    kauth_domain = 2
    knickname = 3
    kgaiaid = 4
    kobfuscated_gaiaid = 5
    kfederated_identity = 6
    kfederated_provider = 7

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "email",
            2: "auth_domain",
            3: "nickname",
            4: "gaiaid",
            5: "obfuscated_gaiaid",
            6: "federated_identity",
            7: "federated_provider",
        },
        7,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STRING,
            2: ProtocolBuffer.Encoder.STRING,
            3: ProtocolBuffer.Encoder.STRING,
            4: ProtocolBuffer.Encoder.NUMERIC,
            5: ProtocolBuffer.Encoder.STRING,
            6: ProtocolBuffer.Encoder.STRING,
            7: ProtocolBuffer.Encoder.STRING,
        },
        7,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.User"


class EntityProto(ProtocolBuffer.ProtocolMessage):

    GD_CONTACT = 1
    GD_EVENT = 2
    GD_MESSAGE = 3

    _Kind_NAMES = {
        1: "GD_CONTACT",
        2: "GD_EVENT",
        3: "GD_MESSAGE",
    }

    def Kind_Name(cls, x):
        return cls._Kind_NAMES.get(x, "")

    Kind_Name = classmethod(Kind_Name)

    has_key_ = 0
    has_entity_group_ = 0
    has_owner_ = 0
    owner_ = None
    has_kind_ = 0
    kind_ = 0
    has_kind_uri_ = 0
    kind_uri_ = ""
    has_rank_ = 0
    rank_ = 0

    def __init__(self, contents=None):
        self.key_ = Reference()
        self.entity_group_ = Path()
        self.property_ = []
        self.raw_property_ = []
        if contents is not None:
            self.MergeFromString(contents)

    def key(self):
        return self.key_

    def mutable_key(self):
        self.has_key_ = 1
        return self.key_

    def clear_key(self):
        self.has_key_ = 0
        self.key_.Clear()

    def has_key(self):
        return self.has_key_

    def entity_group(self):
        return self.entity_group_

    def mutable_entity_group(self):
        self.has_entity_group_ = 1
        return self.entity_group_

    def clear_entity_group(self):
        self.has_entity_group_ = 0
        self.entity_group_.Clear()

    def has_entity_group(self):
        return self.has_entity_group_

    def owner(self):
        if self.owner_ is None:
            self.owner_ = User()
        return self.owner_

    def mutable_owner(self):
        self.has_owner_ = 1
        return self.owner()

    def clear_owner(self):

        if self.has_owner_:
            self.has_owner_ = 0
            if self.owner_ is not None:
                self.owner_.Clear()

    def has_owner(self):
        return self.has_owner_

    def kind(self):
        return self.kind_

    def set_kind(self, x):
        self.has_kind_ = 1
        self.kind_ = x

    def clear_kind(self):
        if self.has_kind_:
            self.has_kind_ = 0
            self.kind_ = 0

    def has_kind(self):
        return self.has_kind_

    def kind_uri(self):
        return self.kind_uri_

    def set_kind_uri(self, x):
        self.has_kind_uri_ = 1
        self.kind_uri_ = x

    def clear_kind_uri(self):
        if self.has_kind_uri_:
            self.has_kind_uri_ = 0
            self.kind_uri_ = ""

    def has_kind_uri(self):
        return self.has_kind_uri_

    def property_size(self):
        return len(self.property_)

    def property_list(self):
        return self.property_

    def property(self, i):
        return self.property_[i]

    def mutable_property(self, i):
        return self.property_[i]

    def add_property(self):
        x = Property()
        self.property_.append(x)
        return x

    def clear_property(self):
        self.property_ = []

    def raw_property_size(self):
        return len(self.raw_property_)

    def raw_property_list(self):
        return self.raw_property_

    def raw_property(self, i):
        return self.raw_property_[i]

    def mutable_raw_property(self, i):
        return self.raw_property_[i]

    def add_raw_property(self):
        x = Property()
        self.raw_property_.append(x)
        return x

    def clear_raw_property(self):
        self.raw_property_ = []

    def rank(self):
        return self.rank_

    def set_rank(self, x):
        self.has_rank_ = 1
        self.rank_ = x

    def clear_rank(self):
        if self.has_rank_:
            self.has_rank_ = 0
            self.rank_ = 0

    def has_rank(self):
        return self.has_rank_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_key():
            self.mutable_key().MergeFrom(x.key())
        if x.has_entity_group():
            self.mutable_entity_group().MergeFrom(x.entity_group())
        if x.has_owner():
            self.mutable_owner().MergeFrom(x.owner())
        if x.has_kind():
            self.set_kind(x.kind())
        if x.has_kind_uri():
            self.set_kind_uri(x.kind_uri())
        for i in range(x.property_size()):
            self.add_property().CopyFrom(x.property(i))
        for i in range(x.raw_property_size()):
            self.add_raw_property().CopyFrom(x.raw_property(i))
        if x.has_rank():
            self.set_rank(x.rank())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_key_ != x.has_key_:
            return 0
        if self.has_key_ and self.key_ != x.key_:
            return 0
        if self.has_entity_group_ != x.has_entity_group_:
            return 0
        if self.has_entity_group_ and self.entity_group_ != x.entity_group_:
            return 0
        if self.has_owner_ != x.has_owner_:
            return 0
        if self.has_owner_ and self.owner_ != x.owner_:
            return 0
        if self.has_kind_ != x.has_kind_:
            return 0
        if self.has_kind_ and self.kind_ != x.kind_:
            return 0
        if self.has_kind_uri_ != x.has_kind_uri_:
            return 0
        if self.has_kind_uri_ and self.kind_uri_ != x.kind_uri_:
            return 0
        if len(self.property_) != len(x.property_):
            return 0
        for e1, e2 in zip(self.property_, x.property_):
            if e1 != e2:
                return 0
        if len(self.raw_property_) != len(x.raw_property_):
            return 0
        for e1, e2 in zip(self.raw_property_, x.raw_property_):
            if e1 != e2:
                return 0
        if self.has_rank_ != x.has_rank_:
            return 0
        if self.has_rank_ and self.rank_ != x.rank_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_key_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: key not set.")
        elif not self.key_.IsInitialized(debug_strs):
            initialized = 0
        if not self.has_entity_group_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: entity_group not set.")
        elif not self.entity_group_.IsInitialized(debug_strs):
            initialized = 0
        if self.has_owner_ and not self.owner_.IsInitialized(debug_strs):
            initialized = 0
        for p in self.property_:
            if not p.IsInitialized(debug_strs):
                initialized = 0
        for p in self.raw_property_:
            if not p.IsInitialized(debug_strs):
                initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(self.key_.ByteSize())
        n += self.lengthString(self.entity_group_.ByteSize())
        if self.has_owner_:
            n += 2 + self.lengthString(self.owner_.ByteSize())
        if self.has_kind_:
            n += 1 + self.lengthVarInt64(self.kind_)
        if self.has_kind_uri_:
            n += 1 + self.lengthString(len(self.kind_uri_))
        n += 1 * len(self.property_)
        for i in range(len(self.property_)):
            n += self.lengthString(self.property_[i].ByteSize())
        n += 1 * len(self.raw_property_)
        for i in range(len(self.raw_property_)):
            n += self.lengthString(self.raw_property_[i].ByteSize())
        if self.has_rank_:
            n += 2 + self.lengthVarInt64(self.rank_)
        return n + 3

    def ByteSizePartial(self):
        n = 0
        if self.has_key_:
            n += 1
            n += self.lengthString(self.key_.ByteSizePartial())
        if self.has_entity_group_:
            n += 2
            n += self.lengthString(self.entity_group_.ByteSizePartial())
        if self.has_owner_:
            n += 2 + self.lengthString(self.owner_.ByteSizePartial())
        if self.has_kind_:
            n += 1 + self.lengthVarInt64(self.kind_)
        if self.has_kind_uri_:
            n += 1 + self.lengthString(len(self.kind_uri_))
        n += 1 * len(self.property_)
        for i in range(len(self.property_)):
            n += self.lengthString(self.property_[i].ByteSizePartial())
        n += 1 * len(self.raw_property_)
        for i in range(len(self.raw_property_)):
            n += self.lengthString(self.raw_property_[i].ByteSizePartial())
        if self.has_rank_:
            n += 2 + self.lengthVarInt64(self.rank_)
        return n

    def Clear(self):
        self.clear_key()
        self.clear_entity_group()
        self.clear_owner()
        self.clear_kind()
        self.clear_kind_uri()
        self.clear_property()
        self.clear_raw_property()
        self.clear_rank()

    def OutputUnchecked(self, out):
        if self.has_kind_:
            out.putVarInt32(32)
            out.putVarInt32(self.kind_)
        if self.has_kind_uri_:
            out.putVarInt32(42)
            out.putPrefixedString(self.kind_uri_)
        out.putVarInt32(106)
        out.putVarInt32(self.key_.ByteSize())
        self.key_.OutputUnchecked(out)
        for i in range(len(self.property_)):
            out.putVarInt32(114)
            out.putVarInt32(self.property_[i].ByteSize())
            self.property_[i].OutputUnchecked(out)
        for i in range(len(self.raw_property_)):
            out.putVarInt32(122)
            out.putVarInt32(self.raw_property_[i].ByteSize())
            self.raw_property_[i].OutputUnchecked(out)
        out.putVarInt32(130)
        out.putVarInt32(self.entity_group_.ByteSize())
        self.entity_group_.OutputUnchecked(out)
        if self.has_owner_:
            out.putVarInt32(138)
            out.putVarInt32(self.owner_.ByteSize())
            self.owner_.OutputUnchecked(out)
        if self.has_rank_:
            out.putVarInt32(144)
            out.putVarInt32(self.rank_)

    def OutputPartial(self, out):
        if self.has_kind_:
            out.putVarInt32(32)
            out.putVarInt32(self.kind_)
        if self.has_kind_uri_:
            out.putVarInt32(42)
            out.putPrefixedString(self.kind_uri_)
        if self.has_key_:
            out.putVarInt32(106)
            out.putVarInt32(self.key_.ByteSizePartial())
            self.key_.OutputPartial(out)
        for i in range(len(self.property_)):
            out.putVarInt32(114)
            out.putVarInt32(self.property_[i].ByteSizePartial())
            self.property_[i].OutputPartial(out)
        for i in range(len(self.raw_property_)):
            out.putVarInt32(122)
            out.putVarInt32(self.raw_property_[i].ByteSizePartial())
            self.raw_property_[i].OutputPartial(out)
        if self.has_entity_group_:
            out.putVarInt32(130)
            out.putVarInt32(self.entity_group_.ByteSizePartial())
            self.entity_group_.OutputPartial(out)
        if self.has_owner_:
            out.putVarInt32(138)
            out.putVarInt32(self.owner_.ByteSizePartial())
            self.owner_.OutputPartial(out)
        if self.has_rank_:
            out.putVarInt32(144)
            out.putVarInt32(self.rank_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 32:
                self.set_kind(d.getVarInt32())
                continue
            if tt == 42:
                self.set_kind_uri(d.getPrefixedString())
                continue
            if tt == 106:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_key().TryMerge(tmp)
                continue
            if tt == 114:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.add_property().TryMerge(tmp)
                continue
            if tt == 122:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.add_raw_property().TryMerge(tmp)
                continue
            if tt == 130:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_entity_group().TryMerge(tmp)
                continue
            if tt == 138:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_owner().TryMerge(tmp)
                continue
            if tt == 144:
                self.set_rank(d.getVarInt32())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_key_:
            res += prefix + "key <\n"
            res += self.key_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_entity_group_:
            res += prefix + "entity_group <\n"
            res += self.entity_group_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_owner_:
            res += prefix + "owner <\n"
            res += self.owner_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_kind_:
            res += prefix + ("kind: %s\n" % self.DebugFormatInt32(self.kind_))
        if self.has_kind_uri_:
            res += prefix + ("kind_uri: %s\n" % self.DebugFormatString(self.kind_uri_))
        cnt = 0
        for e in self.property_:
            elm = ""
            if printElemNumber:
                elm = "(%d)" % cnt
            res += prefix + ("property%s <\n" % elm)
            res += e.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
            cnt += 1
        cnt = 0
        for e in self.raw_property_:
            elm = ""
            if printElemNumber:
                elm = "(%d)" % cnt
            res += prefix + ("raw_property%s <\n" % elm)
            res += e.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
            cnt += 1
        if self.has_rank_:
            res += prefix + ("rank: %s\n" % self.DebugFormatInt32(self.rank_))
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kkey = 13
    kentity_group = 16
    kowner = 17
    kkind = 4
    kkind_uri = 5
    kproperty = 14
    kraw_property = 15
    krank = 18

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            4: "kind",
            5: "kind_uri",
            13: "key",
            14: "property",
            15: "raw_property",
            16: "entity_group",
            17: "owner",
            18: "rank",
        },
        18,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            4: ProtocolBuffer.Encoder.NUMERIC,
            5: ProtocolBuffer.Encoder.STRING,
            13: ProtocolBuffer.Encoder.STRING,
            14: ProtocolBuffer.Encoder.STRING,
            15: ProtocolBuffer.Encoder.STRING,
            16: ProtocolBuffer.Encoder.STRING,
            17: ProtocolBuffer.Encoder.STRING,
            18: ProtocolBuffer.Encoder.NUMERIC,
        },
        18,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.EntityProto"


class CompositeProperty(ProtocolBuffer.ProtocolMessage):
    has_index_id_ = 0
    index_id_ = 0

    def __init__(self, contents=None):
        self.value_ = []
        if contents is not None:
            self.MergeFromString(contents)

    def index_id(self):
        return self.index_id_

    def set_index_id(self, x):
        self.has_index_id_ = 1
        self.index_id_ = x

    def clear_index_id(self):
        if self.has_index_id_:
            self.has_index_id_ = 0
            self.index_id_ = 0

    def has_index_id(self):
        return self.has_index_id_

    def value_size(self):
        return len(self.value_)

    def value_list(self):
        return self.value_

    def value(self, i):
        return self.value_[i]

    def set_value(self, i, x):
        self.value_[i] = x

    def add_value(self, x):
        self.value_.append(x)

    def clear_value(self):
        self.value_ = []

    def MergeFrom(self, x):
        assert x is not self
        if x.has_index_id():
            self.set_index_id(x.index_id())
        for i in range(x.value_size()):
            self.add_value(x.value(i))

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_index_id_ != x.has_index_id_:
            return 0
        if self.has_index_id_ and self.index_id_ != x.index_id_:
            return 0
        if len(self.value_) != len(x.value_):
            return 0
        for e1, e2 in zip(self.value_, x.value_):
            if e1 != e2:
                return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_index_id_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: index_id not set.")
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthVarInt64(self.index_id_)
        n += 1 * len(self.value_)
        for i in range(len(self.value_)):
            n += self.lengthString(len(self.value_[i]))
        return n + 1

    def ByteSizePartial(self):
        n = 0
        if self.has_index_id_:
            n += 1
            n += self.lengthVarInt64(self.index_id_)
        n += 1 * len(self.value_)
        for i in range(len(self.value_)):
            n += self.lengthString(len(self.value_[i]))
        return n

    def Clear(self):
        self.clear_index_id()
        self.clear_value()

    def OutputUnchecked(self, out):
        out.putVarInt32(8)
        out.putVarInt64(self.index_id_)
        for i in range(len(self.value_)):
            out.putVarInt32(18)
            out.putPrefixedString(self.value_[i])

    def OutputPartial(self, out):
        if self.has_index_id_:
            out.putVarInt32(8)
            out.putVarInt64(self.index_id_)
        for i in range(len(self.value_)):
            out.putVarInt32(18)
            out.putPrefixedString(self.value_[i])

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 8:
                self.set_index_id(d.getVarInt64())
                continue
            if tt == 18:
                self.add_value(d.getPrefixedString())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_index_id_:
            res += prefix + ("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
        cnt = 0
        for e in self.value_:
            elm = ""
            if printElemNumber:
                elm = "(%d)" % cnt
            res += prefix + ("value%s: %s\n" % (elm, self.DebugFormatString(e)))
            cnt += 1
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kindex_id = 1
    kvalue = 2

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "index_id",
            2: "value",
        },
        2,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.NUMERIC,
            2: ProtocolBuffer.Encoder.STRING,
        },
        2,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.CompositeProperty"


class Index_Property(ProtocolBuffer.ProtocolMessage):

    ASCENDING = 1
    DESCENDING = 2

    _Direction_NAMES = {
        1: "ASCENDING",
        2: "DESCENDING",
    }

    def Direction_Name(cls, x):
        return cls._Direction_NAMES.get(x, "")

    Direction_Name = classmethod(Direction_Name)

    has_name_ = 0
    name_ = ""
    has_direction_ = 0
    direction_ = 1

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def name(self):
        return self.name_

    def set_name(self, x):
        self.has_name_ = 1
        self.name_ = x

    def clear_name(self):
        if self.has_name_:
            self.has_name_ = 0
            self.name_ = ""

    def has_name(self):
        return self.has_name_

    def direction(self):
        return self.direction_

    def set_direction(self, x):
        self.has_direction_ = 1
        self.direction_ = x

    def clear_direction(self):
        if self.has_direction_:
            self.has_direction_ = 0
            self.direction_ = 1

    def has_direction(self):
        return self.has_direction_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_name():
            self.set_name(x.name())
        if x.has_direction():
            self.set_direction(x.direction())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_name_ != x.has_name_:
            return 0
        if self.has_name_ and self.name_ != x.name_:
            return 0
        if self.has_direction_ != x.has_direction_:
            return 0
        if self.has_direction_ and self.direction_ != x.direction_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_name_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: name not set.")
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.name_))
        if self.has_direction_:
            n += 1 + self.lengthVarInt64(self.direction_)
        return n + 1

    def ByteSizePartial(self):
        n = 0
        if self.has_name_:
            n += 1
            n += self.lengthString(len(self.name_))
        if self.has_direction_:
            n += 1 + self.lengthVarInt64(self.direction_)
        return n

    def Clear(self):
        self.clear_name()
        self.clear_direction()

    def OutputUnchecked(self, out):
        out.putVarInt32(26)
        out.putPrefixedString(self.name_)
        if self.has_direction_:
            out.putVarInt32(32)
            out.putVarInt32(self.direction_)

    def OutputPartial(self, out):
        if self.has_name_:
            out.putVarInt32(26)
            out.putPrefixedString(self.name_)
        if self.has_direction_:
            out.putVarInt32(32)
            out.putVarInt32(self.direction_)

    def TryMerge(self, d):
        while 1:
            tt = d.getVarInt32()
            if tt == 20:
                break
            if tt == 26:
                self.set_name(d.getPrefixedString())
                continue
            if tt == 32:
                self.set_direction(d.getVarInt32())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_name_:
            res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
        if self.has_direction_:
            res += prefix + ("direction: %s\n" % self.DebugFormatInt32(self.direction_))
        return res


class Index(ProtocolBuffer.ProtocolMessage):
    has_entity_type_ = 0
    entity_type_ = ""
    has_ancestor_ = 0
    ancestor_ = 0

    def __init__(self, contents=None):
        self.property_ = []
        if contents is not None:
            self.MergeFromString(contents)

    def entity_type(self):
        return self.entity_type_

    def set_entity_type(self, x):
        self.has_entity_type_ = 1
        self.entity_type_ = x

    def clear_entity_type(self):
        if self.has_entity_type_:
            self.has_entity_type_ = 0
            self.entity_type_ = ""

    def has_entity_type(self):
        return self.has_entity_type_

    def ancestor(self):
        return self.ancestor_

    def set_ancestor(self, x):
        self.has_ancestor_ = 1
        self.ancestor_ = x

    def clear_ancestor(self):
        if self.has_ancestor_:
            self.has_ancestor_ = 0
            self.ancestor_ = 0

    def has_ancestor(self):
        return self.has_ancestor_

    def property_size(self):
        return len(self.property_)

    def property_list(self):
        return self.property_

    def property(self, i):
        return self.property_[i]

    def mutable_property(self, i):
        return self.property_[i]

    def add_property(self):
        x = Index_Property()
        self.property_.append(x)
        return x

    def clear_property(self):
        self.property_ = []

    def MergeFrom(self, x):
        assert x is not self
        if x.has_entity_type():
            self.set_entity_type(x.entity_type())
        if x.has_ancestor():
            self.set_ancestor(x.ancestor())
        for i in range(x.property_size()):
            self.add_property().CopyFrom(x.property(i))

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_entity_type_ != x.has_entity_type_:
            return 0
        if self.has_entity_type_ and self.entity_type_ != x.entity_type_:
            return 0
        if self.has_ancestor_ != x.has_ancestor_:
            return 0
        if self.has_ancestor_ and self.ancestor_ != x.ancestor_:
            return 0
        if len(self.property_) != len(x.property_):
            return 0
        for e1, e2 in zip(self.property_, x.property_):
            if e1 != e2:
                return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_entity_type_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: entity_type not set.")
        if not self.has_ancestor_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: ancestor not set.")
        for p in self.property_:
            if not p.IsInitialized(debug_strs):
                initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.entity_type_))
        n += 2 * len(self.property_)
        for i in range(len(self.property_)):
            n += self.property_[i].ByteSize()
        return n + 3

    def ByteSizePartial(self):
        n = 0
        if self.has_entity_type_:
            n += 1
            n += self.lengthString(len(self.entity_type_))
        if self.has_ancestor_:
            n += 2
        n += 2 * len(self.property_)
        for i in range(len(self.property_)):
            n += self.property_[i].ByteSizePartial()
        return n

    def Clear(self):
        self.clear_entity_type()
        self.clear_ancestor()
        self.clear_property()

    def OutputUnchecked(self, out):
        out.putVarInt32(10)
        out.putPrefixedString(self.entity_type_)
        for i in range(len(self.property_)):
            out.putVarInt32(19)
            self.property_[i].OutputUnchecked(out)
            out.putVarInt32(20)
        out.putVarInt32(40)
        out.putBoolean(self.ancestor_)

    def OutputPartial(self, out):
        if self.has_entity_type_:
            out.putVarInt32(10)
            out.putPrefixedString(self.entity_type_)
        for i in range(len(self.property_)):
            out.putVarInt32(19)
            self.property_[i].OutputPartial(out)
            out.putVarInt32(20)
        if self.has_ancestor_:
            out.putVarInt32(40)
            out.putBoolean(self.ancestor_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                self.set_entity_type(d.getPrefixedString())
                continue
            if tt == 19:
                self.add_property().TryMerge(d)
                continue
            if tt == 40:
                self.set_ancestor(d.getBoolean())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_entity_type_:
            res += prefix + (
                "entity_type: %s\n" % self.DebugFormatString(self.entity_type_)
            )
        if self.has_ancestor_:
            res += prefix + ("ancestor: %s\n" % self.DebugFormatBool(self.ancestor_))
        cnt = 0
        for e in self.property_:
            elm = ""
            if printElemNumber:
                elm = "(%d)" % cnt
            res += prefix + ("Property%s {\n" % elm)
            res += e.__str__(prefix + "  ", printElemNumber)
            res += prefix + "}\n"
            cnt += 1
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kentity_type = 1
    kancestor = 5
    kPropertyGroup = 2
    kPropertyname = 3
    kPropertydirection = 4

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "entity_type",
            2: "Property",
            3: "name",
            4: "direction",
            5: "ancestor",
        },
        5,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STRING,
            2: ProtocolBuffer.Encoder.STARTGROUP,
            3: ProtocolBuffer.Encoder.STRING,
            4: ProtocolBuffer.Encoder.NUMERIC,
            5: ProtocolBuffer.Encoder.NUMERIC,
        },
        5,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Index"


class CompositeIndex(ProtocolBuffer.ProtocolMessage):

    WRITE_ONLY = 1
    READ_WRITE = 2
    DELETED = 3
    ERROR = 4

    _State_NAMES = {
        1: "WRITE_ONLY",
        2: "READ_WRITE",
        3: "DELETED",
        4: "ERROR",
    }

    def State_Name(cls, x):
        return cls._State_NAMES.get(x, "")

    State_Name = classmethod(State_Name)

    has_app_id_ = 0
    app_id_ = ""
    has_id_ = 0
    id_ = 0
    has_definition_ = 0
    has_state_ = 0
    state_ = 0
    has_only_use_if_required_ = 0
    only_use_if_required_ = 0

    def __init__(self, contents=None):
        self.definition_ = Index()
        if contents is not None:
            self.MergeFromString(contents)

    def app_id(self):
        return self.app_id_

    def set_app_id(self, x):
        self.has_app_id_ = 1
        self.app_id_ = x

    def clear_app_id(self):
        if self.has_app_id_:
            self.has_app_id_ = 0
            self.app_id_ = ""

    def has_app_id(self):
        return self.has_app_id_

    def id(self):
        return self.id_

    def set_id(self, x):
        self.has_id_ = 1
        self.id_ = x

    def clear_id(self):
        if self.has_id_:
            self.has_id_ = 0
            self.id_ = 0

    def has_id(self):
        return self.has_id_

    def definition(self):
        return self.definition_

    def mutable_definition(self):
        self.has_definition_ = 1
        return self.definition_

    def clear_definition(self):
        self.has_definition_ = 0
        self.definition_.Clear()

    def has_definition(self):
        return self.has_definition_

    def state(self):
        return self.state_

    def set_state(self, x):
        self.has_state_ = 1
        self.state_ = x

    def clear_state(self):
        if self.has_state_:
            self.has_state_ = 0
            self.state_ = 0

    def has_state(self):
        return self.has_state_

    def only_use_if_required(self):
        return self.only_use_if_required_

    def set_only_use_if_required(self, x):
        self.has_only_use_if_required_ = 1
        self.only_use_if_required_ = x

    def clear_only_use_if_required(self):
        if self.has_only_use_if_required_:
            self.has_only_use_if_required_ = 0
            self.only_use_if_required_ = 0

    def has_only_use_if_required(self):
        return self.has_only_use_if_required_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_app_id():
            self.set_app_id(x.app_id())
        if x.has_id():
            self.set_id(x.id())
        if x.has_definition():
            self.mutable_definition().MergeFrom(x.definition())
        if x.has_state():
            self.set_state(x.state())
        if x.has_only_use_if_required():
            self.set_only_use_if_required(x.only_use_if_required())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_app_id_ != x.has_app_id_:
            return 0
        if self.has_app_id_ and self.app_id_ != x.app_id_:
            return 0
        if self.has_id_ != x.has_id_:
            return 0
        if self.has_id_ and self.id_ != x.id_:
            return 0
        if self.has_definition_ != x.has_definition_:
            return 0
        if self.has_definition_ and self.definition_ != x.definition_:
            return 0
        if self.has_state_ != x.has_state_:
            return 0
        if self.has_state_ and self.state_ != x.state_:
            return 0
        if self.has_only_use_if_required_ != x.has_only_use_if_required_:
            return 0
        if (
            self.has_only_use_if_required_
            and self.only_use_if_required_ != x.only_use_if_required_
        ):
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_app_id_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: app_id not set.")
        if not self.has_id_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: id not set.")
        if not self.has_definition_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: definition not set.")
        elif not self.definition_.IsInitialized(debug_strs):
            initialized = 0
        if not self.has_state_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: state not set.")
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.app_id_))
        n += self.lengthVarInt64(self.id_)
        n += self.lengthString(self.definition_.ByteSize())
        n += self.lengthVarInt64(self.state_)
        if self.has_only_use_if_required_:
            n += 2
        return n + 4

    def ByteSizePartial(self):
        n = 0
        if self.has_app_id_:
            n += 1
            n += self.lengthString(len(self.app_id_))
        if self.has_id_:
            n += 1
            n += self.lengthVarInt64(self.id_)
        if self.has_definition_:
            n += 1
            n += self.lengthString(self.definition_.ByteSizePartial())
        if self.has_state_:
            n += 1
            n += self.lengthVarInt64(self.state_)
        if self.has_only_use_if_required_:
            n += 2
        return n

    def Clear(self):
        self.clear_app_id()
        self.clear_id()
        self.clear_definition()
        self.clear_state()
        self.clear_only_use_if_required()

    def OutputUnchecked(self, out):
        out.putVarInt32(10)
        out.putPrefixedString(self.app_id_)
        out.putVarInt32(16)
        out.putVarInt64(self.id_)
        out.putVarInt32(26)
        out.putVarInt32(self.definition_.ByteSize())
        self.definition_.OutputUnchecked(out)
        out.putVarInt32(32)
        out.putVarInt32(self.state_)
        if self.has_only_use_if_required_:
            out.putVarInt32(48)
            out.putBoolean(self.only_use_if_required_)

    def OutputPartial(self, out):
        if self.has_app_id_:
            out.putVarInt32(10)
            out.putPrefixedString(self.app_id_)
        if self.has_id_:
            out.putVarInt32(16)
            out.putVarInt64(self.id_)
        if self.has_definition_:
            out.putVarInt32(26)
            out.putVarInt32(self.definition_.ByteSizePartial())
            self.definition_.OutputPartial(out)
        if self.has_state_:
            out.putVarInt32(32)
            out.putVarInt32(self.state_)
        if self.has_only_use_if_required_:
            out.putVarInt32(48)
            out.putBoolean(self.only_use_if_required_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                self.set_app_id(d.getPrefixedString())
                continue
            if tt == 16:
                self.set_id(d.getVarInt64())
                continue
            if tt == 26:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_definition().TryMerge(tmp)
                continue
            if tt == 32:
                self.set_state(d.getVarInt32())
                continue
            if tt == 48:
                self.set_only_use_if_required(d.getBoolean())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_app_id_:
            res += prefix + ("app_id: %s\n" % self.DebugFormatString(self.app_id_))
        if self.has_id_:
            res += prefix + ("id: %s\n" % self.DebugFormatInt64(self.id_))
        if self.has_definition_:
            res += prefix + "definition <\n"
            res += self.definition_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_state_:
            res += prefix + ("state: %s\n" % self.DebugFormatInt32(self.state_))
        if self.has_only_use_if_required_:
            res += prefix + (
                "only_use_if_required: %s\n"
                % self.DebugFormatBool(self.only_use_if_required_)
            )
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kapp_id = 1
    kid = 2
    kdefinition = 3
    kstate = 4
    konly_use_if_required = 6

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "app_id",
            2: "id",
            3: "definition",
            4: "state",
            6: "only_use_if_required",
        },
        6,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STRING,
            2: ProtocolBuffer.Encoder.NUMERIC,
            3: ProtocolBuffer.Encoder.STRING,
            4: ProtocolBuffer.Encoder.NUMERIC,
            6: ProtocolBuffer.Encoder.NUMERIC,
        },
        6,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.CompositeIndex"


class IndexPostfix_IndexValue(ProtocolBuffer.ProtocolMessage):
    has_property_name_ = 0
    property_name_ = ""
    has_value_ = 0

    def __init__(self, contents=None):
        self.value_ = PropertyValue()
        if contents is not None:
            self.MergeFromString(contents)

    def property_name(self):
        return self.property_name_

    def set_property_name(self, x):
        self.has_property_name_ = 1
        self.property_name_ = x

    def clear_property_name(self):
        if self.has_property_name_:
            self.has_property_name_ = 0
            self.property_name_ = ""

    def has_property_name(self):
        return self.has_property_name_

    def value(self):
        return self.value_

    def mutable_value(self):
        self.has_value_ = 1
        return self.value_

    def clear_value(self):
        self.has_value_ = 0
        self.value_.Clear()

    def has_value(self):
        return self.has_value_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_property_name():
            self.set_property_name(x.property_name())
        if x.has_value():
            self.mutable_value().MergeFrom(x.value())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_property_name_ != x.has_property_name_:
            return 0
        if self.has_property_name_ and self.property_name_ != x.property_name_:
            return 0
        if self.has_value_ != x.has_value_:
            return 0
        if self.has_value_ and self.value_ != x.value_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if not self.has_property_name_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: property_name not set.")
        if not self.has_value_:
            initialized = 0
            if debug_strs is not None:
                debug_strs.append("Required field: value not set.")
        elif not self.value_.IsInitialized(debug_strs):
            initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.property_name_))
        n += self.lengthString(self.value_.ByteSize())
        return n + 2

    def ByteSizePartial(self):
        n = 0
        if self.has_property_name_:
            n += 1
            n += self.lengthString(len(self.property_name_))
        if self.has_value_:
            n += 1
            n += self.lengthString(self.value_.ByteSizePartial())
        return n

    def Clear(self):
        self.clear_property_name()
        self.clear_value()

    def OutputUnchecked(self, out):
        out.putVarInt32(10)
        out.putPrefixedString(self.property_name_)
        out.putVarInt32(18)
        out.putVarInt32(self.value_.ByteSize())
        self.value_.OutputUnchecked(out)

    def OutputPartial(self, out):
        if self.has_property_name_:
            out.putVarInt32(10)
            out.putPrefixedString(self.property_name_)
        if self.has_value_:
            out.putVarInt32(18)
            out.putVarInt32(self.value_.ByteSizePartial())
            self.value_.OutputPartial(out)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                self.set_property_name(d.getPrefixedString())
                continue
            if tt == 18:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_value().TryMerge(tmp)
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_property_name_:
            res += prefix + (
                "property_name: %s\n" % self.DebugFormatString(self.property_name_)
            )
        if self.has_value_:
            res += prefix + "value <\n"
            res += self.value_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kproperty_name = 1
    kvalue = 2

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "property_name",
            2: "value",
        },
        2,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STRING,
            2: ProtocolBuffer.Encoder.STRING,
        },
        2,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.IndexPostfix_IndexValue"


class IndexPostfix(ProtocolBuffer.ProtocolMessage):
    has_key_ = 0
    key_ = None
    has_before_ = 0
    before_ = 1

    def __init__(self, contents=None):
        self.index_value_ = []
        if contents is not None:
            self.MergeFromString(contents)

    def index_value_size(self):
        return len(self.index_value_)

    def index_value_list(self):
        return self.index_value_

    def index_value(self, i):
        return self.index_value_[i]

    def mutable_index_value(self, i):
        return self.index_value_[i]

    def add_index_value(self):
        x = IndexPostfix_IndexValue()
        self.index_value_.append(x)
        return x

    def clear_index_value(self):
        self.index_value_ = []

    def key(self):
        if self.key_ is None:
            self.key_ = Reference()
        return self.key_

    def mutable_key(self):
        self.has_key_ = 1
        return self.key()

    def clear_key(self):

        if self.has_key_:
            self.has_key_ = 0
            if self.key_ is not None:
                self.key_.Clear()

    def has_key(self):
        return self.has_key_

    def before(self):
        return self.before_

    def set_before(self, x):
        self.has_before_ = 1
        self.before_ = x

    def clear_before(self):
        if self.has_before_:
            self.has_before_ = 0
            self.before_ = 1

    def has_before(self):
        return self.has_before_

    def MergeFrom(self, x):
        assert x is not self
        for i in range(x.index_value_size()):
            self.add_index_value().CopyFrom(x.index_value(i))
        if x.has_key():
            self.mutable_key().MergeFrom(x.key())
        if x.has_before():
            self.set_before(x.before())

    def Equals(self, x):
        if x is self:
            return 1
        if len(self.index_value_) != len(x.index_value_):
            return 0
        for e1, e2 in zip(self.index_value_, x.index_value_):
            if e1 != e2:
                return 0
        if self.has_key_ != x.has_key_:
            return 0
        if self.has_key_ and self.key_ != x.key_:
            return 0
        if self.has_before_ != x.has_before_:
            return 0
        if self.has_before_ and self.before_ != x.before_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        for p in self.index_value_:
            if not p.IsInitialized(debug_strs):
                initialized = 0
        if self.has_key_ and not self.key_.IsInitialized(debug_strs):
            initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += 1 * len(self.index_value_)
        for i in range(len(self.index_value_)):
            n += self.lengthString(self.index_value_[i].ByteSize())
        if self.has_key_:
            n += 1 + self.lengthString(self.key_.ByteSize())
        if self.has_before_:
            n += 2
        return n

    def ByteSizePartial(self):
        n = 0
        n += 1 * len(self.index_value_)
        for i in range(len(self.index_value_)):
            n += self.lengthString(self.index_value_[i].ByteSizePartial())
        if self.has_key_:
            n += 1 + self.lengthString(self.key_.ByteSizePartial())
        if self.has_before_:
            n += 2
        return n

    def Clear(self):
        self.clear_index_value()
        self.clear_key()
        self.clear_before()

    def OutputUnchecked(self, out):
        for i in range(len(self.index_value_)):
            out.putVarInt32(10)
            out.putVarInt32(self.index_value_[i].ByteSize())
            self.index_value_[i].OutputUnchecked(out)
        if self.has_key_:
            out.putVarInt32(18)
            out.putVarInt32(self.key_.ByteSize())
            self.key_.OutputUnchecked(out)
        if self.has_before_:
            out.putVarInt32(24)
            out.putBoolean(self.before_)

    def OutputPartial(self, out):
        for i in range(len(self.index_value_)):
            out.putVarInt32(10)
            out.putVarInt32(self.index_value_[i].ByteSizePartial())
            self.index_value_[i].OutputPartial(out)
        if self.has_key_:
            out.putVarInt32(18)
            out.putVarInt32(self.key_.ByteSizePartial())
            self.key_.OutputPartial(out)
        if self.has_before_:
            out.putVarInt32(24)
            out.putBoolean(self.before_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.add_index_value().TryMerge(tmp)
                continue
            if tt == 18:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
                d.skip(length)
                self.mutable_key().TryMerge(tmp)
                continue
            if tt == 24:
                self.set_before(d.getBoolean())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        cnt = 0
        for e in self.index_value_:
            elm = ""
            if printElemNumber:
                elm = "(%d)" % cnt
            res += prefix + ("index_value%s <\n" % elm)
            res += e.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
            cnt += 1
        if self.has_key_:
            res += prefix + "key <\n"
            res += self.key_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_before_:
            res += prefix + ("before: %s\n" % self.DebugFormatBool(self.before_))
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kindex_value = 1
    kkey = 2
    kbefore = 3

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "index_value",
            2: "key",
            3: "before",
        },
        3,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STRING,
            2: ProtocolBuffer.Encoder.STRING,
            3: ProtocolBuffer.Encoder.NUMERIC,
        },
        3,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.IndexPostfix"


class IndexPosition(ProtocolBuffer.ProtocolMessage):
    has_key_ = 0
    key_ = ""
    has_before_ = 0
    before_ = 1

    def __init__(self, contents=None):
        if contents is not None:
            self.MergeFromString(contents)

    def key(self):
        return self.key_

    def set_key(self, x):
        self.has_key_ = 1
        self.key_ = x

    def clear_key(self):
        if self.has_key_:
            self.has_key_ = 0
            self.key_ = ""

    def has_key(self):
        return self.has_key_

    def before(self):
        return self.before_

    def set_before(self, x):
        self.has_before_ = 1
        self.before_ = x

    def clear_before(self):
        if self.has_before_:
            self.has_before_ = 0
            self.before_ = 1

    def has_before(self):
        return self.has_before_

    def MergeFrom(self, x):
        assert x is not self
        if x.has_key():
            self.set_key(x.key())
        if x.has_before():
            self.set_before(x.before())

    def Equals(self, x):
        if x is self:
            return 1
        if self.has_key_ != x.has_key_:
            return 0
        if self.has_key_ and self.key_ != x.key_:
            return 0
        if self.has_before_ != x.has_before_:
            return 0
        if self.has_before_ and self.before_ != x.before_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        return initialized

    def ByteSize(self):
        n = 0
        if self.has_key_:
            n += 1 + self.lengthString(len(self.key_))
        if self.has_before_:
            n += 2
        return n

    def ByteSizePartial(self):
        n = 0
        if self.has_key_:
            n += 1 + self.lengthString(len(self.key_))
        if self.has_before_:
            n += 2
        return n

    def Clear(self):
        self.clear_key()
        self.clear_before()

    def OutputUnchecked(self, out):
        if self.has_key_:
            out.putVarInt32(10)
            out.putPrefixedString(self.key_)
        if self.has_before_:
            out.putVarInt32(16)
            out.putBoolean(self.before_)

    def OutputPartial(self, out):
        if self.has_key_:
            out.putVarInt32(10)
            out.putPrefixedString(self.key_)
        if self.has_before_:
            out.putVarInt32(16)
            out.putBoolean(self.before_)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                self.set_key(d.getPrefixedString())
                continue
            if tt == 16:
                self.set_before(d.getBoolean())
                continue

            if tt == 0:
                raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_key_:
            res += prefix + ("key: %s\n" % self.DebugFormatString(self.key_))
        if self.has_before_:
            res += prefix + ("before: %s\n" % self.DebugFormatBool(self.before_))
        return res

    def _BuildTagLookupTable(sparse, maxtag, default=None):
        return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])

    kkey = 1
    kbefore = 2

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "key",
            2: "before",
        },
        2,
    )

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STRING,
            2: ProtocolBuffer.Encoder.NUMERIC,
        },
        2,
        ProtocolBuffer.Encoder.MAX_TYPE,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.IndexPosition"


if _extension_runtime:
    pass

__all__ = [
    "PropertyValue",
    "PropertyValue_ReferenceValuePathElement",
    "PropertyValue_PointValue",
    "PropertyValue_UserValue",
    "PropertyValue_ReferenceValue",
    "Property",
    "Path",
    "Path_Element",
    "Reference",
    "User",
    "EntityProto",
    "CompositeProperty",
    "Index",
    "Index_Property",
    "CompositeIndex",
    "IndexPostfix_IndexValue",
    "IndexPostfix",
    "IndexPosition",
]
