@name Record.getDetails

@description Update the flavor details for this instance

@param {Function}    callback    handles the callback of your api call
503794
function(callback) {
        var self = this;
            this.domain.getRecord(this.id, function(err, record) {
            if (err) {
                callback(err);
                return;
            }

            self._setProperties(record);
            callback(null, self);
        });
    }
340003
async def detail(self, **kwargs):
        '''
        
        '''
        try:
            pk = self.pk_type(kwargs.get('pk'))
            obj = await self._meta.object_class.find_one(self.db, {self.pk: pk})
            if obj:
                return await obj.serialize()
            raise NotFound('Object matching the given {} with value {} was not found'.format(self.pk, str(pk)))
        except InvalidId:
            raise NotFound('Invalid ID')
1103341
function _treatEntityDetail(fieldErrors) {
    return Object.keys(fieldErrors || {}).reduce(
        (res, field) => {
            res[field] = translate(fieldErrors[field]);
            return res;
        }, {});
}
761819
function (appid) {
    return this.get('/appuserdetails', {
      // 'cc': this.options.country,
      // 'l': this.options.language,
      'v': 1,
      'appids': appid
    }).then(function (body) {
      console.log('appUserDetails - ', body)
      return Promise.resolve(body);
    });
  }
566214
function (details, callback) {
    var self = this;

    if (typeof(details) === 'function') {
      callback = details;
      details = {};
    }

    var requestOptions = {
      path: _urlPrefix
    };

    requestOptions.qs = _.pick(details,
      'name');

    return self._request(requestOptions, function (err, body, res) {
      return err
        ? callback(err)
        : callback(null, body.domains.map(function (result) {
        return new dns.Zone(self, result);
      }), res);
    });
  }
205472
function getAccountDetail (queryOptions, { accountId, key, writerId }) {
  return sendQuery(
    queryOptions,
    queryHelper.addQuery(
      queryHelper.emptyQuery(),
      'getAccountDetail',
      {
        accountId
      }
    ),
    (resolve, reject, responseName, response) => {
      if (responseName !== 'ACCOUNT_DETAIL_RESPONSE') {
        const error = JSON.stringify(response.toObject().errorResponse)
        return reject(new Error(`Query response error: expected=ACCOUNT_DETAIL_RESPONSE, actual=${responseName}\nReason: ${error}`))
      }

      const transactions = JSON.parse(response.getAccountDetailResponse().toObject().detail)
      resolve(transactions)
    }
  )
}
1227590
function(details) {
        var self = this;

        this.id = details.id;
        this.name = details.name;
        this.port = details.port;
        this.protocol = details.protocol;
        this.nodeCount = details.nodeCount;
        this.algorithm = details.algorithm;
        this.status = details.status;
        this.timeout = details.timeout;
        this.cluster = details.cluster;
        this.created = details.created;
        this.updated = details.updated;
        this.connectionLogging = details.connectionLogging;
        this.sourceAddresses = details.sourceAddresses;
        this.connectionThrottle = details.connectionThrottle;
        this.sessionPersistence = details.sessionPersistence;

        self._populateNodes(details.nodes);
        self._populateVirtualIps(details.virtualIps);
    }
37539
public final void setEntryDetailsCallback(Callback<EntryDetailsParameter, Boolean> callback) {
        requireNonNull(callback);
        entryDetailsCallbackProperty().set(callback);
    }
876127
private void deliverWaveformDetailUpdate(final int player, final WaveformDetail detail) {
        if (!getWaveformListeners().isEmpty()) {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    final WaveformDetailUpdate update = new WaveformDetailUpdate(player, detail);
                    for (final WaveformListener listener : getWaveformListeners()) {
                        try {
                            listener.detailChanged(update);

                        } catch (Throwable t) {
                            logger.warn("Problem delivering waveform detail update to listener", t);
                        }
                    }
                }
            });
        }
    }
939043
async function fetchDetails(id, fetch, gAuthKey) {
  try {
    const res = await fetch(
      `https://www.googleapis.com/youtube/v3/videos?id=${id}&key=${gAuthKey}&part=snippet,statistics`
    )
    const data = await res.json()
    return data.items[0]
  } catch (e) {
    console.log(e)
    return {}
  }
}
325656
public JobExecutionStatusDetails withDetailsMap(java.util.Map<String, String> detailsMap) {
        setDetailsMap(detailsMap);
        return this;
    }
142276
function(callback)
    {
        var params = util.extend({count:1}, this.params);        
        this.api.doRequest("GET", this.path, params, function(err, res) {
            if (err)
            {
                return callback(err);
            }                    
            callback(null, res.count);
        });
    }
802760
function getKeyDetailsString (key, redisConnection, data, next) {
  redisConnection.get(key, function (err, val) {
    if (err) {
      api.log('getRedisString: ' + err, 'error');
    }

    var details = {
      key: key,
      type: 'string',
      value: val
    };
    
    data.response.details = details;
    next();
  });
}
109553
function fetchDetails(event) {
    var filename = event.filename || event.target && event.target.src;
    if (scriptPromises[filename]) {

      /* Only process this once... */
      if (event.stopPropagation) event.stopPropagation();
      if (event.preventDefault) event.preventDefault();

      /* Try to zap the <script /> element */
      if (event.target && event.target.parentNode) try {
        event.target.parentNode.removeChild(event.target);
      } catch (error) {
        // This might have never slapped in the DOM
      }

      /* Wipe-and-return... */
      var promise = scriptPromises[filename];
      delete scriptPromises[filename];
      promise.remaining -= 1; // decrement!
      return { script: filename, promise: promise };
    }
  }
280181
public void showDetails(final ActionEvent event) {
		// Track down the data associated with this event.
		MyData data = (MyData) event.getActionObject();

		displayDialog.setData(data);
		dialog.display();
	}
781225
function populateOriginalKeyDetails (json, originalKey) {
  const properties = [
    'id',
    'name'
  ]

  properties
    .filter(jsonProp => !json.hasOwnProperty(jsonProp))
    .forEach(jsonProp => {
      json[jsonProp] = originalKey
    })
}
79244
function updateWithInfo(info) {
  var disableOverlay = document.querySelector('.disableOverlay');
  var stopRecordingButton = document.querySelector('.buttonStopRecording');

  var status = info.status;
  switch (status) {
    case 'instrumented':
      // Instrumentation is enabled for the page.
      disableOverlay.style.display = '';
      stopRecordingButton.innerText = 'Stop Recording';
      break;
    case 'whitelisted':
      // Tracing is enabled for the page.
      disableOverlay.style.display = '';
      stopRecordingButton.innerText = 'Stop Recording For This URL';
      break;
    default:
      // Tracing is disabled for the page.
      disableOverlay.style.display = 'none';
      stopRecordingButton.innerText = '';
      break;
  }

  buildAddonTable(info.all_addons, info.options['wtf.addons']);
}