<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="factchecktools_v1alpha1.html">Fact Check Tools API</a> . <a href="factchecktools_v1alpha1.pages.html">pages</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#close">close()</a></code></p>
<p class="firstline">Close httplib2 connections.</p>
<p class="toc_element">
  <code><a href="#create">create(body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Create `ClaimReview` markup on a page.</p>
<p class="toc_element">
  <code><a href="#delete">delete(name, x__xgafv=None)</a></code></p>
<p class="firstline">Delete all `ClaimReview` markup on a page.</p>
<p class="toc_element">
  <code><a href="#get">get(name, x__xgafv=None)</a></code></p>
<p class="firstline">Get all `ClaimReview` markup on a page.</p>
<p class="toc_element">
  <code><a href="#list">list(organization=None, url=None, offset=None, pageToken=None, pageSize=None, x__xgafv=None)</a></code></p>
<p class="firstline">List the `ClaimReview` markup pages for a specific URL or for an organization.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#update">update(name, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Update for all `ClaimReview` markup on a page Note that this is a full update. To retain the existing `ClaimReview` markup on a page, first perform a Get operation, then modify the returned markup, and finally call Update with the entire `ClaimReview` markup as the body.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="close">close()</code>
  <pre>Close httplib2 connections.</pre>
</div>

<div class="method">
    <code class="details" id="create">create(body=None, x__xgafv=None)</code>
  <pre>Create `ClaimReview` markup on a page.

Args:
  body: object, The request body.
    The object takes the form of:

{ # Holds one or more instances of `ClaimReview` markup for a webpage.
  &quot;pageUrl&quot;: &quot;A String&quot;, # The URL of the page associated with this `ClaimReview` markup. While every individual `ClaimReview` has its own URL field, semantically this is a page-level field, and each `ClaimReview` on this page will use this value unless individually overridden. Corresponds to `ClaimReview.url`
  &quot;claimReviewAuthor&quot;: { # Information about the claim review author. # Info about the author of this claim review. Similar to the above, semantically these are page-level fields, and each `ClaimReview` on this page will contain the same values.
    &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.author.image`.
    &quot;name&quot;: &quot;A String&quot;, # Name of the organization that is publishing the fact check. Corresponds to `ClaimReview.author.name`.
  },
  &quot;name&quot;: &quot;A String&quot;, # The name of this `ClaimReview` markup page resource, in the form of `pages/{page_id}`. Except for update requests, this field is output-only and should not be set by the user.
  &quot;publishDate&quot;: &quot;A String&quot;, # The date when the fact check was published. Similar to the URL, semantically this is a page-level field, and each `ClaimReview` on this page will contain the same value. Corresponds to `ClaimReview.datePublished`
  &quot;versionId&quot;: &quot;A String&quot;, # The version ID for this markup. Except for update requests, this field is output-only and should not be set by the user.
  &quot;claimReviewMarkups&quot;: [ # A list of individual claim reviews for this page. Each item in the list corresponds to one `ClaimReview` element.
    { # Fields for an individual `ClaimReview` element. Except for sub-messages that group fields together, each of these fields correspond those in https://schema.org/ClaimReview. We list the precise mapping for each field.
      &quot;claimReviewed&quot;: &quot;A String&quot;, # A short summary of the claim being evaluated. Corresponds to `ClaimReview.claimReviewed`.
      &quot;rating&quot;: { # Information about the claim rating. # Info about the rating of this claim review.
        &quot;bestRating&quot;: 42, # For numeric ratings, the best value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.bestRating`.
        &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.image`.
        &quot;ratingExplanation&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.ratingExplanation`.
        &quot;textualRating&quot;: &quot;A String&quot;, # The truthfulness rating as a human-readible short word or phrase. Corresponds to `ClaimReview.reviewRating.alternateName`.
        &quot;ratingValue&quot;: 42, # A numeric rating of this claim, in the range worstRating — bestRating inclusive. Corresponds to `ClaimReview.reviewRating.ratingValue`.
        &quot;worstRating&quot;: 42, # For numeric ratings, the worst value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.worstRating`.
      },
      &quot;claimLocation&quot;: &quot;A String&quot;, # The location where this claim was made. Corresponds to `ClaimReview.itemReviewed.name`.
      &quot;claimAuthor&quot;: { # Information about the claim author. # Info about the author of this claim.
        &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.image`.
        &quot;sameAs&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.sameAs`.
        &quot;jobTitle&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.jobTitle`.
        &quot;name&quot;: &quot;A String&quot;, # A person or organization stating the claim. For instance, &quot;John Doe&quot;. Corresponds to `ClaimReview.itemReviewed.author.name`.
      },
      &quot;url&quot;: &quot;A String&quot;, # This field is optional, and will default to the page URL. We provide this field to allow you the override the default value, but the only permitted override is the page URL plus an optional anchor link (&quot;page jump&quot;). Corresponds to `ClaimReview.url`
      &quot;claimFirstAppearance&quot;: &quot;A String&quot;, # A link to a work in which this claim first appears. Corresponds to `ClaimReview.itemReviewed[@type=Claim].firstAppearance.url`.
      &quot;claimDate&quot;: &quot;A String&quot;, # The date when the claim was made or entered public discourse. Corresponds to `ClaimReview.itemReviewed.datePublished`.
      &quot;claimAppearances&quot;: [ # A list of links to works in which this claim appears, aside from the one specified in `claim_first_appearance`. Corresponds to `ClaimReview.itemReviewed[@type=Claim].appearance.url`.
        &quot;A String&quot;,
      ],
    },
  ],
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Holds one or more instances of `ClaimReview` markup for a webpage.
    &quot;pageUrl&quot;: &quot;A String&quot;, # The URL of the page associated with this `ClaimReview` markup. While every individual `ClaimReview` has its own URL field, semantically this is a page-level field, and each `ClaimReview` on this page will use this value unless individually overridden. Corresponds to `ClaimReview.url`
    &quot;claimReviewAuthor&quot;: { # Information about the claim review author. # Info about the author of this claim review. Similar to the above, semantically these are page-level fields, and each `ClaimReview` on this page will contain the same values.
      &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.author.image`.
      &quot;name&quot;: &quot;A String&quot;, # Name of the organization that is publishing the fact check. Corresponds to `ClaimReview.author.name`.
    },
    &quot;name&quot;: &quot;A String&quot;, # The name of this `ClaimReview` markup page resource, in the form of `pages/{page_id}`. Except for update requests, this field is output-only and should not be set by the user.
    &quot;publishDate&quot;: &quot;A String&quot;, # The date when the fact check was published. Similar to the URL, semantically this is a page-level field, and each `ClaimReview` on this page will contain the same value. Corresponds to `ClaimReview.datePublished`
    &quot;versionId&quot;: &quot;A String&quot;, # The version ID for this markup. Except for update requests, this field is output-only and should not be set by the user.
    &quot;claimReviewMarkups&quot;: [ # A list of individual claim reviews for this page. Each item in the list corresponds to one `ClaimReview` element.
      { # Fields for an individual `ClaimReview` element. Except for sub-messages that group fields together, each of these fields correspond those in https://schema.org/ClaimReview. We list the precise mapping for each field.
        &quot;claimReviewed&quot;: &quot;A String&quot;, # A short summary of the claim being evaluated. Corresponds to `ClaimReview.claimReviewed`.
        &quot;rating&quot;: { # Information about the claim rating. # Info about the rating of this claim review.
          &quot;bestRating&quot;: 42, # For numeric ratings, the best value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.bestRating`.
          &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.image`.
          &quot;ratingExplanation&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.ratingExplanation`.
          &quot;textualRating&quot;: &quot;A String&quot;, # The truthfulness rating as a human-readible short word or phrase. Corresponds to `ClaimReview.reviewRating.alternateName`.
          &quot;ratingValue&quot;: 42, # A numeric rating of this claim, in the range worstRating — bestRating inclusive. Corresponds to `ClaimReview.reviewRating.ratingValue`.
          &quot;worstRating&quot;: 42, # For numeric ratings, the worst value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.worstRating`.
        },
        &quot;claimLocation&quot;: &quot;A String&quot;, # The location where this claim was made. Corresponds to `ClaimReview.itemReviewed.name`.
        &quot;claimAuthor&quot;: { # Information about the claim author. # Info about the author of this claim.
          &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.image`.
          &quot;sameAs&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.sameAs`.
          &quot;jobTitle&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.jobTitle`.
          &quot;name&quot;: &quot;A String&quot;, # A person or organization stating the claim. For instance, &quot;John Doe&quot;. Corresponds to `ClaimReview.itemReviewed.author.name`.
        },
        &quot;url&quot;: &quot;A String&quot;, # This field is optional, and will default to the page URL. We provide this field to allow you the override the default value, but the only permitted override is the page URL plus an optional anchor link (&quot;page jump&quot;). Corresponds to `ClaimReview.url`
        &quot;claimFirstAppearance&quot;: &quot;A String&quot;, # A link to a work in which this claim first appears. Corresponds to `ClaimReview.itemReviewed[@type=Claim].firstAppearance.url`.
        &quot;claimDate&quot;: &quot;A String&quot;, # The date when the claim was made or entered public discourse. Corresponds to `ClaimReview.itemReviewed.datePublished`.
        &quot;claimAppearances&quot;: [ # A list of links to works in which this claim appears, aside from the one specified in `claim_first_appearance`. Corresponds to `ClaimReview.itemReviewed[@type=Claim].appearance.url`.
          &quot;A String&quot;,
        ],
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(name, x__xgafv=None)</code>
  <pre>Delete all `ClaimReview` markup on a page.

Args:
  name: string, The name of the resource to delete, in the form of `pages/{page_id}`. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.
  }</pre>
</div>

<div class="method">
    <code class="details" id="get">get(name, x__xgafv=None)</code>
  <pre>Get all `ClaimReview` markup on a page.

Args:
  name: string, The name of the resource to get, in the form of `pages/{page_id}`. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Holds one or more instances of `ClaimReview` markup for a webpage.
    &quot;pageUrl&quot;: &quot;A String&quot;, # The URL of the page associated with this `ClaimReview` markup. While every individual `ClaimReview` has its own URL field, semantically this is a page-level field, and each `ClaimReview` on this page will use this value unless individually overridden. Corresponds to `ClaimReview.url`
    &quot;claimReviewAuthor&quot;: { # Information about the claim review author. # Info about the author of this claim review. Similar to the above, semantically these are page-level fields, and each `ClaimReview` on this page will contain the same values.
      &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.author.image`.
      &quot;name&quot;: &quot;A String&quot;, # Name of the organization that is publishing the fact check. Corresponds to `ClaimReview.author.name`.
    },
    &quot;name&quot;: &quot;A String&quot;, # The name of this `ClaimReview` markup page resource, in the form of `pages/{page_id}`. Except for update requests, this field is output-only and should not be set by the user.
    &quot;publishDate&quot;: &quot;A String&quot;, # The date when the fact check was published. Similar to the URL, semantically this is a page-level field, and each `ClaimReview` on this page will contain the same value. Corresponds to `ClaimReview.datePublished`
    &quot;versionId&quot;: &quot;A String&quot;, # The version ID for this markup. Except for update requests, this field is output-only and should not be set by the user.
    &quot;claimReviewMarkups&quot;: [ # A list of individual claim reviews for this page. Each item in the list corresponds to one `ClaimReview` element.
      { # Fields for an individual `ClaimReview` element. Except for sub-messages that group fields together, each of these fields correspond those in https://schema.org/ClaimReview. We list the precise mapping for each field.
        &quot;claimReviewed&quot;: &quot;A String&quot;, # A short summary of the claim being evaluated. Corresponds to `ClaimReview.claimReviewed`.
        &quot;rating&quot;: { # Information about the claim rating. # Info about the rating of this claim review.
          &quot;bestRating&quot;: 42, # For numeric ratings, the best value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.bestRating`.
          &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.image`.
          &quot;ratingExplanation&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.ratingExplanation`.
          &quot;textualRating&quot;: &quot;A String&quot;, # The truthfulness rating as a human-readible short word or phrase. Corresponds to `ClaimReview.reviewRating.alternateName`.
          &quot;ratingValue&quot;: 42, # A numeric rating of this claim, in the range worstRating — bestRating inclusive. Corresponds to `ClaimReview.reviewRating.ratingValue`.
          &quot;worstRating&quot;: 42, # For numeric ratings, the worst value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.worstRating`.
        },
        &quot;claimLocation&quot;: &quot;A String&quot;, # The location where this claim was made. Corresponds to `ClaimReview.itemReviewed.name`.
        &quot;claimAuthor&quot;: { # Information about the claim author. # Info about the author of this claim.
          &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.image`.
          &quot;sameAs&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.sameAs`.
          &quot;jobTitle&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.jobTitle`.
          &quot;name&quot;: &quot;A String&quot;, # A person or organization stating the claim. For instance, &quot;John Doe&quot;. Corresponds to `ClaimReview.itemReviewed.author.name`.
        },
        &quot;url&quot;: &quot;A String&quot;, # This field is optional, and will default to the page URL. We provide this field to allow you the override the default value, but the only permitted override is the page URL plus an optional anchor link (&quot;page jump&quot;). Corresponds to `ClaimReview.url`
        &quot;claimFirstAppearance&quot;: &quot;A String&quot;, # A link to a work in which this claim first appears. Corresponds to `ClaimReview.itemReviewed[@type=Claim].firstAppearance.url`.
        &quot;claimDate&quot;: &quot;A String&quot;, # The date when the claim was made or entered public discourse. Corresponds to `ClaimReview.itemReviewed.datePublished`.
        &quot;claimAppearances&quot;: [ # A list of links to works in which this claim appears, aside from the one specified in `claim_first_appearance`. Corresponds to `ClaimReview.itemReviewed[@type=Claim].appearance.url`.
          &quot;A String&quot;,
        ],
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(organization=None, url=None, offset=None, pageToken=None, pageSize=None, x__xgafv=None)</code>
  <pre>List the `ClaimReview` markup pages for a specific URL or for an organization.

Args:
  organization: string, The organization for which we want to fetch markups for. For instance, &quot;site.com&quot;. Cannot be specified along with an URL.
  url: string, The URL from which to get `ClaimReview` markup. There will be at most one result. If markup is associated with a more canonical version of the URL provided, we will return that URL instead. Cannot be specified along with an organization.
  offset: integer, An integer that specifies the current offset (that is, starting result location) in search results. This field is only considered if `page_token` is unset, and if the request is not for a specific URL. For example, 0 means to return results starting from the first matching result, and 10 means to return from the 11th result.
  pageToken: string, The pagination token. You may provide the `next_page_token` returned from a previous List request, if any, in order to get the next page. All other fields must have the same values as in the previous request.
  pageSize: integer, The pagination size. We will return up to that many results. Defaults to 10 if not set. Has no effect if a URL is requested.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response from listing `ClaimReview` markup.
    &quot;claimReviewMarkupPages&quot;: [ # The result list of pages of `ClaimReview` markup.
      { # Holds one or more instances of `ClaimReview` markup for a webpage.
        &quot;pageUrl&quot;: &quot;A String&quot;, # The URL of the page associated with this `ClaimReview` markup. While every individual `ClaimReview` has its own URL field, semantically this is a page-level field, and each `ClaimReview` on this page will use this value unless individually overridden. Corresponds to `ClaimReview.url`
        &quot;claimReviewAuthor&quot;: { # Information about the claim review author. # Info about the author of this claim review. Similar to the above, semantically these are page-level fields, and each `ClaimReview` on this page will contain the same values.
          &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.author.image`.
          &quot;name&quot;: &quot;A String&quot;, # Name of the organization that is publishing the fact check. Corresponds to `ClaimReview.author.name`.
        },
        &quot;name&quot;: &quot;A String&quot;, # The name of this `ClaimReview` markup page resource, in the form of `pages/{page_id}`. Except for update requests, this field is output-only and should not be set by the user.
        &quot;publishDate&quot;: &quot;A String&quot;, # The date when the fact check was published. Similar to the URL, semantically this is a page-level field, and each `ClaimReview` on this page will contain the same value. Corresponds to `ClaimReview.datePublished`
        &quot;versionId&quot;: &quot;A String&quot;, # The version ID for this markup. Except for update requests, this field is output-only and should not be set by the user.
        &quot;claimReviewMarkups&quot;: [ # A list of individual claim reviews for this page. Each item in the list corresponds to one `ClaimReview` element.
          { # Fields for an individual `ClaimReview` element. Except for sub-messages that group fields together, each of these fields correspond those in https://schema.org/ClaimReview. We list the precise mapping for each field.
            &quot;claimReviewed&quot;: &quot;A String&quot;, # A short summary of the claim being evaluated. Corresponds to `ClaimReview.claimReviewed`.
            &quot;rating&quot;: { # Information about the claim rating. # Info about the rating of this claim review.
              &quot;bestRating&quot;: 42, # For numeric ratings, the best value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.bestRating`.
              &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.image`.
              &quot;ratingExplanation&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.ratingExplanation`.
              &quot;textualRating&quot;: &quot;A String&quot;, # The truthfulness rating as a human-readible short word or phrase. Corresponds to `ClaimReview.reviewRating.alternateName`.
              &quot;ratingValue&quot;: 42, # A numeric rating of this claim, in the range worstRating — bestRating inclusive. Corresponds to `ClaimReview.reviewRating.ratingValue`.
              &quot;worstRating&quot;: 42, # For numeric ratings, the worst value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.worstRating`.
            },
            &quot;claimLocation&quot;: &quot;A String&quot;, # The location where this claim was made. Corresponds to `ClaimReview.itemReviewed.name`.
            &quot;claimAuthor&quot;: { # Information about the claim author. # Info about the author of this claim.
              &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.image`.
              &quot;sameAs&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.sameAs`.
              &quot;jobTitle&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.jobTitle`.
              &quot;name&quot;: &quot;A String&quot;, # A person or organization stating the claim. For instance, &quot;John Doe&quot;. Corresponds to `ClaimReview.itemReviewed.author.name`.
            },
            &quot;url&quot;: &quot;A String&quot;, # This field is optional, and will default to the page URL. We provide this field to allow you the override the default value, but the only permitted override is the page URL plus an optional anchor link (&quot;page jump&quot;). Corresponds to `ClaimReview.url`
            &quot;claimFirstAppearance&quot;: &quot;A String&quot;, # A link to a work in which this claim first appears. Corresponds to `ClaimReview.itemReviewed[@type=Claim].firstAppearance.url`.
            &quot;claimDate&quot;: &quot;A String&quot;, # The date when the claim was made or entered public discourse. Corresponds to `ClaimReview.itemReviewed.datePublished`.
            &quot;claimAppearances&quot;: [ # A list of links to works in which this claim appears, aside from the one specified in `claim_first_appearance`. Corresponds to `ClaimReview.itemReviewed[@type=Claim].appearance.url`.
              &quot;A String&quot;,
            ],
          },
        ],
      },
    ],
    &quot;nextPageToken&quot;: &quot;A String&quot;, # The next pagination token in the Search response. It should be used as the `page_token` for the following request. An empty value means no more results.
  }</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call &#x27;execute()&#x27; on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="update">update(name, body=None, x__xgafv=None)</code>
  <pre>Update for all `ClaimReview` markup on a page Note that this is a full update. To retain the existing `ClaimReview` markup on a page, first perform a Get operation, then modify the returned markup, and finally call Update with the entire `ClaimReview` markup as the body.

Args:
  name: string, The name of this `ClaimReview` markup page resource, in the form of `pages/{page_id}`. Except for update requests, this field is output-only and should not be set by the user. (required)
  body: object, The request body.
    The object takes the form of:

{ # Holds one or more instances of `ClaimReview` markup for a webpage.
  &quot;pageUrl&quot;: &quot;A String&quot;, # The URL of the page associated with this `ClaimReview` markup. While every individual `ClaimReview` has its own URL field, semantically this is a page-level field, and each `ClaimReview` on this page will use this value unless individually overridden. Corresponds to `ClaimReview.url`
  &quot;claimReviewAuthor&quot;: { # Information about the claim review author. # Info about the author of this claim review. Similar to the above, semantically these are page-level fields, and each `ClaimReview` on this page will contain the same values.
    &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.author.image`.
    &quot;name&quot;: &quot;A String&quot;, # Name of the organization that is publishing the fact check. Corresponds to `ClaimReview.author.name`.
  },
  &quot;name&quot;: &quot;A String&quot;, # The name of this `ClaimReview` markup page resource, in the form of `pages/{page_id}`. Except for update requests, this field is output-only and should not be set by the user.
  &quot;publishDate&quot;: &quot;A String&quot;, # The date when the fact check was published. Similar to the URL, semantically this is a page-level field, and each `ClaimReview` on this page will contain the same value. Corresponds to `ClaimReview.datePublished`
  &quot;versionId&quot;: &quot;A String&quot;, # The version ID for this markup. Except for update requests, this field is output-only and should not be set by the user.
  &quot;claimReviewMarkups&quot;: [ # A list of individual claim reviews for this page. Each item in the list corresponds to one `ClaimReview` element.
    { # Fields for an individual `ClaimReview` element. Except for sub-messages that group fields together, each of these fields correspond those in https://schema.org/ClaimReview. We list the precise mapping for each field.
      &quot;claimReviewed&quot;: &quot;A String&quot;, # A short summary of the claim being evaluated. Corresponds to `ClaimReview.claimReviewed`.
      &quot;rating&quot;: { # Information about the claim rating. # Info about the rating of this claim review.
        &quot;bestRating&quot;: 42, # For numeric ratings, the best value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.bestRating`.
        &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.image`.
        &quot;ratingExplanation&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.ratingExplanation`.
        &quot;textualRating&quot;: &quot;A String&quot;, # The truthfulness rating as a human-readible short word or phrase. Corresponds to `ClaimReview.reviewRating.alternateName`.
        &quot;ratingValue&quot;: 42, # A numeric rating of this claim, in the range worstRating — bestRating inclusive. Corresponds to `ClaimReview.reviewRating.ratingValue`.
        &quot;worstRating&quot;: 42, # For numeric ratings, the worst value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.worstRating`.
      },
      &quot;claimLocation&quot;: &quot;A String&quot;, # The location where this claim was made. Corresponds to `ClaimReview.itemReviewed.name`.
      &quot;claimAuthor&quot;: { # Information about the claim author. # Info about the author of this claim.
        &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.image`.
        &quot;sameAs&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.sameAs`.
        &quot;jobTitle&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.jobTitle`.
        &quot;name&quot;: &quot;A String&quot;, # A person or organization stating the claim. For instance, &quot;John Doe&quot;. Corresponds to `ClaimReview.itemReviewed.author.name`.
      },
      &quot;url&quot;: &quot;A String&quot;, # This field is optional, and will default to the page URL. We provide this field to allow you the override the default value, but the only permitted override is the page URL plus an optional anchor link (&quot;page jump&quot;). Corresponds to `ClaimReview.url`
      &quot;claimFirstAppearance&quot;: &quot;A String&quot;, # A link to a work in which this claim first appears. Corresponds to `ClaimReview.itemReviewed[@type=Claim].firstAppearance.url`.
      &quot;claimDate&quot;: &quot;A String&quot;, # The date when the claim was made or entered public discourse. Corresponds to `ClaimReview.itemReviewed.datePublished`.
      &quot;claimAppearances&quot;: [ # A list of links to works in which this claim appears, aside from the one specified in `claim_first_appearance`. Corresponds to `ClaimReview.itemReviewed[@type=Claim].appearance.url`.
        &quot;A String&quot;,
      ],
    },
  ],
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Holds one or more instances of `ClaimReview` markup for a webpage.
    &quot;pageUrl&quot;: &quot;A String&quot;, # The URL of the page associated with this `ClaimReview` markup. While every individual `ClaimReview` has its own URL field, semantically this is a page-level field, and each `ClaimReview` on this page will use this value unless individually overridden. Corresponds to `ClaimReview.url`
    &quot;claimReviewAuthor&quot;: { # Information about the claim review author. # Info about the author of this claim review. Similar to the above, semantically these are page-level fields, and each `ClaimReview` on this page will contain the same values.
      &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.author.image`.
      &quot;name&quot;: &quot;A String&quot;, # Name of the organization that is publishing the fact check. Corresponds to `ClaimReview.author.name`.
    },
    &quot;name&quot;: &quot;A String&quot;, # The name of this `ClaimReview` markup page resource, in the form of `pages/{page_id}`. Except for update requests, this field is output-only and should not be set by the user.
    &quot;publishDate&quot;: &quot;A String&quot;, # The date when the fact check was published. Similar to the URL, semantically this is a page-level field, and each `ClaimReview` on this page will contain the same value. Corresponds to `ClaimReview.datePublished`
    &quot;versionId&quot;: &quot;A String&quot;, # The version ID for this markup. Except for update requests, this field is output-only and should not be set by the user.
    &quot;claimReviewMarkups&quot;: [ # A list of individual claim reviews for this page. Each item in the list corresponds to one `ClaimReview` element.
      { # Fields for an individual `ClaimReview` element. Except for sub-messages that group fields together, each of these fields correspond those in https://schema.org/ClaimReview. We list the precise mapping for each field.
        &quot;claimReviewed&quot;: &quot;A String&quot;, # A short summary of the claim being evaluated. Corresponds to `ClaimReview.claimReviewed`.
        &quot;rating&quot;: { # Information about the claim rating. # Info about the rating of this claim review.
          &quot;bestRating&quot;: 42, # For numeric ratings, the best value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.bestRating`.
          &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.image`.
          &quot;ratingExplanation&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.reviewRating.ratingExplanation`.
          &quot;textualRating&quot;: &quot;A String&quot;, # The truthfulness rating as a human-readible short word or phrase. Corresponds to `ClaimReview.reviewRating.alternateName`.
          &quot;ratingValue&quot;: 42, # A numeric rating of this claim, in the range worstRating — bestRating inclusive. Corresponds to `ClaimReview.reviewRating.ratingValue`.
          &quot;worstRating&quot;: 42, # For numeric ratings, the worst value possible in the scale from worst to best. Corresponds to `ClaimReview.reviewRating.worstRating`.
        },
        &quot;claimLocation&quot;: &quot;A String&quot;, # The location where this claim was made. Corresponds to `ClaimReview.itemReviewed.name`.
        &quot;claimAuthor&quot;: { # Information about the claim author. # Info about the author of this claim.
          &quot;imageUrl&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.image`.
          &quot;sameAs&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.sameAs`.
          &quot;jobTitle&quot;: &quot;A String&quot;, # Corresponds to `ClaimReview.itemReviewed.author.jobTitle`.
          &quot;name&quot;: &quot;A String&quot;, # A person or organization stating the claim. For instance, &quot;John Doe&quot;. Corresponds to `ClaimReview.itemReviewed.author.name`.
        },
        &quot;url&quot;: &quot;A String&quot;, # This field is optional, and will default to the page URL. We provide this field to allow you the override the default value, but the only permitted override is the page URL plus an optional anchor link (&quot;page jump&quot;). Corresponds to `ClaimReview.url`
        &quot;claimFirstAppearance&quot;: &quot;A String&quot;, # A link to a work in which this claim first appears. Corresponds to `ClaimReview.itemReviewed[@type=Claim].firstAppearance.url`.
        &quot;claimDate&quot;: &quot;A String&quot;, # The date when the claim was made or entered public discourse. Corresponds to `ClaimReview.itemReviewed.datePublished`.
        &quot;claimAppearances&quot;: [ # A list of links to works in which this claim appears, aside from the one specified in `claim_first_appearance`. Corresponds to `ClaimReview.itemReviewed[@type=Claim].appearance.url`.
          &quot;A String&quot;,
        ],
      },
    ],
  }</pre>
</div>

</body></html>