<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="freebase_v1.html">Freebase API</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="freebase_v1.text.html">text()</a></code>
</p>
<p class="firstline">Returns the text Resource.</p>

<p class="toc_element">
  <code><a href="freebase_v1.topic.html">topic()</a></code>
</p>
<p class="firstline">Returns the topic Resource.</p>

<p class="toc_element">
  <code><a href="#image">image(id, maxwidth=None, maxheight=None, fallbackid=None, pad=None, mode=None)</a></code></p>
<p class="firstline">Returns the scaled/cropped image attached to a freebase node.</p>
<p class="toc_element">
  <code><a href="#image_media">image_media(id, maxwidth=None, maxheight=None, fallbackid=None, pad=None, mode=None)</a></code></p>
<p class="firstline">Returns the scaled/cropped image attached to a freebase node.</p>
<p class="toc_element">
  <code><a href="#mqlread">mqlread(query, lang=None, indent=None, callback=None, uniqueness_failure=None, dateline=None, html_escape=None, cursor=None, cost=None, as_of_time=None)</a></code></p>
<p class="firstline">Performs MQL Queries.</p>
<p class="toc_element">
  <code><a href="#mqlread_media">mqlread_media(query, lang=None, indent=None, callback=None, uniqueness_failure=None, dateline=None, html_escape=None, cursor=None, cost=None, as_of_time=None)</a></code></p>
<p class="firstline">Performs MQL Queries.</p>
<p class="toc_element">
  <code><a href="#mqlwrite">mqlwrite(query, indent=None, callback=None, dateline=None, use_permission_of=None)</a></code></p>
<p class="firstline">Performs MQL Write Operations.</p>
<p class="toc_element">
  <code><a href="#mqlwrite_media">mqlwrite_media(query, indent=None, callback=None, dateline=None, use_permission_of=None)</a></code></p>
<p class="firstline">Performs MQL Write Operations.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="image">image(id, maxwidth=None, maxheight=None, fallbackid=None, pad=None, mode=None)</code>
  <pre>Returns the scaled/cropped image attached to a freebase node.

Args:
  id: string, Freebase entity or content id, mid, or guid. (required) (repeated)
  maxwidth: integer, Maximum width in pixels for resulting image.
  maxheight: integer, Maximum height in pixels for resulting image.
  fallbackid: string, Use the image associated with this secondary id if no image is associated with the primary id.
  pad: boolean, A boolean specifying whether the resulting image should be padded up to the requested dimensions.
  mode: string, Method used to scale or crop image.
    Allowed values
      fill - Fill rectangle completely with image, relax constraint on one dimension if necessary.
      fillcrop - Fill rectangle with image, crop image to maintain rectangle dimensions.
      fillcropmid - Fill rectangle with image, center horizontally, crop left and right.
      fit - Fit image inside rectangle, leave empty space in one dimension if necessary.
</pre>
</div>

<div class="method">
    <code class="details" id="image_media">image_media(id, maxwidth=None, maxheight=None, fallbackid=None, pad=None, mode=None)</code>
  <pre>Returns the scaled/cropped image attached to a freebase node.

Args:
  id: string, Freebase entity or content id, mid, or guid. (required) (repeated)
  maxwidth: integer, Maximum width in pixels for resulting image.
  maxheight: integer, Maximum height in pixels for resulting image.
  fallbackid: string, Use the image associated with this secondary id if no image is associated with the primary id.
  pad: boolean, A boolean specifying whether the resulting image should be padded up to the requested dimensions.
  mode: string, Method used to scale or crop image.
    Allowed values
      fill - Fill rectangle completely with image, relax constraint on one dimension if necessary.
      fillcrop - Fill rectangle with image, crop image to maintain rectangle dimensions.
      fillcropmid - Fill rectangle with image, center horizontally, crop left and right.
      fit - Fit image inside rectangle, leave empty space in one dimension if necessary.
</pre>
</div>

<div class="method">
    <code class="details" id="mqlread">mqlread(query, lang=None, indent=None, callback=None, uniqueness_failure=None, dateline=None, html_escape=None, cursor=None, cost=None, as_of_time=None)</code>
  <pre>Performs MQL Queries.

Args:
  query: string, An envelope containing a single MQL query. (required)
  lang: string, The language of the results - an id of a /type/lang object.
  indent: integer, How many spaces to indent the json.
  callback: string, JS method name for JSONP callbacks.
  uniqueness_failure: string, How MQL responds to uniqueness failures.
    Allowed values
      hard - Be strict - throw an error.
      soft - Just return the first encountered object.
  dateline: string, The dateline that you get in a mqlwrite response to ensure consistent results.
  html_escape: boolean, Whether or not to escape entities.
  cursor: string, The mql cursor.
  cost: boolean, Show the costs or not.
  as_of_time: string, Run the query as it would've been run at the specified point in time.
</pre>
</div>

<div class="method">
    <code class="details" id="mqlread_media">mqlread_media(query, lang=None, indent=None, callback=None, uniqueness_failure=None, dateline=None, html_escape=None, cursor=None, cost=None, as_of_time=None)</code>
  <pre>Performs MQL Queries.

Args:
  query: string, An envelope containing a single MQL query. (required)
  lang: string, The language of the results - an id of a /type/lang object.
  indent: integer, How many spaces to indent the json.
  callback: string, JS method name for JSONP callbacks.
  uniqueness_failure: string, How MQL responds to uniqueness failures.
    Allowed values
      hard - Be strict - throw an error.
      soft - Just return the first encountered object.
  dateline: string, The dateline that you get in a mqlwrite response to ensure consistent results.
  html_escape: boolean, Whether or not to escape entities.
  cursor: string, The mql cursor.
  cost: boolean, Show the costs or not.
  as_of_time: string, Run the query as it would've been run at the specified point in time.
</pre>
</div>

<div class="method">
    <code class="details" id="mqlwrite">mqlwrite(query, indent=None, callback=None, dateline=None, use_permission_of=None)</code>
  <pre>Performs MQL Write Operations.

Args:
  query: string, An MQL query with write directives. (required)
  indent: integer, How many spaces to indent the json.
  callback: string, JS method name for JSONP callbacks.
  dateline: string, The dateline that you get in a mqlwrite response to ensure consistent results.
  use_permission_of: string, Use the same permission node of the object with the specified id.
</pre>
</div>

<div class="method">
    <code class="details" id="mqlwrite_media">mqlwrite_media(query, indent=None, callback=None, dateline=None, use_permission_of=None)</code>
  <pre>Performs MQL Write Operations.

Args:
  query: string, An MQL query with write directives. (required)
  indent: integer, How many spaces to indent the json.
  callback: string, JS method name for JSONP callbacks.
  dateline: string, The dateline that you get in a mqlwrite response to ensure consistent results.
  use_permission_of: string, Use the same permission node of the object with the specified id.
</pre>
</div>

</body></html>