docs: function method (methodName, method, options) {
      // require valid name
      requireValidName(methodName)
      // if method is not defined return existing method if any
      if (!defined(method)) {
          return this[methodName]
      }
      // make sure options is object
      options = requireValidOptionalObject(options)
      // use allow override value from options if set, otherwise use module
      var allowOverride = defined(options.allowOverride)
          ? options.allowOverride
          : this.meta.options.allowOverride
      // throw exception if method already defined
      this.assert(allowOverride || !defined(this[methodName]), `method ${methodName} already defined`)
      // require function
      this.assert(typeof method === 'function', `function required for ${methodName}`)
      // create meta data entry for function
      var methodMeta = {
          // ajv json schema validator instance
          ajv: defined(options.ajv) ? options.ajv : this.meta.options.ajv,
          // automock function
          automock: defined(options.automock) ? options.automock : this.meta.options.automock,
          // freeze args and return values
          freeze: defined(options.freeze) ? !!options.freeze : this.meta.options.freeze,
          // enable Immutable AI
          immutableAI: defined(options.immutableAI) ? options.immutableAI : this.meta.options.immutableAI,
          // set logging client using either method options or module options
          logClient: defined(options.logClient) ? options.logClient : this.meta.options.logClient,
          // original method function
          method: method,
          // method name
          methodName: methodName,
          // module name
          moduleName: this.meta.name,
          // resolve promises in args and return values
          resolve: defined(options.resolve) ? !!options.resolve : this.meta.options.resolve,
          // json schema
          schema: defined(options.schema) ? options.schema : {},
          // method signature - ModuleName.methodName
          signature: `${this.meta.name}.${methodName}`,
          // strict mode for args only - do not require return to be promise
          strictArgs: options.strictArgs !== undefined ? options.strictArgs : this.meta.options.strictArgs,
          // allow arg validation to be disabled
          validateArgs: defined(options.validateArgs) ? !!options.validateArgs : this.meta.options.validateArgs,
          // allow return validation to be disabled
          validateReturn: defined(options.validateReturn) ? !!options.validateReturn : this.meta.options.validateReturn,
      }
      // get schema
      var schema = methodMeta.schema
      // intialize args schema
      if (defined(schema.args)) {
          // create unique schema id
          schema.args.id = `/module/${this.meta.name}/${methodName}/args`
          // default schema type to object
          if (!defined(schema.args.type)) {
              schema.args.type = 'object'
          }
          // add schema to validator
          methodMeta.ajv.addSchema(schema.args, schema.args.id)
      }
      // intialize return schema
      if (defined(schema.return)) {
          // create unique schema id
          schema.return.id = `/module/${this.meta.name}/${methodName}/return`
          // default schema type to object
          if (!defined(schema.return.type)) {
              schema.return.type = 'object'
          }
          // add schema to validator
          methodMeta.ajv.addSchema(schema.return, schema.return.id)
      }
      // create wrapper function
      this[methodName] = methodMeta.automock
          // wrap method with automock if set
          ? methodMeta.automock( createMethodWrapperFunction(this.meta, methodMeta) )
          // create regular method with no mock
          : createMethodWrapperFunction(this.meta, methodMeta)
      // return method function
      return this[methodName]
  }