googleapis/build/src/apis/genomics/v1.d.ts

Google APIs Client Library for Node.js

/**
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
 * Genomics API
 *
 * Upload, process, query, and search Genomics data in the cloud.
 *
 * @example
 * const google = require('googleapis');
 * const genomics = google.genomics('v1');
 *
 * @namespace genomics
 * @type {Function}
 * @version v1
 * @variation v1
 * @param {object=} options Options for Genomics
 */
export declare class Genomics {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    annotations: Resource$Annotations;
    annotationsets: Resource$Annotationsets;
    callsets: Resource$Callsets;
    datasets: Resource$Datasets;
    operations: Resource$Operations;
    readgroupsets: Resource$Readgroupsets;
    reads: Resource$Reads;
    references: Resource$References;
    referencesets: Resource$Referencesets;
    variants: Resource$Variants;
    variantsets: Resource$Variantsets;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * An annotation describes a region of reference genome. The value of an
 * annotation may be one of several canonical types, supplemented by arbitrary
 * info tags. An annotation is not inherently associated with a specific sample
 * or individual (though a client could choose to use annotations in this way).
 * Example canonical annotation types are `GENE` and `VARIANT`.
 */
export interface Schema$Annotation {
    /**
     * The annotation set to which this annotation belongs.
     */
    annotationSetId: string;
    /**
     * The end position of the range on the reference, 0-based exclusive.
     */
    end: string;
    /**
     * The server-generated annotation ID, unique across all annotations.
     */
    id: string;
    /**
     * A map of additional read alignment information. This must be of the form
     * map<string, string[]> (string key mapping to a list of string
     * values).
     */
    info: any;
    /**
     * The display name of this annotation.
     */
    name: string;
    /**
     * The ID of the Google Genomics reference associated with this range.
     */
    referenceId: string;
    /**
     * The display name corresponding to the reference specified by `referenceId`,
     * for example `chr1`, `1`, or `chrX`.
     */
    referenceName: string;
    /**
     * Whether this range refers to the reverse strand, as opposed to the forward
     * strand. Note that regardless of this field, the start/end position of the
     * range always refer to the forward strand.
     */
    reverseStrand: boolean;
    /**
     * The start position of the range on the reference, 0-based inclusive.
     */
    start: string;
    /**
     * A transcript value represents the assertion that a particular region of the
     * reference genome may be transcribed as RNA. An alternative splicing pattern
     * would be represented as a separate transcript object. This field is only
     * set for annotations of type `TRANSCRIPT`.
     */
    transcript: Schema$Transcript;
    /**
     * The data type for this annotation. Must match the containing annotation
     * set's type.
     */
    type: string;
    /**
     * A variant annotation, which describes the effect of a variant on the
     * genome, the coding sequence, and/or higher level consequences at the
     * organism level e.g. pathogenicity. This field is only set for annotations
     * of type `VARIANT`.
     */
    variant: Schema$VariantAnnotation;
}
/**
 * An annotation set is a logical grouping of annotations that share consistent
 * type information and provenance. Examples of annotation sets include 'all
 * genes from refseq', and 'all variant annotations from ClinVar'.
 */
export interface Schema$AnnotationSet {
    /**
     * The dataset to which this annotation set belongs.
     */
    datasetId: string;
    /**
     * The server-generated annotation set ID, unique across all annotation sets.
     */
    id: string;
    /**
     * A map of additional read alignment information. This must be of the form
     * map<string, string[]> (string key mapping to a list of string
     * values).
     */
    info: any;
    /**
     * The display name for this annotation set.
     */
    name: string;
    /**
     * The ID of the reference set that defines the coordinate space for this
     * set's annotations.
     */
    referenceSetId: string;
    /**
     * The source URI describing the file from which this annotation set was
     * generated, if any.
     */
    sourceUri: string;
    /**
     * The type of annotations contained within this set.
     */
    type: string;
}
export interface Schema$BatchCreateAnnotationsRequest {
    /**
     * The annotations to be created. At most 4096 can be specified in a single
     * request.
     */
    annotations: Schema$Annotation[];
    /**
     * A unique request ID which enables the server to detect duplicated requests.
     * If provided, duplicated requests will result in the same response; if not
     * provided, duplicated requests may result in duplicated data. For a given
     * annotation set, callers should not reuse `request_id`s when writing
     * different batches of annotations - behavior in this case is undefined. A
     * common approach is to use a UUID. For batch jobs where worker crashes are a
     * possibility, consider using some unique variant of a worker or run ID.
     */
    requestId: string;
}
export interface Schema$BatchCreateAnnotationsResponse {
    /**
     * The resulting per-annotation entries, ordered consistently with the
     * original request.
     */
    entries: Schema$Entry[];
}
/**
 * Associates `members` with a `role`.
 */
export interface Schema$Binding {
    /**
     * Specifies the identities requesting access for a Cloud Platform resource.
     * `members` can have the following values:  * `allUsers`: A special
     * identifier that represents anyone who is    on the internet; with or
     * without a Google account.  * `allAuthenticatedUsers`: A special identifier
     * that represents anyone    who is authenticated with a Google account or a
     * service account.  * `user:{emailid}`: An email address that represents a
     * specific Google    account. For example, `alice@gmail.com` or
     * `joe@example.com`.   * `serviceAccount:{emailid}`: An email address that
     * represents a service    account. For example,
     * `my-other-app@appspot.gserviceaccount.com`.  * `group:{emailid}`: An email
     * address that represents a Google group.    For example,
     * `admins@example.com`.   * `domain:{domain}`: A Google Apps domain name that
     * represents all the    users of that domain. For example, `google.com` or
     * `example.com`.
     */
    members: string[];
    /**
     * Role that is assigned to `members`. For example, `roles/viewer`,
     * `roles/editor`, or `roles/owner`. Required
     */
    role: string;
}
/**
 * A call set is a collection of variant calls, typically for one sample. It
 * belongs to a variant set.
 */
export interface Schema$CallSet {
    /**
     * The date this call set was created in milliseconds from the epoch.
     */
    created: string;
    /**
     * The server-generated call set ID, unique across all call sets.
     */
    id: string;
    /**
     * A map of additional call set information. This must be of the form
     * map<string, string[]> (string key mapping to a list of string
     * values).
     */
    info: any;
    /**
     * The call set name.
     */
    name: string;
    /**
     * The sample ID this call set corresponds to.
     */
    sampleId: string;
    /**
     * The IDs of the variant sets this call set belongs to. This field must have
     * exactly length one, as a call set belongs to a single variant set. This
     * field is repeated for compatibility with the [GA4GH 0.5.1
     * API](https://github.com/ga4gh/schemas/blob/v0.5.1/src/main/resources/avro/variants.avdl#L76).
     */
    variantSetIds: string[];
}
/**
 * The request message for Operations.CancelOperation.
 */
export interface Schema$CancelOperationRequest {
}
/**
 * A single CIGAR operation.
 */
export interface Schema$CigarUnit {
    operation: string;
    /**
     * The number of genomic bases that the operation runs for. Required.
     */
    operationLength: string;
    /**
     * `referenceSequence` is only used at mismatches (`SEQUENCE_MISMATCH`) and
     * deletions (`DELETE`). Filling this field replaces SAM's MD tag. If the
     * relevant information is not available, this field is unset.
     */
    referenceSequence: string;
}
export interface Schema$ClinicalCondition {
    /**
     * The MedGen concept id associated with this gene. Search for these IDs at
     * http://www.ncbi.nlm.nih.gov/medgen/
     */
    conceptId: string;
    /**
     * The set of external IDs for this condition.
     */
    externalIds: Schema$ExternalId[];
    /**
     * A set of names for the condition.
     */
    names: string[];
    /**
     * The OMIM id for this condition. Search for these IDs at http://omim.org/
     */
    omimId: string;
}
export interface Schema$CodingSequence {
    /**
     * The end of the coding sequence on this annotation's reference sequence,
     * 0-based exclusive. Note that this position is relative to the reference
     * start, and *not* the containing annotation start.
     */
    end: string;
    /**
     * The start of the coding sequence on this annotation's reference
     * sequence, 0-based inclusive. Note that this position is relative to the
     * reference start, and *not* the containing annotation start.
     */
    start: string;
}
/**
 * Describes a Compute Engine resource that is being managed by a running
 * pipeline.
 */
export interface Schema$ComputeEngine {
    /**
     * The names of the disks that were created for this pipeline.
     */
    diskNames: string[];
    /**
     * The instance on which the operation is running.
     */
    instanceName: string;
    /**
     * The machine type of the instance.
     */
    machineType: string;
    /**
     * The availability zone in which the instance resides.
     */
    zone: string;
}
/**
 * This event is generated when a container starts.
 */
export interface Schema$ContainerStartedEvent {
    /**
     * The numeric ID of the action that started this container.
     */
    actionId: number;
    /**
     * The public IP address that can be used to connect to the container.  This
     * field is only populated when at least one port mapping is present.  If the
     * instance was created with a private address this field will be empty even
     * if port mappings exist.
     */
    ipAddress: string;
    /**
     * The container to host port mappings installed for this container.  This set
     * will contain any ports exposed using the PUBLISH_EXPOSED_PORTS flag as well
     * as any specified in the Action definition.
     */
    portMappings: any;
}
/**
 * This event is generated when a container exits.
 */
export interface Schema$ContainerStoppedEvent {
    /**
     * The numeric ID of the action that started this container.
     */
    actionId: number;
    /**
     * The exit status of the container.
     */
    exitStatus: number;
}
/**
 * A bucket over which read coverage has been precomputed. A bucket corresponds
 * to a specific range of the reference sequence.
 */
export interface Schema$CoverageBucket {
    /**
     * The average number of reads which are aligned to each individual reference
     * base in this bucket.
     */
    meanCoverage: number;
    /**
     * The genomic coordinate range spanned by this bucket.
     */
    range: Schema$Range;
}
/**
 * A Dataset is a collection of genomic data.
 */
export interface Schema$Dataset {
    /**
     * The time this dataset was created, in seconds from the epoch.
     */
    createTime: string;
    /**
     * The server-generated dataset ID, unique across all datasets.
     */
    id: string;
    /**
     * The dataset name.
     */
    name: string;
    /**
     * The Google Cloud project ID that this dataset belongs to.
     */
    projectId: string;
}
/**
 * This event is generated whenever a resource limitation or transient error
 * delays execution of a pipeline that was otherwise ready to run.
 */
export interface Schema$DelayedEvent {
    /**
     * A textual description of the cause of the delay.  The string may change
     * without notice since it is often generated by another service (such as
     * Compute Engine).
     */
    cause: string;
    /**
     * If the delay was caused by a resource shortage, this field lists the
     * Compute Engine metrics that are preventing this operation from running (for
     * example, CPUS or INSTANCES).  If the particular metric is not known, a
     * single UNKNOWN metric will be present.
     */
    metrics: string[];
}
/**
 * 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 `{}`.
 */
export interface Schema$Empty {
}
export interface Schema$Entry {
    /**
     * The created annotation, if creation was successful.
     */
    annotation: Schema$Annotation;
    /**
     * The creation status.
     */
    status: Schema$Status;
}
/**
 * Event carries information about events that occur during pipeline execution.
 */
export interface Schema$Event {
    /**
     * A human readable description of the event.  Note that these strings may
     * change at any time without notice.  Any application logic must use the
     * information in the details field.
     */
    description: string;
    /**
     * Machine readable details about the event.
     */
    details: any;
    /**
     * The time that the event occurred.
     */
    timestamp: string;
}
export interface Schema$Exon {
    /**
     * The end position of the exon on this annotation's reference sequence,
     * 0-based exclusive. Note that this is relative to the reference start, and
     * *not* the containing annotation start.
     */
    end: string;
    /**
     * The frame of this exon. Contains a value of 0, 1, or 2, which indicates the
     * offset of the first coding base of the exon within the reading frame of the
     * coding DNA sequence, if any. This field is dependent on the strandedness of
     * this annotation (see Annotation.reverse_strand). For forward stranded
     * annotations, this offset is relative to the exon.start. For reverse strand
     * annotations, this offset is relative to the exon.end `- 1`.  Unset if this
     * exon does not intersect the coding sequence. Upon creation of a transcript,
     * the frame must be populated for all or none of the coding exons.
     */
    frame: number;
    /**
     * The start position of the exon on this annotation's reference sequence,
     * 0-based inclusive. Note that this is relative to the reference start, and
     * **not** the containing annotation start.
     */
    start: string;
}
export interface Schema$Experiment {
    /**
     * The instrument model used as part of this experiment. This maps to
     * sequencing technology in the SAM spec.
     */
    instrumentModel: string;
    /**
     * A client-supplied library identifier; a library is a collection of DNA
     * fragments which have been prepared for sequencing from a sample. This field
     * is important for quality control as error or bias can be introduced during
     * sample preparation.
     */
    libraryId: string;
    /**
     * The platform unit used as part of this experiment, for example
     * flowcell-barcode.lane for Illumina or slide for SOLiD. Corresponds to the
     * @RG PU field in the SAM spec.
     */
    platformUnit: string;
    /**
     * The sequencing center used as part of this experiment.
     */
    sequencingCenter: string;
}
/**
 * The read group set export request.
 */
export interface Schema$ExportReadGroupSetRequest {
    /**
     * Required. A Google Cloud Storage URI for the exported BAM file. The
     * currently authenticated user must have write access to the new file. An
     * error will be returned if the URI already contains data.
     */
    exportUri: string;
    /**
     * Required. The Google Cloud project ID that owns this export. The caller
     * must have WRITE access to this project.
     */
    projectId: string;
    /**
     * The reference names to export. If this is not specified, all reference
     * sequences, including unmapped reads, are exported. Use `*` to export only
     * unmapped reads.
     */
    referenceNames: string[];
}
/**
 * The variant data export request.
 */
export interface Schema$ExportVariantSetRequest {
    /**
     * Required. The BigQuery dataset to export data to. This dataset must already
     * exist. Note that this is distinct from the Genomics concept of
     * "dataset".
     */
    bigqueryDataset: string;
    /**
     * Required. The BigQuery table to export data to. If the table doesn't
     * exist, it will be created. If it already exists, it will be overwritten.
     */
    bigqueryTable: string;
    /**
     * If provided, only variant call information from the specified call sets
     * will be exported. By default all variant calls are exported.
     */
    callSetIds: string[];
    /**
     * The format for the exported data.
     */
    format: string;
    /**
     * Required. The Google Cloud project ID that owns the destination BigQuery
     * dataset. The caller must have WRITE access to this project.  This project
     * will also own the resulting export job.
     */
    projectId: string;
}
export interface Schema$ExternalId {
    /**
     * The id used by the source of this data.
     */
    id: string;
    /**
     * The name of the source of this data.
     */
    sourceName: string;
}
/**
 * This event is generated when the execution of a pipeline has failed.  Note
 * that other events may continue to occur after this event.
 */
export interface Schema$FailedEvent {
    /**
     * The human readable description of the cause of the failure.
     */
    cause: string;
    /**
     * The Google standard error code that best describes this failure.
     */
    code: string;
}
/**
 * Request message for `GetIamPolicy` method.
 */
export interface Schema$GetIamPolicyRequest {
}
/**
 * The read group set import request.
 */
export interface Schema$ImportReadGroupSetsRequest {
    /**
     * Required. The ID of the dataset these read group sets will belong to. The
     * caller must have WRITE permissions to this dataset.
     */
    datasetId: string;
    /**
     * The partition strategy describes how read groups are partitioned into read
     * group sets.
     */
    partitionStrategy: string;
    /**
     * The reference set to which the imported read group sets are aligned to, if
     * any. The reference names of this reference set must be a superset of those
     * found in the imported file headers. If no reference set id is provided, a
     * best effort is made to associate with a matching reference set.
     */
    referenceSetId: string;
    /**
     * A list of URIs pointing at [BAM
     * files](https://samtools.github.io/hts-specs/SAMv1.pdf) in Google Cloud
     * Storage. Those URIs can include wildcards (*), but do not add or remove
     * matching files before import has completed.  Note that Google Cloud Storage
     * object listing is only eventually consistent: files added may be not be
     * immediately visible to everyone. Thus, if using a wildcard it is preferable
     * not to start the import immediately after the files are created.
     */
    sourceUris: string[];
}
/**
 * The read group set import response.
 */
export interface Schema$ImportReadGroupSetsResponse {
    /**
     * IDs of the read group sets that were created.
     */
    readGroupSetIds: string[];
}
/**
 * The variant data import request.
 */
export interface Schema$ImportVariantsRequest {
    /**
     * The format of the variant data being imported. If unspecified, defaults to
     * to `VCF`.
     */
    format: string;
    /**
     * A mapping between info field keys and the InfoMergeOperations to be
     * performed on them. This is plumbed down to the MergeVariantRequests
     * generated by the resulting import job.
     */
    infoMergeConfig: any;
    /**
     * Convert reference names to the canonical representation. hg19 haploytypes
     * (those reference names containing "_hap") are not modified in any
     * way. All other reference names are modified according to the following
     * rules: The reference name is capitalized. The "chr" prefix is
     * dropped for all autosomes and sex chromsomes. For example "chr17"
     * becomes "17" and "chrX" becomes "X". All
     * mitochondrial chromosomes ("chrM", "chrMT", etc) become
     * "MT".
     */
    normalizeReferenceNames: boolean;
    /**
     * A list of URIs referencing variant files in Google Cloud Storage. URIs can
     * include wildcards [as described
     * here](https://cloud.google.com/storage/docs/gsutil/addlhelp/WildcardNames).
     * Note that recursive wildcards ('**') are not supported.
     */
    sourceUris: string[];
    /**
     * Required. The variant set to which variant data should be imported.
     */
    variantSetId: string;
}
/**
 * The variant data import response.
 */
export interface Schema$ImportVariantsResponse {
    /**
     * IDs of the call sets created during the import.
     */
    callSetIds: string[];
}
/**
 * A linear alignment can be represented by one CIGAR string. Describes the
 * mapped position and local alignment of the read to the reference.
 */
export interface Schema$LinearAlignment {
    /**
     * Represents the local alignment of this sequence (alignment matches, indels,
     * etc) against the reference.
     */
    cigar: Schema$CigarUnit[];
    /**
     * The mapping quality of this alignment. Represents how likely the read maps
     * to this position as opposed to other locations.  Specifically, this is -10
     * log10 Pr(mapping position is wrong), rounded to the nearest integer.
     */
    mappingQuality: number;
    /**
     * The position of this alignment.
     */
    position: Schema$Position;
}
export interface Schema$ListBasesResponse {
    /**
     * The continuation token, which is used to page through large result sets.
     * Provide this value in a subsequent request to return the next page of
     * results. This field will be empty if there aren't any additional
     * results.
     */
    nextPageToken: string;
    /**
     * The offset position (0-based) of the given `sequence` from the start of
     * this `Reference`. This value will differ for each page in a paginated
     * request.
     */
    offset: string;
    /**
     * A substring of the bases that make up this reference.
     */
    sequence: string;
}
export interface Schema$ListCoverageBucketsResponse {
    /**
     * The length of each coverage bucket in base pairs. Note that buckets at the
     * end of a reference sequence may be shorter. This value is omitted if the
     * bucket width is infinity (the default behaviour, with no range or
     * `targetBucketWidth`).
     */
    bucketWidth: string;
    /**
     * The coverage buckets. The list of buckets is sparse; a bucket with 0
     * overlapping reads is not returned. A bucket never crosses more than one
     * reference sequence. Each bucket has width `bucketWidth`, unless its end is
     * the end of the reference sequence.
     */
    coverageBuckets: Schema$CoverageBucket[];
    /**
     * The continuation token, which is used to page through large result sets.
     * Provide this value in a subsequent request to return the next page of
     * results. This field will be empty if there aren't any additional
     * results.
     */
    nextPageToken: string;
}
/**
 * The dataset list response.
 */
export interface Schema$ListDatasetsResponse {
    /**
     * The list of matching Datasets.
     */
    datasets: Schema$Dataset[];
    /**
     * The continuation token, which is used to page through large result sets.
     * Provide this value in a subsequent request to return the next page of
     * results. This field will be empty if there aren't any additional
     * results.
     */
    nextPageToken: string;
}
/**
 * The response message for Operations.ListOperations.
 */
export interface Schema$ListOperationsResponse {
    /**
     * The standard List next-page token.
     */
    nextPageToken: string;
    /**
     * A list of operations that matches the specified filter in the request.
     */
    operations: Schema$Operation[];
}
export interface Schema$MergeVariantsRequest {
    /**
     * A mapping between info field keys and the InfoMergeOperations to be
     * performed on them.
     */
    infoMergeConfig: any;
    /**
     * The variants to be merged with existing variants.
     */
    variants: Schema$Variant[];
    /**
     * The destination variant set.
     */
    variantSetId: string;
}
/**
 * This resource represents a long-running operation that is the result of a
 * network API call.
 */
export interface Schema$Operation {
    /**
     * If the value is `false`, it means the operation is still in progress. If
     * `true`, the operation is completed, and either `error` or `response` is
     * available.
     */
    done: boolean;
    /**
     * The error result of the operation in case of failure or cancellation.
     */
    error: Schema$Status;
    /**
     * An OperationMetadata or Metadata object. This will always be returned with
     * the Operation.
     */
    metadata: any;
    /**
     * The server-assigned name, which is only unique within the same service that
     * originally returns it. For example:
     * `operations/CJHU7Oi_ChDrveSpBRjfuL-qzoWAgEw`
     */
    name: string;
    /**
     * If importing ReadGroupSets, an ImportReadGroupSetsResponse is returned. If
     * importing Variants, an ImportVariantsResponse is returned. For pipelines
     * and exports, an Empty response is returned.
     */
    response: any;
}
/**
 * An event that occurred during an Operation.
 */
export interface Schema$OperationEvent {
    /**
     * Required description of event.
     */
    description: string;
    /**
     * Optional time of when event finished. An event can have a start time and no
     * finish time. If an event has a finish time, there must be a start time.
     */
    endTime: string;
    /**
     * Optional time of when event started.
     */
    startTime: string;
}
/**
 * Metadata describing an Operation.
 */
export interface Schema$OperationMetadata {
    /**
     * This field is deprecated. Use `labels` instead. Optionally provided by the
     * caller when submitting the request that creates the operation.
     */
    clientId: string;
    /**
     * The time at which the job was submitted to the Genomics service.
     */
    createTime: string;
    /**
     * The time at which the job stopped running.
     */
    endTime: string;
    /**
     * Optional event messages that were generated during the job's execution.
     * This also contains any warnings that were generated during import or
     * export.
     */
    events: Schema$OperationEvent[];
    /**
     * Optionally provided by the caller when submitting the request that creates
     * the operation.
     */
    labels: any;
    /**
     * The Google Cloud Project in which the job is scoped.
     */
    projectId: string;
    /**
     * The original request that started the operation. Note that this will be in
     * current version of the API. If the operation was started with v1beta2 API
     * and a GetOperation is performed on v1 API, a v1 request will be returned.
     */
    request: any;
    /**
     * Runtime metadata on this Operation.
     */
    runtimeMetadata: any;
    /**
     * The time at which the job began to run.
     */
    startTime: string;
}
/**
 * Defines an Identity and Access Management (IAM) policy. It is used to specify
 * access control policies for Cloud Platform resources.   A `Policy` consists
 * of a list of `bindings`. A `Binding` binds a list of `members` to a `role`,
 * where the members can be user accounts, Google groups, Google domains, and
 * service accounts. A `role` is a named list of permissions defined by IAM.
 * **Example**      {       "bindings": [         { "role":
 * "roles/owner",           "members": [
 * "user:mike@example.com", "group:admins@example.com",
 * "domain:google.com",
 * "serviceAccount:my-other-app@appspot.gserviceaccount.com", ] }, {
 * "role": "roles/viewer",           "members":
 * ["user:sean@example.com"]         }       ]     }  For a
 * description of IAM and its features, see the [IAM developer's
 * guide](https://cloud.google.com/iam/docs).
 */
export interface Schema$Policy {
    /**
     * Associates a list of `members` to a `role`. `bindings` with no members will
     * result in an error.
     */
    bindings: Schema$Binding[];
    /**
     * `etag` is used for optimistic concurrency control as a way to help prevent
     * simultaneous updates of a policy from overwriting each other. It is
     * strongly suggested that systems make use of the `etag` in the
     * read-modify-write cycle to perform policy updates in order to avoid race
     * conditions: An `etag` is returned in the response to `getIamPolicy`, and
     * systems are expected to put that etag in the request to `setIamPolicy` to
     * ensure that their change will be applied to the same version of the policy.
     * If no `etag` is provided in the call to `setIamPolicy`, then the existing
     * policy is overwritten blindly.
     */
    etag: string;
    /**
     * Deprecated.
     */
    version: number;
}
/**
 * An abstraction for referring to a genomic position, in relation to some
 * already known reference. For now, represents a genomic position as a
 * reference name, a base number on that reference (0-based), and a
 * determination of forward or reverse strand.
 */
export interface Schema$Position {
    /**
     * The 0-based offset from the start of the forward strand for that reference.
     */
    position: string;
    /**
     * The name of the reference in whatever reference set is being used.
     */
    referenceName: string;
    /**
     * Whether this position is on the reverse strand, as opposed to the forward
     * strand.
     */
    reverseStrand: boolean;
}
export interface Schema$Program {
    /**
     * The command line used to run this program.
     */
    commandLine: string;
    /**
     * The user specified locally unique ID of the program. Used along with
     * `prevProgramId` to define an ordering between programs.
     */
    id: string;
    /**
     * The display name of the program. This is typically the colloquial name of
     * the tool used, for example 'bwa' or 'picard'.
     */
    name: string;
    /**
     * The ID of the program run before this one.
     */
    prevProgramId: string;
    /**
     * The version of the program run.
     */
    version: string;
}
/**
 * This event is generated when the worker starts pulling an image.
 */
export interface Schema$PullStartedEvent {
    /**
     * The URI of the image that was pulled.
     */
    imageUri: string;
}
/**
 * This event is generated when the worker stops pulling an image.
 */
export interface Schema$PullStoppedEvent {
    /**
     * The URI of the image that was pulled.
     */
    imageUri: string;
}
/**
 * A 0-based half-open genomic coordinate range for search requests.
 */
export interface Schema$Range {
    /**
     * The end position of the range on the reference, 0-based exclusive.
     */
    end: string;
    /**
     * The reference sequence name, for example `chr1`, `1`, or `chrX`.
     */
    referenceName: string;
    /**
     * The start position of the range on the reference, 0-based inclusive.
     */
    start: string;
}
/**
 * A read alignment describes a linear alignment of a string of DNA to a
 * reference sequence, in addition to metadata about the fragment (the molecule
 * of DNA sequenced) and the read (the bases which were read by the sequencer).
 * A read is equivalent to a line in a SAM file. A read belongs to exactly one
 * read group and exactly one read group set.  ### Reverse-stranded reads Mapped
 * reads (reads having a non-null `alignment`) can be aligned to either the
 * forward or the reverse strand of their associated reference. Strandedness of
 * a mapped read is encoded by `alignment.position.reverseStrand`.  If we
 * consider the reference to be a forward-stranded coordinate space of `[0,
 * reference.length)` with `0` as the left-most position and `reference.length`
 * as the right-most position, reads are always aligned left to right. That is,
 * `alignment.position.position` always refers to the left-most reference
 * coordinate and `alignment.cigar` describes the alignment of this read to the
 * reference from left to right. All per-base fields such as `alignedSequence`
 * and `alignedQuality` share this same left-to-right orientation; this is true
 * of reads which are aligned to either strand. For reverse-stranded reads, this
 * means that `alignedSequence` is the reverse complement of the bases that were
 * originally reported by the sequencing machine.  ### Generating a
 * reference-aligned sequence string  When interacting with mapped reads,
 * it's often useful to produce a string representing the local alignment of
 * the read to reference. The following pseudocode demonstrates one way of doing
 * this:      out = ""     offset = 0     for c in
 * read.alignment.cigar {       switch c.operation {       case
 * "ALIGNMENT_MATCH", "SEQUENCE_MATCH",
 * "SEQUENCE_MISMATCH":         out +=
 * read.alignedSequence[offset:offset+c.operationLength]         offset +=
 * c.operationLength         break       case "CLIP_SOFT",
 * "INSERT":         offset += c.operationLength         break case
 * "PAD":         out += repeat("*", c.operationLength)
 * break       case "DELETE":         out += repeat("-",
 * c.operationLength)         break       case "SKIP":         out +=
 * repeat(" ", c.operationLength)         break       case
 * "CLIP_HARD":         break       }     }     return out  ###
 * Converting to SAM's CIGAR string  The following pseudocode generates a
 * SAM CIGAR string from the `cigar` field. Note that this is a lossy conversion
 * (`cigar.referenceSequence` is lost).      cigarMap = {
 * "ALIGNMENT_MATCH": "M",       "INSERT":
 * "I",       "DELETE": "D", "SKIP":
 * "N",       "CLIP_SOFT": "S",
 * "CLIP_HARD": "H",       "PAD": "P",
 * "SEQUENCE_MATCH": "=", "SEQUENCE_MISMATCH":
 * "X",     }     cigarStr = ""     for c in
 * read.alignment.cigar {       cigarStr += c.operationLength +
 * cigarMap[c.operation]     }     return cigarStr
 */
export interface Schema$Read {
    /**
     * The quality of the read sequence contained in this alignment record
     * (equivalent to QUAL in SAM). `alignedSequence` and `alignedQuality` may be
     * shorter than the full read sequence and quality. This will occur if the
     * alignment is part of a chimeric alignment, or if the read was trimmed. When
     * this occurs, the CIGAR for this read will begin/end with a hard clip
     * operator that will indicate the length of the excised sequence.
     */
    alignedQuality: number[];
    /**
     * The bases of the read sequence contained in this alignment record,
     * **without CIGAR operations applied** (equivalent to SEQ in SAM).
     * `alignedSequence` and `alignedQuality` may be shorter than the full read
     * sequence and quality. This will occur if the alignment is part of a
     * chimeric alignment, or if the read was trimmed. When this occurs, the CIGAR
     * for this read will begin/end with a hard clip operator that will indicate
     * the length of the excised sequence.
     */
    alignedSequence: string;
    /**
     * The linear alignment for this alignment record. This field is null for
     * unmapped reads.
     */
    alignment: Schema$LinearAlignment;
    /**
     * The fragment is a PCR or optical duplicate (SAM flag 0x400).
     */
    duplicateFragment: boolean;
    /**
     * Whether this read did not pass filters, such as platform or vendor quality
     * controls (SAM flag 0x200).
     */
    failedVendorQualityChecks: boolean;
    /**
     * The observed length of the fragment, equivalent to TLEN in SAM.
     */
    fragmentLength: number;
    /**
     * The fragment name. Equivalent to QNAME (query template name) in SAM.
     */
    fragmentName: string;
    /**
     * The server-generated read ID, unique across all reads. This is different
     * from the `fragmentName`.
     */
    id: string;
    /**
     * A map of additional read alignment information. This must be of the form
     * map<string, string[]> (string key mapping to a list of string
     * values).
     */
    info: any;
    /**
     * The mapping of the primary alignment of the `(readNumber+1)%numberReads`
     * read in the fragment. It replaces mate position and mate strand in SAM.
     */
    nextMatePosition: Schema$Position;
    /**
     * The number of reads in the fragment (extension to SAM flag 0x1).
     */
    numberReads: number;
    /**
     * The orientation and the distance between reads from the fragment are
     * consistent with the sequencing protocol (SAM flag 0x2).
     */
    properPlacement: boolean;
    /**
     * The ID of the read group this read belongs to. A read belongs to exactly
     * one read group. This is a server-generated ID which is distinct from
     * SAM's RG tag (for that value, see ReadGroup.name).
     */
    readGroupId: string;
    /**
     * The ID of the read group set this read belongs to. A read belongs to
     * exactly one read group set.
     */
    readGroupSetId: string;
    /**
     * The read number in sequencing. 0-based and less than numberReads. This
     * field replaces SAM flag 0x40 and 0x80.
     */
    readNumber: number;
    /**
     * Whether this alignment is secondary. Equivalent to SAM flag 0x100. A
     * secondary alignment represents an alternative to the primary alignment for
     * this read. Aligners may return secondary alignments if a read can map
     * ambiguously to multiple coordinates in the genome. By convention, each read
     * has one and only one alignment where both `secondaryAlignment` and
     * `supplementaryAlignment` are false.
     */
    secondaryAlignment: boolean;
    /**
     * Whether this alignment is supplementary. Equivalent to SAM flag 0x800.
     * Supplementary alignments are used in the representation of a chimeric
     * alignment. In a chimeric alignment, a read is split into multiple linear
     * alignments that map to different reference contigs. The first linear
     * alignment in the read will be designated as the representative alignment;
     * the remaining linear alignments will be designated as supplementary
     * alignments. These alignments may have different mapping quality scores. In
     * each linear alignment in a chimeric alignment, the read will be hard
     * clipped. The `alignedSequence` and `alignedQuality` fields in the alignment
     * record will only represent the bases for its respective linear alignment.
     */
    supplementaryAlignment: boolean;
}
/**
 * A read group is all the data that's processed the same way by the
 * sequencer.
 */
export interface Schema$ReadGroup {
    /**
     * The dataset to which this read group belongs.
     */
    datasetId: string;
    /**
     * A free-form text description of this read group.
     */
    description: string;
    /**
     * The experiment used to generate this read group.
     */
    experiment: Schema$Experiment;
    /**
     * The server-generated read group ID, unique for all read groups. Note: This
     * is different than the @RG ID field in the SAM spec. For that value, see
     * name.
     */
    id: string;
    /**
     * A map of additional read group information. This must be of the form
     * map<string, string[]> (string key mapping to a list of string
     * values).
     */
    info: any;
    /**
     * The read group name. This corresponds to the @RG ID field in the SAM spec.
     */
    name: string;
    /**
     * The predicted insert size of this read group. The insert size is the length
     * the sequenced DNA fragment from end-to-end, not including the adapters.
     */
    predictedInsertSize: number;
    /**
     * The programs used to generate this read group. Programs are always
     * identical for all read groups within a read group set. For this reason,
     * only the first read group in a returned set will have this field populated.
     */
    programs: Schema$Program[];
    /**
     * The reference set the reads in this read group are aligned to.
     */
    referenceSetId: string;
    /**
     * A client-supplied sample identifier for the reads in this read group.
     */
    sampleId: string;
}
/**
 * A read group set is a logical collection of read groups, which are
 * collections of reads produced by a sequencer. A read group set typically
 * models reads corresponding to one sample, sequenced one way, and aligned one
 * way.  * A read group set belongs to one dataset. * A read group belongs to
 * one read group set. * A read belongs to one read group.
 */
export interface Schema$ReadGroupSet {
    /**
     * The dataset to which this read group set belongs.
     */
    datasetId: string;
    /**
     * The filename of the original source file for this read group set, if any.
     */
    filename: string;
    /**
     * The server-generated read group set ID, unique for all read group sets.
     */
    id: string;
    /**
     * A map of additional read group set information.
     */
    info: any;
    /**
     * The read group set name. By default this will be initialized to the sample
     * name of the sequenced data contained in this set.
     */
    name: string;
    /**
     * The read groups in this set. There are typically 1-10 read groups in a read
     * group set.
     */
    readGroups: Schema$ReadGroup[];
    /**
     * The reference set to which the reads in this read group set are aligned.
     */
    referenceSetId: string;
}
/**
 * A reference is a canonical assembled DNA sequence, intended to act as a
 * reference coordinate space for other genomic annotations. A single reference
 * might represent the human chromosome 1 or mitochandrial DNA, for instance. A
 * reference belongs to one or more reference sets.
 */
export interface Schema$Reference {
    /**
     * The server-generated reference ID, unique across all references.
     */
    id: string;
    /**
     * The length of this reference's sequence.
     */
    length: string;
    /**
     * MD5 of the upper-case sequence excluding all whitespace characters (this is
     * equivalent to SQ:M5 in SAM). This value is represented in lower case
     * hexadecimal format.
     */
    md5checksum: string;
    /**
     * The name of this reference, for example `22`.
     */
    name: string;
    /**
     * ID from http://www.ncbi.nlm.nih.gov/taxonomy. For example, 9606 for human.
     */
    ncbiTaxonId: number;
    /**
     * All known corresponding accession IDs in INSDC (GenBank/ENA/DDBJ) ideally
     * with a version number, for example `GCF_000001405.26`.
     */
    sourceAccessions: string[];
    /**
     * The URI from which the sequence was obtained. Typically specifies a FASTA
     * format file.
     */
    sourceUri: string;
}
/**
 * ReferenceBound records an upper bound for the starting coordinate of variants
 * in a particular reference.
 */
export interface Schema$ReferenceBound {
    /**
     * The name of the reference associated with this reference bound.
     */
    referenceName: string;
    /**
     * An upper bound (inclusive) on the starting coordinate of any variant in the
     * reference sequence.
     */
    upperBound: string;
}
/**
 * A reference set is a set of references which typically comprise a reference
 * assembly for a species, such as `GRCh38` which is representative of the human
 * genome. A reference set defines a common coordinate space for comparing
 * reference-aligned experimental data. A reference set contains 1 or more
 * references.
 */
export interface Schema$ReferenceSet {
    /**
     * Public id of this reference set, such as `GRCh37`.
     */
    assemblyId: string;
    /**
     * Free text description of this reference set.
     */
    description: string;
    /**
     * The server-generated reference set ID, unique across all reference sets.
     */
    id: string;
    /**
     * Order-independent MD5 checksum which identifies this reference set. The
     * checksum is computed by sorting all lower case hexidecimal string
     * `reference.md5checksum` (for all reference in this set) in ascending
     * lexicographic order, concatenating, and taking the MD5 of that value. The
     * resulting value is represented in lower case hexadecimal format.
     */
    md5checksum: string;
    /**
     * ID from http://www.ncbi.nlm.nih.gov/taxonomy (for example, 9606 for human)
     * indicating the species which this reference set is intended to model. Note
     * that contained references may specify a different `ncbiTaxonId`, as
     * assemblies may contain reference sequences which do not belong to the
     * modeled species, for example EBV in a human reference genome.
     */
    ncbiTaxonId: number;
    /**
     * The IDs of the reference objects that are part of this set.
     * `Reference.md5checksum` must be unique within this set.
     */
    referenceIds: string[];
    /**
     * All known corresponding accession IDs in INSDC (GenBank/ENA/DDBJ) ideally
     * with a version number, for example `NC_000001.11`.
     */
    sourceAccessions: string[];
    /**
     * The URI from which the references were obtained.
     */
    sourceUri: string;
}
/**
 * Runtime metadata that will be populated in the runtimeMetadata field of the
 * Operation associated with a RunPipeline execution.
 */
export interface Schema$RuntimeMetadata {
    /**
     * Execution information specific to Google Compute Engine.
     */
    computeEngine: Schema$ComputeEngine;
}
export interface Schema$SearchAnnotationSetsRequest {
    /**
     * Required. The dataset IDs to search within. Caller must have `READ` access
     * to these datasets.
     */
    datasetIds: string[];
    /**
     * Only return annotations sets for which a substring of the name matches this
     * string (case insensitive).
     */
    name: string;
    /**
     * The maximum number of results to return in a single page. If unspecified,
     * defaults to 128. The maximum value is 1024.
     */
    pageSize: number;
    /**
     * The continuation token, which is used to page through large result sets. To
     * get the next page of results, set this parameter to the value of
     * `nextPageToken` from the previous response.
     */
    pageToken: string;
    /**
     * If specified, only annotation sets associated with the given reference set
     * are returned.
     */
    referenceSetId: string;
    /**
     * If specified, only annotation sets that have any of these types are
     * returned.
     */
    types: string[];
}
export interface Schema$SearchAnnotationSetsResponse {
    /**
     * The matching annotation sets.
     */
    annotationSets: Schema$AnnotationSet[];
    /**
     * The continuation token, which is used to page through large result sets.
     * Provide this value in a subsequent request to return the next page of
     * results. This field will be empty if there aren't any additional
     * results.
     */
    nextPageToken: string;
}
export interface Schema$SearchAnnotationsRequest {
    /**
     * Required. The annotation sets to search within. The caller must have `READ`
     * access to these annotation sets. All queried annotation sets must have the
     * same type.
     */
    annotationSetIds: string[];
    /**
     * The end position of the range on the reference, 0-based exclusive. If
     * referenceId or referenceName must be specified, Defaults to the length of
     * the reference.
     */
    end: string;
    /**
     * The maximum number of results to return in a single page. If unspecified,
     * defaults to 256.