text: /**
   * Constructs a new Namespace.
   * @exports ProtoBuf.Reflect.Namespace
   * @param {!ProtoBuf.Builder} builder Builder reference
   * @param {?ProtoBuf.Reflect.Namespace} parent Namespace parent
   * @param {string} name Namespace name
   * @param {Object.<string,*>=} options Namespace options
   * @param {string?} syntax The syntax level of this definition (e.g., proto3)
   * @constructor
   * @extends ProtoBuf.Reflect.T
   */
  var Namespace = function(builder, parent, name, options, syntax) {
      T.call(this, builder, parent, name);
  
      /**
       * @override
       */
      this.className = "Namespace";
  
      /**
       * Children inside the namespace.
       * @type {!Array.<ProtoBuf.Reflect.T>}
       */
      this.children = [];
  
      /**
       * Options.
       * @type {!Object.<string, *>}
       */
      this.options = options || {};
  
      /**
       * Syntax level (e.g., proto2 or proto3).
       * @type {!string}
       */
      this.syntax = syntax || "proto2";
  };
  
  /**
   * @alias ProtoBuf.Reflect.Namespace.prototype
   * @inner
   */
  var NamespacePrototype = Namespace.prototype = Object.create(T.prototype);
  
  /**
   * Returns an array of the namespace's children.
   * @param {ProtoBuf.Reflect.T=} type Filter type (returns instances of this type only). Defaults to null (all children).
   * @return {Array.<ProtoBuf.Reflect.T>}
   * @expose
   */
  NamespacePrototype.getChildren = function(type) {
      type = type || null;
      if (type == null)
          return this.children.slice();
      var children = [];
      for (var i=0, k=this.children.length; i<k; ++i)
          if (this.children[i] instanceof type)
              children.push(this.children[i]);
      return children;
  };
  
  /**
   * Adds a child to the namespace.
   * @param {ProtoBuf.Reflect.T} child Child
   * @throws {Error} If the child cannot be added (duplicate)
   * @expose
   */
  NamespacePrototype.addChild = function(child) {
      var other;
      if (other = this.getChild(child.name)) {
          // Try to revert camelcase transformation on collision
          if (other instanceof Message.Field && other.name !== other.originalName && this.getChild(other.originalName) === null)
              other.name = other.originalName; // Revert previous first (effectively keeps both originals)
          else if (child instanceof Message.Field && child.name !== child.originalName && this.getChild(child.originalName) === null)
              child.name = child.originalName;
          else
              throw Error("Duplicate name in namespace "+this.toString(true)+": "+child.name);
      }
      this.children.push(child);
  };
  
  /**
   * Gets a child by its name or id.
   * @param {string|number} nameOrId Child name or id
   * @return {?ProtoBuf.Reflect.T} The child or null if not found
   * @expose
   */
  NamespacePrototype.getChild = function(nameOrId) {
      var key = typeof nameOrId === 'number' ? 'id' : 'name';
      for (var i=0, k=this.children.length; i<k; ++i)
          if (this.children[i][key] === nameOrId)
              return this.children[i];
      return null;
  };
  
  /**
   * Resolves a reflect object inside of this namespace.
   * @param {string|!Array.<string>} qn Qualified name to resolve
   * @param {boolean=} excludeNonNamespace Excludes non-namespace types, defaults to `false`
   * @return {?ProtoBuf.Reflect.Namespace} The resolved type or null if not found
   * @expose
   */
  NamespacePrototype.resolve = function(qn, excludeNonNamespace) {
      var part = typeof qn === 'string' ? qn.split(".") : qn,
          ptr = this,
          i = 0;
      if (part[i] === "") { // Fully qualified name, e.g. ".My.Message'
          while (ptr.parent !== null)
              ptr = ptr.parent;
          i++;
      }
      var child;
      do {
          do {
              if (!(ptr instanceof Reflect.Namespace)) {
                  ptr = null;
                  break;
              }
              child = ptr.getChild(part[i]);
              if (!child || !(child instanceof Reflect.T) || (excludeNonNamespace && !(child instanceof Reflect.Namespace))) {
                  ptr = null;
                  break;
              }
              ptr = child; i++;
          } while (i < part.length);
          if (ptr != null)
              break; // Found
          // Else search the parent
          if (this.parent !== null)
              return this.parent.resolve(qn, excludeNonNamespace);
      } while (ptr != null);
      return ptr;
  };
  
  /**
   * Determines the shortest qualified name of the specified type, if any, relative to this namespace.
   * @param {!ProtoBuf.Reflect.T} t Reflection type
   * @returns {string} The shortest qualified name or, if there is none, the fqn
   * @expose
   */
  NamespacePrototype.qn = function(t) {
      var part = [], ptr = t;
      do {
          part.unshift(ptr.name);
          ptr = ptr.parent;
      } while (ptr !== null);
      for (var len=1; len <= part.length; len++) {
          var qn = part.slice(part.length-len);
          if (t === this.resolve(qn, t instanceof Reflect.Namespace))
              return qn.join(".");
      }
      return t.fqn();
  };
  
  /**
   * Builds the namespace and returns the runtime counterpart.
   * @return {Object.<string,Function|Object>} Runtime namespace
   * @expose
   */
  NamespacePrototype.build = function() {
      /** @dict */
      var ns = {};
      var children = this.children;
      for (var i=0, k=children.length, child; i<k; ++i) {
          child = children[i];
          if (child instanceof Namespace)
              ns[child.name] = child.build();
      }
      if (Object.defineProperty)
          Object.defineProperty(ns, "$options", { "value": this.buildOpt() });
      return ns;
  };
  
  /**
   * Builds the namespace's '$options' property.
   * @return {Object.<string,*>}
   */
  NamespacePrototype.buildOpt = function() {
      var opt = {},
          keys = Object.keys(this.options);
      for (var i=0, k=keys.length; i<k; ++i) {
          var key = keys[i],
              val = this.options[keys[i]];
          // TODO: Options are not resolved, yet.
          // if (val instanceof Namespace) {
          //     opt[key] = val.build();
          // } else {
          opt[key] = val;
          // }
      }
      return opt;
  };
  
  /**
   * Gets the value assigned to the option with the specified name.
   * @param {string=} name Returns the option value if specified, otherwise all options are returned.
   * @return {*|Object.<string,*>}null} Option value or NULL if there is no such option
   */
  NamespacePrototype.getOption = function(name) {
      if (typeof name === 'undefined')
          return this.options;
      return typeof this.options[name] !== 'undefined' ? this.options[name] : null;
  };
  