Home | History | Annotate | Download | only in dyn
      1 <html><body>
      2 <style>
      3 
      4 body, h1, h2, h3, div, span, p, pre, a {
      5   margin: 0;
      6   padding: 0;
      7   border: 0;
      8   font-weight: inherit;
      9   font-style: inherit;
     10   font-size: 100%;
     11   font-family: inherit;
     12   vertical-align: baseline;
     13 }
     14 
     15 body {
     16   font-size: 13px;
     17   padding: 1em;
     18 }
     19 
     20 h1 {
     21   font-size: 26px;
     22   margin-bottom: 1em;
     23 }
     24 
     25 h2 {
     26   font-size: 24px;
     27   margin-bottom: 1em;
     28 }
     29 
     30 h3 {
     31   font-size: 20px;
     32   margin-bottom: 1em;
     33   margin-top: 1em;
     34 }
     35 
     36 pre, code {
     37   line-height: 1.5;
     38   font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
     39 }
     40 
     41 pre {
     42   margin-top: 0.5em;
     43 }
     44 
     45 h1, h2, h3, p {
     46   font-family: Arial, sans serif;
     47 }
     48 
     49 h1, h2, h3 {
     50   border-bottom: solid #CCC 1px;
     51 }
     52 
     53 .toc_element {
     54   margin-top: 0.5em;
     55 }
     56 
     57 .firstline {
     58   margin-left: 2 em;
     59 }
     60 
     61 .method  {
     62   margin-top: 1em;
     63   border: solid 1px #CCC;
     64   padding: 1em;
     65   background: #EEE;
     66 }
     67 
     68 .details {
     69   font-weight: bold;
     70   font-size: 14px;
     71 }
     72 
     73 </style>
     74 
     75 <h1><a href="genomics_v1.html">Genomics API</a> . <a href="genomics_v1.variants.html">variants</a></h1>
     76 <h2>Instance Methods</h2>
     77 <p class="toc_element">
     78   <code><a href="#create">create(body, x__xgafv=None)</a></code></p>
     79 <p class="firstline">Creates a new variant.</p>
     80 <p class="toc_element">
     81   <code><a href="#delete">delete(variantId, x__xgafv=None)</a></code></p>
     82 <p class="firstline">Deletes a variant.</p>
     83 <p class="toc_element">
     84   <code><a href="#get">get(variantId, x__xgafv=None)</a></code></p>
     85 <p class="firstline">Gets a variant by ID.</p>
     86 <p class="toc_element">
     87   <code><a href="#import_">import_(body, x__xgafv=None)</a></code></p>
     88 <p class="firstline">Creates variant data by asynchronously importing the provided information.</p>
     89 <p class="toc_element">
     90   <code><a href="#merge">merge(body, x__xgafv=None)</a></code></p>
     91 <p class="firstline">Merges the given variants with existing variants.</p>
     92 <p class="toc_element">
     93   <code><a href="#patch">patch(variantId, body, x__xgafv=None, updateMask=None)</a></code></p>
     94 <p class="firstline">Updates a variant.</p>
     95 <p class="toc_element">
     96   <code><a href="#search">search(body, x__xgafv=None)</a></code></p>
     97 <p class="firstline">Gets a list of variants matching the criteria.</p>
     98 <p class="toc_element">
     99   <code><a href="#search_next">search_next(previous_request, previous_response)</a></code></p>
    100 <p class="firstline">Retrieves the next page of results.</p>
    101 <h3>Method Details</h3>
    102 <div class="method">
    103     <code class="details" id="create">create(body, x__xgafv=None)</code>
    104   <pre>Creates a new variant.
    105 
    106 For the definitions of variants and other genomics resources, see
    107 [Fundamentals of Google
    108 Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    109 
    110 Args:
    111   body: object, The request body. (required)
    112     The object takes the form of:
    113 
    114 { # A variant represents a change in DNA sequence relative to a reference
    115     # sequence. For example, a variant could represent a SNP or an insertion.
    116     # Variants belong to a variant set.
    117     # 
    118     # For more genomics resource definitions, see [Fundamentals of Google
    119     # Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    120     # 
    121     # Each of the calls on a variant represent a determination of genotype with
    122     # respect to that variant. For example, a call might assign probability of 0.32
    123     # to the occurrence of a SNP named rs1234 in a sample named NA12345. A call
    124     # belongs to a call set, which contains related calls typically from one
    125     # sample.
    126   "info": { # A map of additional variant information. This must be of the form
    127       # map<string, string[]> (string key mapping to a list of string values).
    128     "a_key": [
    129       "",
    130     ],
    131   },
    132   "variantSetId": "A String", # The ID of the variant set this variant belongs to.
    133   "end": "A String", # The end position (0-based) of this variant. This corresponds to the first
    134       # base after the last base in the reference allele. So, the length of
    135       # the reference allele is (end - start). This is useful for variants
    136       # that don't explicitly give alternate bases, for example large deletions.
    137   "calls": [ # The variant calls for this particular variant. Each one represents the
    138       # determination of genotype with respect to this variant.
    139     { # A call represents the determination of genotype with respect to a particular
    140         # variant. It may include associated information such as quality and phasing.
    141         # For example, a call might assign a probability of 0.32 to the occurrence of
    142         # a SNP named rs1234 in a call set with the name NA12345.
    143       "info": { # A map of additional variant call information. This must be of the form
    144           # map<string, string[]> (string key mapping to a list of string values).
    145         "a_key": [
    146           "",
    147         ],
    148       },
    149       "genotype": [ # The genotype of this variant call. Each value represents either the value
    150           # of the `referenceBases` field or a 1-based index into
    151           # `alternateBases`. If a variant had a `referenceBases`
    152           # value of `T` and an `alternateBases`
    153           # value of `["A", "C"]`, and the `genotype` was
    154           # `[2, 1]`, that would mean the call
    155           # represented the heterozygous value `CA` for this variant.
    156           # If the `genotype` was instead `[0, 1]`, the
    157           # represented value would be `TA`. Ordering of the
    158           # genotype values is important if the `phaseset` is present.
    159           # If a genotype is not called (that is, a `.` is present in the
    160           # GT string) -1 is returned.
    161         42,
    162       ],
    163       "callSetId": "A String", # The ID of the call set this variant call belongs to.
    164       "phaseset": "A String", # If this field is present, this variant call's genotype ordering implies
    165           # the phase of the bases and is consistent with any other variant calls in
    166           # the same reference sequence which have the same phaseset value.
    167           # When importing data from VCF, if the genotype data was phased but no
    168           # phase set was specified this field will be set to `*`.
    169       "genotypeLikelihood": [ # The genotype likelihoods for this variant call. Each array entry
    170           # represents how likely a specific genotype is for this call. The value
    171           # ordering is defined by the GL tag in the VCF spec.
    172           # If Phred-scaled genotype likelihood scores (PL) are available and
    173           # log10(P) genotype likelihood scores (GL) are not, PL scores are converted
    174           # to GL scores.  If both are available, PL scores are stored in `info`.
    175         3.14,
    176       ],
    177       "callSetName": "A String", # The name of the call set this variant call belongs to.
    178     },
    179   ],
    180   "created": "A String", # The date this variant was created, in milliseconds from the epoch.
    181   "id": "A String", # The server-generated variant ID, unique across all variants.
    182   "filter": [ # A list of filters (normally quality filters) this variant has failed.
    183       # `PASS` indicates this variant has passed all filters.
    184     "A String",
    185   ],
    186   "start": "A String", # The position at which this variant occurs (0-based).
    187       # This corresponds to the first base of the string of reference bases.
    188   "names": [ # Names for the variant, for example a RefSNP ID.
    189     "A String",
    190   ],
    191   "alternateBases": [ # The bases that appear instead of the reference bases.
    192     "A String",
    193   ],
    194   "referenceName": "A String", # The reference on which this variant occurs.
    195       # (such as `chr20` or `X`)
    196   "quality": 3.14, # A measure of how likely this variant is to be real.
    197       # A higher value is better.
    198   "referenceBases": "A String", # The reference bases for this variant. They start at the given
    199       # position.
    200 }
    201 
    202   x__xgafv: string, V1 error format.
    203     Allowed values
    204       1 - v1 error format
    205       2 - v2 error format
    206 
    207 Returns:
    208   An object of the form:
    209 
    210     { # A variant represents a change in DNA sequence relative to a reference
    211       # sequence. For example, a variant could represent a SNP or an insertion.
    212       # Variants belong to a variant set.
    213       #
    214       # For more genomics resource definitions, see [Fundamentals of Google
    215       # Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    216       #
    217       # Each of the calls on a variant represent a determination of genotype with
    218       # respect to that variant. For example, a call might assign probability of 0.32
    219       # to the occurrence of a SNP named rs1234 in a sample named NA12345. A call
    220       # belongs to a call set, which contains related calls typically from one
    221       # sample.
    222     "info": { # A map of additional variant information. This must be of the form
    223         # map<string, string[]> (string key mapping to a list of string values).
    224       "a_key": [
    225         "",
    226       ],
    227     },
    228     "variantSetId": "A String", # The ID of the variant set this variant belongs to.
    229     "end": "A String", # The end position (0-based) of this variant. This corresponds to the first
    230         # base after the last base in the reference allele. So, the length of
    231         # the reference allele is (end - start). This is useful for variants
    232         # that don't explicitly give alternate bases, for example large deletions.
    233     "calls": [ # The variant calls for this particular variant. Each one represents the
    234         # determination of genotype with respect to this variant.
    235       { # A call represents the determination of genotype with respect to a particular
    236           # variant. It may include associated information such as quality and phasing.
    237           # For example, a call might assign a probability of 0.32 to the occurrence of
    238           # a SNP named rs1234 in a call set with the name NA12345.
    239         "info": { # A map of additional variant call information. This must be of the form
    240             # map<string, string[]> (string key mapping to a list of string values).
    241           "a_key": [
    242             "",
    243           ],
    244         },
    245         "genotype": [ # The genotype of this variant call. Each value represents either the value
    246             # of the `referenceBases` field or a 1-based index into
    247             # `alternateBases`. If a variant had a `referenceBases`
    248             # value of `T` and an `alternateBases`
    249             # value of `["A", "C"]`, and the `genotype` was
    250             # `[2, 1]`, that would mean the call
    251             # represented the heterozygous value `CA` for this variant.
    252             # If the `genotype` was instead `[0, 1]`, the
    253             # represented value would be `TA`. Ordering of the
    254             # genotype values is important if the `phaseset` is present.
    255             # If a genotype is not called (that is, a `.` is present in the
    256             # GT string) -1 is returned.
    257           42,
    258         ],
    259         "callSetId": "A String", # The ID of the call set this variant call belongs to.
    260         "phaseset": "A String", # If this field is present, this variant call's genotype ordering implies
    261             # the phase of the bases and is consistent with any other variant calls in
    262             # the same reference sequence which have the same phaseset value.
    263             # When importing data from VCF, if the genotype data was phased but no
    264             # phase set was specified this field will be set to `*`.
    265         "genotypeLikelihood": [ # The genotype likelihoods for this variant call. Each array entry
    266             # represents how likely a specific genotype is for this call. The value
    267             # ordering is defined by the GL tag in the VCF spec.
    268             # If Phred-scaled genotype likelihood scores (PL) are available and
    269             # log10(P) genotype likelihood scores (GL) are not, PL scores are converted
    270             # to GL scores.  If both are available, PL scores are stored in `info`.
    271           3.14,
    272         ],
    273         "callSetName": "A String", # The name of the call set this variant call belongs to.
    274       },
    275     ],
    276     "created": "A String", # The date this variant was created, in milliseconds from the epoch.
    277     "id": "A String", # The server-generated variant ID, unique across all variants.
    278     "filter": [ # A list of filters (normally quality filters) this variant has failed.
    279         # `PASS` indicates this variant has passed all filters.
    280       "A String",
    281     ],
    282     "start": "A String", # The position at which this variant occurs (0-based).
    283         # This corresponds to the first base of the string of reference bases.
    284     "names": [ # Names for the variant, for example a RefSNP ID.
    285       "A String",
    286     ],
    287     "alternateBases": [ # The bases that appear instead of the reference bases.
    288       "A String",
    289     ],
    290     "referenceName": "A String", # The reference on which this variant occurs.
    291         # (such as `chr20` or `X`)
    292     "quality": 3.14, # A measure of how likely this variant is to be real.
    293         # A higher value is better.
    294     "referenceBases": "A String", # The reference bases for this variant. They start at the given
    295         # position.
    296   }</pre>
    297 </div>
    298 
    299 <div class="method">
    300     <code class="details" id="delete">delete(variantId, x__xgafv=None)</code>
    301   <pre>Deletes a variant.
    302 
    303 For the definitions of variants and other genomics resources, see
    304 [Fundamentals of Google
    305 Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    306 
    307 Args:
    308   variantId: string, The ID of the variant to be deleted. (required)
    309   x__xgafv: string, V1 error format.
    310     Allowed values
    311       1 - v1 error format
    312       2 - v2 error format
    313 
    314 Returns:
    315   An object of the form:
    316 
    317     { # A generic empty message that you can re-use to avoid defining duplicated
    318       # empty messages in your APIs. A typical example is to use it as the request
    319       # or the response type of an API method. For instance:
    320       #
    321       #     service Foo {
    322       #       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
    323       #     }
    324       #
    325       # The JSON representation for `Empty` is empty JSON object `{}`.
    326   }</pre>
    327 </div>
    328 
    329 <div class="method">
    330     <code class="details" id="get">get(variantId, x__xgafv=None)</code>
    331   <pre>Gets a variant by ID.
    332 
    333 For the definitions of variants and other genomics resources, see
    334 [Fundamentals of Google
    335 Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    336 
    337 Args:
    338   variantId: string, The ID of the variant. (required)
    339   x__xgafv: string, V1 error format.
    340     Allowed values
    341       1 - v1 error format
    342       2 - v2 error format
    343 
    344 Returns:
    345   An object of the form:
    346 
    347     { # A variant represents a change in DNA sequence relative to a reference
    348       # sequence. For example, a variant could represent a SNP or an insertion.
    349       # Variants belong to a variant set.
    350       #
    351       # For more genomics resource definitions, see [Fundamentals of Google
    352       # Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    353       #
    354       # Each of the calls on a variant represent a determination of genotype with
    355       # respect to that variant. For example, a call might assign probability of 0.32
    356       # to the occurrence of a SNP named rs1234 in a sample named NA12345. A call
    357       # belongs to a call set, which contains related calls typically from one
    358       # sample.
    359     "info": { # A map of additional variant information. This must be of the form
    360         # map<string, string[]> (string key mapping to a list of string values).
    361       "a_key": [
    362         "",
    363       ],
    364     },
    365     "variantSetId": "A String", # The ID of the variant set this variant belongs to.
    366     "end": "A String", # The end position (0-based) of this variant. This corresponds to the first
    367         # base after the last base in the reference allele. So, the length of
    368         # the reference allele is (end - start). This is useful for variants
    369         # that don't explicitly give alternate bases, for example large deletions.
    370     "calls": [ # The variant calls for this particular variant. Each one represents the
    371         # determination of genotype with respect to this variant.
    372       { # A call represents the determination of genotype with respect to a particular
    373           # variant. It may include associated information such as quality and phasing.
    374           # For example, a call might assign a probability of 0.32 to the occurrence of
    375           # a SNP named rs1234 in a call set with the name NA12345.
    376         "info": { # A map of additional variant call information. This must be of the form
    377             # map<string, string[]> (string key mapping to a list of string values).
    378           "a_key": [
    379             "",
    380           ],
    381         },
    382         "genotype": [ # The genotype of this variant call. Each value represents either the value
    383             # of the `referenceBases` field or a 1-based index into
    384             # `alternateBases`. If a variant had a `referenceBases`
    385             # value of `T` and an `alternateBases`
    386             # value of `["A", "C"]`, and the `genotype` was
    387             # `[2, 1]`, that would mean the call
    388             # represented the heterozygous value `CA` for this variant.
    389             # If the `genotype` was instead `[0, 1]`, the
    390             # represented value would be `TA`. Ordering of the
    391             # genotype values is important if the `phaseset` is present.
    392             # If a genotype is not called (that is, a `.` is present in the
    393             # GT string) -1 is returned.
    394           42,
    395         ],
    396         "callSetId": "A String", # The ID of the call set this variant call belongs to.
    397         "phaseset": "A String", # If this field is present, this variant call's genotype ordering implies
    398             # the phase of the bases and is consistent with any other variant calls in
    399             # the same reference sequence which have the same phaseset value.
    400             # When importing data from VCF, if the genotype data was phased but no
    401             # phase set was specified this field will be set to `*`.
    402         "genotypeLikelihood": [ # The genotype likelihoods for this variant call. Each array entry
    403             # represents how likely a specific genotype is for this call. The value
    404             # ordering is defined by the GL tag in the VCF spec.
    405             # If Phred-scaled genotype likelihood scores (PL) are available and
    406             # log10(P) genotype likelihood scores (GL) are not, PL scores are converted
    407             # to GL scores.  If both are available, PL scores are stored in `info`.
    408           3.14,
    409         ],
    410         "callSetName": "A String", # The name of the call set this variant call belongs to.
    411       },
    412     ],
    413     "created": "A String", # The date this variant was created, in milliseconds from the epoch.
    414     "id": "A String", # The server-generated variant ID, unique across all variants.
    415     "filter": [ # A list of filters (normally quality filters) this variant has failed.
    416         # `PASS` indicates this variant has passed all filters.
    417       "A String",
    418     ],
    419     "start": "A String", # The position at which this variant occurs (0-based).
    420         # This corresponds to the first base of the string of reference bases.
    421     "names": [ # Names for the variant, for example a RefSNP ID.
    422       "A String",
    423     ],
    424     "alternateBases": [ # The bases that appear instead of the reference bases.
    425       "A String",
    426     ],
    427     "referenceName": "A String", # The reference on which this variant occurs.
    428         # (such as `chr20` or `X`)
    429     "quality": 3.14, # A measure of how likely this variant is to be real.
    430         # A higher value is better.
    431     "referenceBases": "A String", # The reference bases for this variant. They start at the given
    432         # position.
    433   }</pre>
    434 </div>
    435 
    436 <div class="method">
    437     <code class="details" id="import_">import_(body, x__xgafv=None)</code>
    438   <pre>Creates variant data by asynchronously importing the provided information.
    439 
    440 For the definitions of variant sets and other genomics resources, see
    441 [Fundamentals of Google
    442 Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    443 
    444 The variants for import will be merged with any existing variant that
    445 matches its reference sequence, start, end, reference bases, and
    446 alternative bases. If no such variant exists, a new one will be created.
    447 
    448 When variants are merged, the call information from the new variant
    449 is added to the existing variant, and Variant info fields are merged
    450 as specified in
    451 infoMergeConfig.
    452 As a special case, for single-sample VCF files, QUAL and FILTER fields will
    453 be moved to the call level; these are sometimes interpreted in a
    454 call-specific context.
    455 Imported VCF headers are appended to the metadata already in a variant set.
    456 
    457 Args:
    458   body: object, The request body. (required)
    459     The object takes the form of:
    460 
    461 { # The variant data import request.
    462     "variantSetId": "A String", # Required. The variant set to which variant data should be imported.
    463     "format": "A String", # The format of the variant data being imported. If unspecified, defaults to
    464         # to `VCF`.
    465     "sourceUris": [ # A list of URIs referencing variant files in Google Cloud Storage. URIs can
    466         # include wildcards [as described
    467         # here](https://cloud.google.com/storage/docs/gsutil/addlhelp/WildcardNames).
    468         # Note that recursive wildcards ('**') are not supported.
    469       "A String",
    470     ],
    471     "infoMergeConfig": { # A mapping between info field keys and the InfoMergeOperations to
    472         # be performed on them. This is plumbed down to the MergeVariantRequests
    473         # generated by the resulting import job.
    474       "a_key": "A String",
    475     },
    476     "normalizeReferenceNames": True or False, # Convert reference names to the canonical representation.
    477         # hg19 haploytypes (those reference names containing "_hap")
    478         # are not modified in any way.
    479         # All other reference names are modified according to the following rules:
    480         # The reference name is capitalized.
    481         # The "chr" prefix is dropped for all autosomes and sex chromsomes.
    482         # For example "chr17" becomes "17" and "chrX" becomes "X".
    483         # All mitochondrial chromosomes ("chrM", "chrMT", etc) become "MT".
    484   }
    485 
    486   x__xgafv: string, V1 error format.
    487     Allowed values
    488       1 - v1 error format
    489       2 - v2 error format
    490 
    491 Returns:
    492   An object of the form:
    493 
    494     { # This resource represents a long-running operation that is the result of a
    495       # network API call.
    496     "metadata": { # An OperationMetadata object. This will always be returned with the Operation.
    497       "a_key": "", # Properties of the object. Contains field @type with type URL.
    498     },
    499     "error": { # The `Status` type defines a logical error model that is suitable for different # The error result of the operation in case of failure or cancellation.
    500         # programming environments, including REST APIs and RPC APIs. It is used by
    501         # [gRPC](https://github.com/grpc). The error model is designed to be:
    502         #
    503         # - Simple to use and understand for most users
    504         # - Flexible enough to meet unexpected needs
    505         #
    506         # # Overview
    507         #
    508         # The `Status` message contains three pieces of data: error code, error message,
    509         # and error details. The error code should be an enum value of
    510         # google.rpc.Code, but it may accept additional error codes if needed.  The
    511         # error message should be a developer-facing English message that helps
    512         # developers *understand* and *resolve* the error. If a localized user-facing
    513         # error message is needed, put the localized message in the error details or
    514         # localize it in the client. The optional error details may contain arbitrary
    515         # information about the error. There is a predefined set of error detail types
    516         # in the package `google.rpc` that can be used for common error conditions.
    517         #
    518         # # Language mapping
    519         #
    520         # The `Status` message is the logical representation of the error model, but it
    521         # is not necessarily the actual wire format. When the `Status` message is
    522         # exposed in different client libraries and different wire protocols, it can be
    523         # mapped differently. For example, it will likely be mapped to some exceptions
    524         # in Java, but more likely mapped to some error codes in C.
    525         #
    526         # # Other uses
    527         #
    528         # The error model and the `Status` message can be used in a variety of
    529         # environments, either with or without APIs, to provide a
    530         # consistent developer experience across different environments.
    531         #
    532         # Example uses of this error model include:
    533         #
    534         # - Partial errors. If a service needs to return partial errors to the client,
    535         #     it may embed the `Status` in the normal response to indicate the partial
    536         #     errors.
    537         #
    538         # - Workflow errors. A typical workflow has multiple steps. Each step may
    539         #     have a `Status` message for error reporting.
    540         #
    541         # - Batch operations. If a client uses batch request and batch response, the
    542         #     `Status` message should be used directly inside batch response, one for
    543         #     each error sub-response.
    544         #
    545         # - Asynchronous operations. If an API call embeds asynchronous operation
    546         #     results in its response, the status of those operations should be
    547         #     represented directly using the `Status` message.
    548         #
    549         # - Logging. If some API errors are stored in logs, the message `Status` could
    550         #     be used directly after any stripping needed for security/privacy reasons.
    551       "message": "A String", # A developer-facing error message, which should be in English. Any
    552           # user-facing error message should be localized and sent in the
    553           # google.rpc.Status.details field, or localized by the client.
    554       "code": 42, # The status code, which should be an enum value of google.rpc.Code.
    555       "details": [ # A list of messages that carry the error details.  There will be a
    556           # common set of message types for APIs to use.
    557         {
    558           "a_key": "", # Properties of the object. Contains field @type with type URL.
    559         },
    560       ],
    561     },
    562     "done": True or False, # If the value is `false`, it means the operation is still in progress.
    563         # If true, the operation is completed, and either `error` or `response` is
    564         # available.
    565     "response": { # If importing ReadGroupSets, an ImportReadGroupSetsResponse is returned. If importing Variants, an ImportVariantsResponse is returned. For pipelines and exports, an empty response is returned.
    566       "a_key": "", # Properties of the object. Contains field @type with type URL.
    567     },
    568     "name": "A String", # The server-assigned name, which is only unique within the same service that originally returns it. For example&#58; `operations/CJHU7Oi_ChDrveSpBRjfuL-qzoWAgEw`
    569   }</pre>
    570 </div>
    571 
    572 <div class="method">
    573     <code class="details" id="merge">merge(body, x__xgafv=None)</code>
    574   <pre>Merges the given variants with existing variants.
    575 
    576 For the definitions of variants and other genomics resources, see
    577 [Fundamentals of Google
    578 Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    579 
    580 Each variant will be
    581 merged with an existing variant that matches its reference sequence,
    582 start, end, reference bases, and alternative bases. If no such variant
    583 exists, a new one will be created.
    584 
    585 When variants are merged, the call information from the new variant
    586 is added to the existing variant. Variant info fields are merged as
    587 specified in the
    588 infoMergeConfig
    589 field of the MergeVariantsRequest.
    590 
    591 Please exercise caution when using this method!  It is easy to introduce
    592 mistakes in existing variants and difficult to back out of them.  For
    593 example,
    594 suppose you were trying to merge a new variant with an existing one and
    595 both
    596 variants contain calls that belong to callsets with the same callset ID.
    597 
    598     // Existing variant - irrelevant fields trimmed for clarity
    599     {
    600         "variantSetId": "10473108253681171589",
    601         "referenceName": "1",
    602         "start": "10582",
    603         "referenceBases": "G",
    604         "alternateBases": [
    605             "A"
    606         ],
    607         "calls": [
    608             {
    609                 "callSetId": "10473108253681171589-0",
    610                 "callSetName": "CALLSET0",
    611                 "genotype": [
    612                     0,
    613                     1
    614                 ],
    615             }
    616         ]
    617     }
    618 
    619     // New variant with conflicting call information
    620     {
    621         "variantSetId": "10473108253681171589",
    622         "referenceName": "1",
    623         "start": "10582",
    624         "referenceBases": "G",
    625         "alternateBases": [
    626             "A"
    627         ],
    628         "calls": [
    629             {
    630                 "callSetId": "10473108253681171589-0",
    631                 "callSetName": "CALLSET0",
    632                 "genotype": [
    633                     1,
    634                     1
    635                 ],
    636             }
    637         ]
    638     }
    639 
    640 The resulting merged variant would overwrite the existing calls with those
    641 from the new variant:
    642 
    643     {
    644         "variantSetId": "10473108253681171589",
    645         "referenceName": "1",
    646         "start": "10582",
    647         "referenceBases": "G",
    648         "alternateBases": [
    649             "A"
    650         ],
    651         "calls": [
    652             {
    653                 "callSetId": "10473108253681171589-0",
    654                 "callSetName": "CALLSET0",
    655                 "genotype": [
    656                     1,
    657                     1
    658                 ],
    659             }
    660         ]
    661     }
    662 
    663 This may be the desired outcome, but it is up to the user to determine if
    664 if that is indeed the case.
    665 
    666 Args:
    667   body: object, The request body. (required)
    668     The object takes the form of:
    669 
    670 {
    671     "variantSetId": "A String", # The destination variant set.
    672     "variants": [ # The variants to be merged with existing variants.
    673       { # A variant represents a change in DNA sequence relative to a reference
    674           # sequence. For example, a variant could represent a SNP or an insertion.
    675           # Variants belong to a variant set.
    676           #
    677           # For more genomics resource definitions, see [Fundamentals of Google
    678           # Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    679           #
    680           # Each of the calls on a variant represent a determination of genotype with
    681           # respect to that variant. For example, a call might assign probability of 0.32
    682           # to the occurrence of a SNP named rs1234 in a sample named NA12345. A call
    683           # belongs to a call set, which contains related calls typically from one
    684           # sample.
    685         "info": { # A map of additional variant information. This must be of the form
    686             # map<string, string[]> (string key mapping to a list of string values).
    687           "a_key": [
    688             "",
    689           ],
    690         },
    691         "variantSetId": "A String", # The ID of the variant set this variant belongs to.
    692         "end": "A String", # The end position (0-based) of this variant. This corresponds to the first
    693             # base after the last base in the reference allele. So, the length of
    694             # the reference allele is (end - start). This is useful for variants
    695             # that don't explicitly give alternate bases, for example large deletions.
    696         "calls": [ # The variant calls for this particular variant. Each one represents the
    697             # determination of genotype with respect to this variant.
    698           { # A call represents the determination of genotype with respect to a particular
    699               # variant. It may include associated information such as quality and phasing.
    700               # For example, a call might assign a probability of 0.32 to the occurrence of
    701               # a SNP named rs1234 in a call set with the name NA12345.
    702             "info": { # A map of additional variant call information. This must be of the form
    703                 # map<string, string[]> (string key mapping to a list of string values).
    704               "a_key": [
    705                 "",
    706               ],
    707             },
    708             "genotype": [ # The genotype of this variant call. Each value represents either the value
    709                 # of the `referenceBases` field or a 1-based index into
    710                 # `alternateBases`. If a variant had a `referenceBases`
    711                 # value of `T` and an `alternateBases`
    712                 # value of `["A", "C"]`, and the `genotype` was
    713                 # `[2, 1]`, that would mean the call
    714                 # represented the heterozygous value `CA` for this variant.
    715                 # If the `genotype` was instead `[0, 1]`, the
    716                 # represented value would be `TA`. Ordering of the
    717                 # genotype values is important if the `phaseset` is present.
    718                 # If a genotype is not called (that is, a `.` is present in the
    719                 # GT string) -1 is returned.
    720               42,
    721             ],
    722             "callSetId": "A String", # The ID of the call set this variant call belongs to.
    723             "phaseset": "A String", # If this field is present, this variant call's genotype ordering implies
    724                 # the phase of the bases and is consistent with any other variant calls in
    725                 # the same reference sequence which have the same phaseset value.
    726                 # When importing data from VCF, if the genotype data was phased but no
    727                 # phase set was specified this field will be set to `*`.
    728             "genotypeLikelihood": [ # The genotype likelihoods for this variant call. Each array entry
    729                 # represents how likely a specific genotype is for this call. The value
    730                 # ordering is defined by the GL tag in the VCF spec.
    731                 # If Phred-scaled genotype likelihood scores (PL) are available and
    732                 # log10(P) genotype likelihood scores (GL) are not, PL scores are converted
    733                 # to GL scores.  If both are available, PL scores are stored in `info`.
    734               3.14,
    735             ],
    736             "callSetName": "A String", # The name of the call set this variant call belongs to.
    737           },
    738         ],
    739         "created": "A String", # The date this variant was created, in milliseconds from the epoch.
    740         "id": "A String", # The server-generated variant ID, unique across all variants.
    741         "filter": [ # A list of filters (normally quality filters) this variant has failed.
    742             # `PASS` indicates this variant has passed all filters.
    743           "A String",
    744         ],
    745         "start": "A String", # The position at which this variant occurs (0-based).
    746             # This corresponds to the first base of the string of reference bases.
    747         "names": [ # Names for the variant, for example a RefSNP ID.
    748           "A String",
    749         ],
    750         "alternateBases": [ # The bases that appear instead of the reference bases.
    751           "A String",
    752         ],
    753         "referenceName": "A String", # The reference on which this variant occurs.
    754             # (such as `chr20` or `X`)
    755         "quality": 3.14, # A measure of how likely this variant is to be real.
    756             # A higher value is better.
    757         "referenceBases": "A String", # The reference bases for this variant. They start at the given
    758             # position.
    759       },
    760     ],
    761     "infoMergeConfig": { # A mapping between info field keys and the InfoMergeOperations to
    762         # be performed on them.
    763       "a_key": "A String",
    764     },
    765   }
    766 
    767   x__xgafv: string, V1 error format.
    768     Allowed values
    769       1 - v1 error format
    770       2 - v2 error format
    771 
    772 Returns:
    773   An object of the form:
    774 
    775     { # A generic empty message that you can re-use to avoid defining duplicated
    776       # empty messages in your APIs. A typical example is to use it as the request
    777       # or the response type of an API method. For instance:
    778       #
    779       #     service Foo {
    780       #       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
    781       #     }
    782       #
    783       # The JSON representation for `Empty` is empty JSON object `{}`.
    784   }</pre>
    785 </div>
    786 
    787 <div class="method">
    788     <code class="details" id="patch">patch(variantId, body, x__xgafv=None, updateMask=None)</code>
    789   <pre>Updates a variant.
    790 
    791 For the definitions of variants and other genomics resources, see
    792 [Fundamentals of Google
    793 Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    794 
    795 This method supports patch semantics. Returns the modified variant without
    796 its calls.
    797 
    798 Args:
    799   variantId: string, The ID of the variant to be updated. (required)
    800   body: object, The request body. (required)
    801     The object takes the form of:
    802 
    803 { # A variant represents a change in DNA sequence relative to a reference
    804     # sequence. For example, a variant could represent a SNP or an insertion.
    805     # Variants belong to a variant set.
    806     # 
    807     # For more genomics resource definitions, see [Fundamentals of Google
    808     # Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    809     # 
    810     # Each of the calls on a variant represent a determination of genotype with
    811     # respect to that variant. For example, a call might assign probability of 0.32
    812     # to the occurrence of a SNP named rs1234 in a sample named NA12345. A call
    813     # belongs to a call set, which contains related calls typically from one
    814     # sample.
    815   "info": { # A map of additional variant information. This must be of the form
    816       # map<string, string[]> (string key mapping to a list of string values).
    817     "a_key": [
    818       "",
    819     ],
    820   },
    821   "variantSetId": "A String", # The ID of the variant set this variant belongs to.
    822   "end": "A String", # The end position (0-based) of this variant. This corresponds to the first
    823       # base after the last base in the reference allele. So, the length of
    824       # the reference allele is (end - start). This is useful for variants
    825       # that don't explicitly give alternate bases, for example large deletions.
    826   "calls": [ # The variant calls for this particular variant. Each one represents the
    827       # determination of genotype with respect to this variant.
    828     { # A call represents the determination of genotype with respect to a particular
    829         # variant. It may include associated information such as quality and phasing.
    830         # For example, a call might assign a probability of 0.32 to the occurrence of
    831         # a SNP named rs1234 in a call set with the name NA12345.
    832       "info": { # A map of additional variant call information. This must be of the form
    833           # map<string, string[]> (string key mapping to a list of string values).
    834         "a_key": [
    835           "",
    836         ],
    837       },
    838       "genotype": [ # The genotype of this variant call. Each value represents either the value
    839           # of the `referenceBases` field or a 1-based index into
    840           # `alternateBases`. If a variant had a `referenceBases`
    841           # value of `T` and an `alternateBases`
    842           # value of `["A", "C"]`, and the `genotype` was
    843           # `[2, 1]`, that would mean the call
    844           # represented the heterozygous value `CA` for this variant.
    845           # If the `genotype` was instead `[0, 1]`, the
    846           # represented value would be `TA`. Ordering of the
    847           # genotype values is important if the `phaseset` is present.
    848           # If a genotype is not called (that is, a `.` is present in the
    849           # GT string) -1 is returned.
    850         42,
    851       ],
    852       "callSetId": "A String", # The ID of the call set this variant call belongs to.
    853       "phaseset": "A String", # If this field is present, this variant call's genotype ordering implies
    854           # the phase of the bases and is consistent with any other variant calls in
    855           # the same reference sequence which have the same phaseset value.
    856           # When importing data from VCF, if the genotype data was phased but no
    857           # phase set was specified this field will be set to `*`.
    858       "genotypeLikelihood": [ # The genotype likelihoods for this variant call. Each array entry
    859           # represents how likely a specific genotype is for this call. The value
    860           # ordering is defined by the GL tag in the VCF spec.
    861           # If Phred-scaled genotype likelihood scores (PL) are available and
    862           # log10(P) genotype likelihood scores (GL) are not, PL scores are converted
    863           # to GL scores.  If both are available, PL scores are stored in `info`.
    864         3.14,
    865       ],
    866       "callSetName": "A String", # The name of the call set this variant call belongs to.
    867     },
    868   ],
    869   "created": "A String", # The date this variant was created, in milliseconds from the epoch.
    870   "id": "A String", # The server-generated variant ID, unique across all variants.
    871   "filter": [ # A list of filters (normally quality filters) this variant has failed.
    872       # `PASS` indicates this variant has passed all filters.
    873     "A String",
    874   ],
    875   "start": "A String", # The position at which this variant occurs (0-based).
    876       # This corresponds to the first base of the string of reference bases.
    877   "names": [ # Names for the variant, for example a RefSNP ID.
    878     "A String",
    879   ],
    880   "alternateBases": [ # The bases that appear instead of the reference bases.
    881     "A String",
    882   ],
    883   "referenceName": "A String", # The reference on which this variant occurs.
    884       # (such as `chr20` or `X`)
    885   "quality": 3.14, # A measure of how likely this variant is to be real.
    886       # A higher value is better.
    887   "referenceBases": "A String", # The reference bases for this variant. They start at the given
    888       # position.
    889 }
    890 
    891   x__xgafv: string, V1 error format.
    892     Allowed values
    893       1 - v1 error format
    894       2 - v2 error format
    895   updateMask: string, An optional mask specifying which fields to update. At this time, mutable
    896 fields are names and
    897 info. Acceptable values are "names" and
    898 "info". If unspecified, all mutable fields will be updated.
    899 
    900 Returns:
    901   An object of the form:
    902 
    903     { # A variant represents a change in DNA sequence relative to a reference
    904       # sequence. For example, a variant could represent a SNP or an insertion.
    905       # Variants belong to a variant set.
    906       #
    907       # For more genomics resource definitions, see [Fundamentals of Google
    908       # Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    909       #
    910       # Each of the calls on a variant represent a determination of genotype with
    911       # respect to that variant. For example, a call might assign probability of 0.32
    912       # to the occurrence of a SNP named rs1234 in a sample named NA12345. A call
    913       # belongs to a call set, which contains related calls typically from one
    914       # sample.
    915     "info": { # A map of additional variant information. This must be of the form
    916         # map<string, string[]> (string key mapping to a list of string values).
    917       "a_key": [
    918         "",
    919       ],
    920     },
    921     "variantSetId": "A String", # The ID of the variant set this variant belongs to.
    922     "end": "A String", # The end position (0-based) of this variant. This corresponds to the first
    923         # base after the last base in the reference allele. So, the length of
    924         # the reference allele is (end - start). This is useful for variants
    925         # that don't explicitly give alternate bases, for example large deletions.
    926     "calls": [ # The variant calls for this particular variant. Each one represents the
    927         # determination of genotype with respect to this variant.
    928       { # A call represents the determination of genotype with respect to a particular
    929           # variant. It may include associated information such as quality and phasing.
    930           # For example, a call might assign a probability of 0.32 to the occurrence of
    931           # a SNP named rs1234 in a call set with the name NA12345.
    932         "info": { # A map of additional variant call information. This must be of the form
    933             # map<string, string[]> (string key mapping to a list of string values).
    934           "a_key": [
    935             "",
    936           ],
    937         },
    938         "genotype": [ # The genotype of this variant call. Each value represents either the value
    939             # of the `referenceBases` field or a 1-based index into
    940             # `alternateBases`. If a variant had a `referenceBases`
    941             # value of `T` and an `alternateBases`
    942             # value of `["A", "C"]`, and the `genotype` was
    943             # `[2, 1]`, that would mean the call
    944             # represented the heterozygous value `CA` for this variant.
    945             # If the `genotype` was instead `[0, 1]`, the
    946             # represented value would be `TA`. Ordering of the
    947             # genotype values is important if the `phaseset` is present.
    948             # If a genotype is not called (that is, a `.` is present in the
    949             # GT string) -1 is returned.
    950           42,
    951         ],
    952         "callSetId": "A String", # The ID of the call set this variant call belongs to.
    953         "phaseset": "A String", # If this field is present, this variant call's genotype ordering implies
    954             # the phase of the bases and is consistent with any other variant calls in
    955             # the same reference sequence which have the same phaseset value.
    956             # When importing data from VCF, if the genotype data was phased but no
    957             # phase set was specified this field will be set to `*`.
    958         "genotypeLikelihood": [ # The genotype likelihoods for this variant call. Each array entry
    959             # represents how likely a specific genotype is for this call. The value
    960             # ordering is defined by the GL tag in the VCF spec.
    961             # If Phred-scaled genotype likelihood scores (PL) are available and
    962             # log10(P) genotype likelihood scores (GL) are not, PL scores are converted
    963             # to GL scores.  If both are available, PL scores are stored in `info`.
    964           3.14,
    965         ],
    966         "callSetName": "A String", # The name of the call set this variant call belongs to.
    967       },
    968     ],
    969     "created": "A String", # The date this variant was created, in milliseconds from the epoch.
    970     "id": "A String", # The server-generated variant ID, unique across all variants.
    971     "filter": [ # A list of filters (normally quality filters) this variant has failed.
    972         # `PASS` indicates this variant has passed all filters.
    973       "A String",
    974     ],
    975     "start": "A String", # The position at which this variant occurs (0-based).
    976         # This corresponds to the first base of the string of reference bases.
    977     "names": [ # Names for the variant, for example a RefSNP ID.
    978       "A String",
    979     ],
    980     "alternateBases": [ # The bases that appear instead of the reference bases.
    981       "A String",
    982     ],
    983     "referenceName": "A String", # The reference on which this variant occurs.
    984         # (such as `chr20` or `X`)
    985     "quality": 3.14, # A measure of how likely this variant is to be real.
    986         # A higher value is better.
    987     "referenceBases": "A String", # The reference bases for this variant. They start at the given
    988         # position.
    989   }</pre>
    990 </div>
    991 
    992 <div class="method">
    993     <code class="details" id="search">search(body, x__xgafv=None)</code>
    994   <pre>Gets a list of variants matching the criteria.
    995 
    996 For the definitions of variants and other genomics resources, see
    997 [Fundamentals of Google
    998 Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
    999 
   1000 Implements
   1001 [GlobalAllianceApi.searchVariants](https://github.com/ga4gh/schemas/blob/v0.5.1/src/main/resources/avro/variantmethods.avdl#L126).
   1002 
   1003 Args:
   1004   body: object, The request body. (required)
   1005     The object takes the form of:
   1006 
   1007 { # The variant search request.
   1008     "end": "A String", # The end of the window, 0-based exclusive. If unspecified or 0, defaults to
   1009         # the length of the reference.
   1010     "pageSize": 42, # The maximum number of variants to return in a single page. If unspecified,
   1011         # defaults to 5000. The maximum value is 10000.
   1012     "start": "A String", # The beginning of the window (0-based, inclusive) for which
   1013         # overlapping variants should be returned. If unspecified, defaults to 0.
   1014     "maxCalls": 42, # The maximum number of calls to return in a single page. Note that this
   1015         # limit may be exceeded in the event that a matching variant contains more
   1016         # calls than the requested maximum. If unspecified, defaults to 5000. The
   1017         # maximum value is 10000.
   1018     "pageToken": "A String", # The continuation token, which is used to page through large result sets.
   1019         # To get the next page of results, set this parameter to the value of
   1020         # `nextPageToken` from the previous response.
   1021     "variantSetIds": [ # At most one variant set ID must be provided. Only variants from this
   1022         # variant set will be returned. If omitted, a call set id must be included in
   1023         # the request.
   1024       "A String",
   1025     ],
   1026     "variantName": "A String", # Only return variants which have exactly this name.
   1027     "referenceName": "A String", # Required. Only return variants in this reference sequence.
   1028     "callSetIds": [ # Only return variant calls which belong to call sets with these ids.
   1029         # Leaving this blank returns all variant calls. If a variant has no
   1030         # calls belonging to any of these call sets, it won't be returned at all.
   1031       "A String",
   1032     ],
   1033   }
   1034 
   1035   x__xgafv: string, V1 error format.
   1036     Allowed values
   1037       1 - v1 error format
   1038       2 - v2 error format
   1039 
   1040 Returns:
   1041   An object of the form:
   1042 
   1043     { # The variant search response.
   1044     "nextPageToken": "A String", # The continuation token, which is used to page through large result sets.
   1045         # Provide this value in a subsequent request to return the next page of
   1046         # results. This field will be empty if there aren't any additional results.
   1047     "variants": [ # The list of matching Variants.
   1048       { # A variant represents a change in DNA sequence relative to a reference
   1049           # sequence. For example, a variant could represent a SNP or an insertion.
   1050           # Variants belong to a variant set.
   1051           #
   1052           # For more genomics resource definitions, see [Fundamentals of Google
   1053           # Genomics](https://cloud.google.com/genomics/fundamentals-of-google-genomics)
   1054           #
   1055           # Each of the calls on a variant represent a determination of genotype with
   1056           # respect to that variant. For example, a call might assign probability of 0.32
   1057           # to the occurrence of a SNP named rs1234 in a sample named NA12345. A call
   1058           # belongs to a call set, which contains related calls typically from one
   1059           # sample.
   1060         "info": { # A map of additional variant information. This must be of the form
   1061             # map<string, string[]> (string key mapping to a list of string values).
   1062           "a_key": [
   1063             "",
   1064           ],
   1065         },
   1066         "variantSetId": "A String", # The ID of the variant set this variant belongs to.
   1067         "end": "A String", # The end position (0-based) of this variant. This corresponds to the first
   1068             # base after the last base in the reference allele. So, the length of
   1069             # the reference allele is (end - start). This is useful for variants
   1070             # that don't explicitly give alternate bases, for example large deletions.
   1071         "calls": [ # The variant calls for this particular variant. Each one represents the
   1072             # determination of genotype with respect to this variant.
   1073           { # A call represents the determination of genotype with respect to a particular
   1074               # variant. It may include associated information such as quality and phasing.
   1075               # For example, a call might assign a probability of 0.32 to the occurrence of
   1076               # a SNP named rs1234 in a call set with the name NA12345.
   1077             "info": { # A map of additional variant call information. This must be of the form
   1078                 # map<string, string[]> (string key mapping to a list of string values).
   1079               "a_key": [
   1080                 "",
   1081               ],
   1082             },
   1083             "genotype": [ # The genotype of this variant call. Each value represents either the value
   1084                 # of the `referenceBases` field or a 1-based index into
   1085                 # `alternateBases`. If a variant had a `referenceBases`
   1086                 # value of `T` and an `alternateBases`
   1087                 # value of `["A", "C"]`, and the `genotype` was
   1088                 # `[2, 1]`, that would mean the call
   1089                 # represented the heterozygous value `CA` for this variant.
   1090                 # If the `genotype` was instead `[0, 1]`, the
   1091                 # represented value would be `TA`. Ordering of the
   1092                 # genotype values is important if the `phaseset` is present.
   1093                 # If a genotype is not called (that is, a `.` is present in the
   1094                 # GT string) -1 is returned.
   1095               42,
   1096             ],
   1097             "callSetId": "A String", # The ID of the call set this variant call belongs to.
   1098             "phaseset": "A String", # If this field is present, this variant call's genotype ordering implies
   1099                 # the phase of the bases and is consistent with any other variant calls in
   1100                 # the same reference sequence which have the same phaseset value.
   1101                 # When importing data from VCF, if the genotype data was phased but no
   1102                 # phase set was specified this field will be set to `*`.
   1103             "genotypeLikelihood": [ # The genotype likelihoods for this variant call. Each array entry
   1104                 # represents how likely a specific genotype is for this call. The value
   1105                 # ordering is defined by the GL tag in the VCF spec.
   1106                 # If Phred-scaled genotype likelihood scores (PL) are available and
   1107                 # log10(P) genotype likelihood scores (GL) are not, PL scores are converted
   1108                 # to GL scores.  If both are available, PL scores are stored in `info`.
   1109               3.14,
   1110             ],
   1111             "callSetName": "A String", # The name of the call set this variant call belongs to.
   1112           },
   1113         ],
   1114         "created": "A String", # The date this variant was created, in milliseconds from the epoch.
   1115         "id": "A String", # The server-generated variant ID, unique across all variants.
   1116         "filter": [ # A list of filters (normally quality filters) this variant has failed.
   1117             # `PASS` indicates this variant has passed all filters.
   1118           "A String",
   1119         ],
   1120         "start": "A String", # The position at which this variant occurs (0-based).
   1121             # This corresponds to the first base of the string of reference bases.
   1122         "names": [ # Names for the variant, for example a RefSNP ID.
   1123           "A String",
   1124         ],
   1125         "alternateBases": [ # The bases that appear instead of the reference bases.
   1126           "A String",
   1127         ],
   1128         "referenceName": "A String", # The reference on which this variant occurs.
   1129             # (such as `chr20` or `X`)
   1130         "quality": 3.14, # A measure of how likely this variant is to be real.
   1131             # A higher value is better.
   1132         "referenceBases": "A String", # The reference bases for this variant. They start at the given
   1133             # position.
   1134       },
   1135     ],
   1136   }</pre>
   1137 </div>
   1138 
   1139 <div class="method">
   1140     <code class="details" id="search_next">search_next(previous_request, previous_response)</code>
   1141   <pre>Retrieves the next page of results.
   1142 
   1143 Args:
   1144   previous_request: The request for the previous page. (required)
   1145   previous_response: The response from the request for the previous page. (required)
   1146 
   1147 Returns:
   1148   A request object that you can call 'execute()' on to request the next
   1149   page. Returns None if there are no more items in the collection.
   1150     </pre>
   1151 </div>
   1152 
   1153 </body></html>