docs: function removeMetaRule(webgmeToken, parameters, callback) {
          var storage,
              context,
              node,
              finish = function (err, result) {
                  if (err) {
                      err = err instanceof Error ? err : new Error(err);
                      logger.error('removeMetaRule failed with error', err);
                  } else {
                      logger.debug('removeMetaRule completed');
                  }
  
                  if (storage) {
                      storage.close(function (closeErr) {
                          callback(err || closeErr, result);
                      });
                  } else {
                      callback(err, result);
                  }
              };
  
          getConnectedStorage(webgmeToken)
              .then(function (storage_) {
                  storage = storage_;
                  storage.addEventListener(storage.CONSTANTS.NETWORK_STATUS_CHANGED,
                      getNetworkStatusChangeHandler(finish));
                  return _getCoreAndRootNode(storage, parameters.projectId, parameters.commitHash,
                      parameters.branchName, parameters.tagName);
              })
              .then(function (context_) {
                  context = context_;
                  return context.core.loadByPath(context.rootNode, parameters.nodePath);
              })
              .then(function (node_) {
                  node = node_;
                  switch (parameters.type) {
                      case 'attribute':
                          context.core.delAttributeMeta(node, parameters.name);
                          break;
                      case 'pointer':
                      case 'set':
                          context.core.delPointerMetaTarget(node, parameters.name, parameters.targetPath);
                          if (context.core.getValidTargetPaths(node, parameters.name).length === 0) {
                              context.core.delPointerMeta(node, parameters.name);
                          }
                          break;
                      case 'containment':
                          context.core.delChildMeta(node, parameters.targetPath);
                          break;
                      case 'aspect':
                          if (typeof parameters.targetPath === 'string') {
                              context.core.delAspectMetaTarget(node, parameters.name, parameters.targetPath);
                          }
  
                          if (typeof parameters.targetPath !== 'string') {
                              context.core.delAspectMeta(node, parameters.name);
                          }
                  }
  
                  return metaRename.propagateMetaDefinitionRemove(context.core, node, parameters);
              })
              .then(function () {
                  var persisted;
  
                  persisted = context.core.persist(context.rootNode);
  
                  context.project.makeCommit(
                      parameters.branchName,
                      [context.commitObject._id],
                      persisted.rootHash,
                      persisted.objects,
                      'remove meta definition [' + parameters.name + '] of [' + parameters.nodePath + ']');
              })
              .nodeify(finish);
      }