           (signature Function)
           (signature Object, Function)
         ]
-        createRole:
-          (signature Object, Function)
         updatePermissions:
           (signature Object, Function)
         fetchAdmins: [

        return callback err if err
        return callback null, channel.id

  # _fetchSubscription: (callback) ->
  #   @fetchSubscription (err, subscription) =>
  #     return callback new KodingError "Error when fetching group's subscription: #{err}"  if err
  #     return callback new KodingError "Group #{@slug}'s subscription is not found"  unless subscription
  #     callback err, subscription

  # debitPack: (options, callback) ->
  #   @_fetchSubscription (err, subscription) ->
  #     return callback err  if err
  #     subscription.debitPack options, callback

  # creditPack: (options, callback) ->
  #   @_fetchSubscription (err, subscription) ->
  #     return callback err  if err
  #     subscription.creditPack options, callback

  # linkPaymentMethod: permit 'manage payment methods',
  #   success: (client, paymentMethodId, callback) ->
  #     { delegate } = client.connection
  #     JPaymentMethod = require '../payment/method'
  #     JPaymentMethod.one { paymentMethodId }, (err, paymentMethod) =>
  #       return callback err  if err
  #       delegate.hasTarget paymentMethod, 'payment method', (err, hasTarget) =>
  #         return callback err  if err
  #         return callback { message: 'Access denied!' }  unless hasTarget
  #         @addPaymentMethod paymentMethod, callback

  # unlinkPaymentMethod: permit 'manage payment methods',
  #   success: (client, paymentMethodId, callback) ->
  #     JPaymentMethod = require '../payment/method'
  #     JPaymentMethod.one { paymentMethodId }, (err, paymentMethod) =>
  #       return callback err  if err
  #       @removePaymentMethod paymentMethod, callback

  # fetchPaymentMethod$: permit 'manage payment methods',
  #   success: (client, callback) ->
  #     JPaymentMethod = require '../payment/method'
  #     @fetchPaymentMethod (err, paymentMethod) ->
  #       return callback err  if err
  #       JPaymentMethod.decoratePaymentMethods [paymentMethod], (err, paymentMethods) ->
  #         return callback err  if err
  #         callback null, paymentMethods[0]

  # fetchProducts$: (category, options, callback) ->
  #   [options, callback] = [callback, options]  unless callback
  #   options ?= {}
  #   { tag, tags } = options
  #   tags = [tag]  if tag and not tags

  #   options.targetOptions ?= {}
  #   options.targetOptions.options ?= {}
  #   options.targetOptions.options.sort ?= sortWeight: 1
  #   options.targetOptions.selector =
  #     if tags
  #     then { tags }
  #     else {}

  #   switch category
  #     when 'product'
  #       @fetchProducts {}, options, callback
  #     when 'pack'
  #       @fetchPacks {}, options, callback
  #     when 'plan'
  #       @fetchPlans {}, options, callback


  # fetchInvitationsFromGraph: permit 'send invitations',
  #   success: (client, type, options, callback)->
  #     @fetchOrCountInvitations client, type, 'fetch', options, (err, results)=>
  #       return callback err  if err
  #       ids = (res.groupOwnedNodes.data.id  for res in results)

  #       require(
  #         if type is 'InvitationRequest'
  #         then '../invitationrequest'
  #         else '../invitation'
  #       ).some _id: $in: ids, {}, callback

  # countInvitationsFromGraph: permit 'send invitations',
  #   success: (client, type, options, callback)->
  #     @fetchOrCountInvitations client, type, 'count', options, (err, result)=>
  #       return callback err, result?[0]?.count

  # fetchMembersFromGraph:(client, options, callback)->
  #   return callback {message: "unimplemented feature"}

  # fetchMembersFromGraph$: permit 'list members',
  #   success: (client, rest...) -> @fetchMembersFromGraph client, rest...
  #

  # fetchOrCreateBundle: (callback) ->
  #   @fetchBundle (err, bundle) =>
  #     return callback err, bundle  if err or bundle

  #     if @slug is 'koding'
  #       @createBundle
  #         overagePolicy: 'not allowed'
  #         paymentPlan  : ''
  #         allocation   : 0
  #         sharedVM     : yes
  #       , (err, bundle) =>
  #         if err then return callback new KodingError 'Unable to create default group bundle'
  #         callback null, bundle
  #     else
  #       callback new KodingError 'Unable to fetch group bundle'

  # fetchNewestMembers$: permit 'list members',
  #   success:(client, rest...)->
  #     [selector, options, callback] = Module.limitEdges 10, 19, rest
  #     selector            or= {}
  #     selector.as         = 'member'
  #     selector.sourceName = 'JGroup'
  #     selector.sourceId   = @getId()
  #     selector.targetName = 'JAccount'

  #     options             or= {}
  #     options.sort        or=
  #       timestamp         : -1
  #     options.limit       or= 16

  #     Relationship.some selector, options, (err,members)=>
  #       if err then callback err
  #       else
  #         targetIds = (member.targetId for member in members)
  #         JAccount = require '../account'
  #         JAccount.some
  #           _id   :
  #             $in : targetIds
  #         , {}, (err,memberAccounts)=>
  #           callback err,memberAccounts

  # fetchSubscription$: secure (client, callback) ->
  #   @fetchSubscription (err, subscription) ->
  #     return callback err  if err
  #     {planCode} = subscription
  #     JPaymentPlan = require '../payment/plan'
  #     JPaymentPlan.one {planCode}, (err, plan) ->
  #       return callback err  if err
  #       subscription.plan = plan
  #       callback null, subscription

  # redeemInvitation: secure (client, code, callback)->
  #   {delegate} = client.connection
  #   @isMember delegate, (err, isMember)=>
  #     return callback err  if err or isMember
  #     selector = targetOptions: selector: {code, status:$in:['active', 'sent']}
  #     @fetchInvitations {}, selector, (err, [invite])=>
  #       return callback err  if err
  #       return callback new KodingError 'Invitation code is invalid!'  unless invite
  #       delegate.fetchUser (err, user)=>
  #         return callback err  if err
  #         unless invite.type is 'multiuse' or user.email is invite.email
  #           return callback new KodingError 'Are you sure invitation e-mail is for you?'

  #         invite.redeem delegate, (err) =>
  #           return callback err if err
  #           @approveMember delegate, callback

          (signature String, Function)
        transferOwnership:
          (signature String, Function)
        remove:
          (signature Function)
        makePayment:
          (signature Object, Function)
        addSubscription:
          (signature String, Function)
        fetchSubscription:
