googleapis

/** * Copyright 2019 Google LLC * * 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 { OAuth2Client, JWT, Compute, UserRefreshClient } from 'google-auth-library'; import { GoogleConfigurable, MethodOptions, GlobalOptions, BodyResponseCallback, APIRequestContext } from 'googleapis-common'; import { GaxiosPromise } from 'gaxios'; export declare namespace healthcare_v1alpha2 { interface Options extends GlobalOptions { version: 'v1alpha2'; } interface StandardParameters { /** * V1 error format. */ '$.xgafv'?: string; /** * OAuth access token. */ access_token?: string; /** * Data format for response. */ alt?: string; /** * JSONP */ callback?: string; /** * Selector specifying which fields to include in a partial response. */ fields?: string; /** * API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. */ key?: string; /** * OAuth 2.0 token for the current user. */ oauth_token?: string; /** * Returns response with indentations and line breaks. */ prettyPrint?: boolean; /** * Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. */ quotaUser?: string; /** * Legacy upload protocol for media (e.g. "media", "multipart"). */ uploadType?: string; /** * Upload protocol for media (e.g. "raw", "multipart"). */ upload_protocol?: string; } /** * Cloud Healthcare API * * Manage, store, and access healthcare data in Google Cloud Platform. * * @example * const {google} = require('googleapis'); * const healthcare = google.healthcare('v1alpha2'); * * @namespace healthcare * @type {Function} * @version v1alpha2 * @variation v1alpha2 * @param {object=} options Options for Healthcare */ class Healthcare { context: APIRequestContext; projects: Resource$Projects; constructor(options: GlobalOptions, google?: GoogleConfigurable); } /** * An annotation record. */ interface Schema$Annotation { /** * Details of the source. */ annotationSource?: Schema$AnnotationSource; /** * Annnotations for images, e.g., bounding polygons. */ imageAnnotation?: Schema$ImageAnnotation; /** * Output only. Resource name of the Annotation, of the form `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/annotationStores/{annotation_store_id}/annotations/{annotation_id}`. */ name?: string; /** * Annotations for resource, e.g., classification tags. */ resourceAnnotation?: Schema$ResourceAnnotation; /** * Annotations for sensitive texts, e.g., range of such texts. */ textAnnotation?: Schema$SensitiveTextAnnotation; } /** * AnnotationSource holds the source information of the annotation. */ interface Schema$AnnotationSource { /** * Cloud Healthcare API resource. */ cloudHealthcareSource?: Schema$CloudHealthcareSource; } /** * An Annotation store that can store annotation resources such as labels and tags for text, image and audio. */ interface Schema$AnnotationStore { /** * User-supplied key-value pairs used to organize Annotation stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be associated with a given store. */ labels?: { [key: string]: string; }; /** * Output only. Resource name of the Annotation store, of the form `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/annotationStores/{annotation_store_id}`. */ name?: string; } /** * Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices" "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE", }, { "log_type": "ADMIN_READ", } ] }, { "service": "sampleservice.googleapis.com" "audit_log_configs": [ { "log_type": "DATA_READ", }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging. */ interface Schema$AuditConfig { /** * The configuration for logging of each type of permission. */ auditLogConfigs?: Schema$AuditLogConfig[]; /** * Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services. */ service?: string; } /** * Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE", } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging. */ interface Schema$AuditLogConfig { /** * Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members. */ exemptedMembers?: string[]; /** * Specifies whether principals can be exempted for the same LogType in lower-level resource policies. If true, any lower-level exemptions will be ignored. */ ignoreChildExemptions?: boolean; /** * The log type that this config enables. */ logType?: string; } /** * Associates `members` with a `role`. */ interface Schema$Binding { /** * The condition that is associated with this binding. NOTE: An unsatisfied condition will not allow user access via current binding. Different bindings, including their conditions, are examined independently. */ condition?: Schema$Expr; /** * 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@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}`: The G Suite domain (primary) 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`. */ role?: string; } /** * A bounding polygon for the detected image annotation. */ interface Schema$BoundingPoly { label?: string; vertices?: Schema$Vertex[]; } /** * Mask a string by replacing its characters with a fixed character. */ interface Schema$CharacterMaskConfig { /** * Character to mask the sensitive values. If not supplied, defaults to "*". */ maskingCharacter?: string; } /** * Cloud Healthcare API resource. */ interface Schema$CloudHealthcareSource { /** * Full path of a Cloud Healthcare API resource. */ name?: string; } /** * Creates a new message. */ interface Schema$CreateMessageRequest { /** * HL7v2 message. */ message?: Schema$Message; } /** * Pseudonymization method that generates surrogates via cryptographic hashing. Uses SHA-256. Outputs a base64-encoded representation of the hashed output (for example, `L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=`). */ interface Schema$CryptoHashConfig { /** * An AES 128/192/256 bit key. Causes the hash to be computed based on this key. A default key is generated for each DeidentifyDataset operation and is used wherever crypto_key is not specified. */ cryptoKey?: string; } /** * A message representing a health dataset. A health dataset represents a collection of healthcare data pertaining to one or more patients. This may include multiple modalities of healthcare data, such as electronic medical records or medical imaging data. */ interface Schema$Dataset { /** * Output only. Resource name of the dataset, of the form `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`. */ name?: string; /** * The default timezone used by this dataset. Must be a either a valid IANA time zone name such as "America/New_York" or empty, which defaults to UTC. This is used for parsing times in resources (e.g., HL7 messages) where no explicit timezone is specified. */ timeZone?: string; } /** * Shift a date forward or backward in time by a random amount which is consistent for a given patient and crypto key combination. */ interface Schema$DateShiftConfig { /** * An AES 128/192/256 bit key. Causes the shift to be computed based on this key and the patient ID. A default key is generated for each DeidentifyDataset operation and is used wherever crypto_key is not specified. */ cryptoKey?: string; } /** * Configures de-id options specific to different types of content. Each submessage customizes the handling of an https://tools.ietf.org/html/rfc6838 media type or subtype. Configs are applied in a nested manner at runtime. */ interface Schema$DeidentifyConfig { /** * Configures de-id of application/DICOM content. */ dicom?: Schema$DicomConfig; /** * Configures de-id of application/FHIR content. */ fhir?: Schema$FhirConfig; /** * Configures de-identification of image pixels wherever they are found in the source_dataset. */ image?: Schema$ImageConfig; /** * Configures de-identification of text wherever it is found in the source_dataset. */ text?: Schema$TextConfig; } /** * Redacts identifying information from the specified dataset. */ interface Schema$DeidentifyDatasetRequest { /** * Deidentify configuration. */ config?: Schema$DeidentifyConfig; /** * The name of the dataset resource to create and write the redacted data to (e.g., `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`). * The destination dataset must not exist. * The destination dataset must be in the same project as the source dataset. De-identifying data across multiple projects is not supported. */ destinationDataset?: string; } /** * Contains the status of the Deidentify operation. */ interface Schema$DeidentifyErrorDetails { /** * Number of resources failed to process. */ failureResourceCount?: string; /** * Number of stores failed to process. */ failureStoreCount?: string; /** * Number of resources successfully processed. */ successResourceCount?: string; /** * Number of stores successfully processed. */ successStoreCount?: string; } /** * Contains a detailed summary of the Deidentify operation. */ interface Schema$DeidentifySummary { /** * Number of resources successfully processed. */ successResourceCount?: string; /** * Number of stores successfully processed. */ successStoreCount?: string; } /** * Contains multiple sensitive information findings for each resource slice. */ interface Schema$Detail { findings?: Schema$Finding[]; } /** * Specifies the parameters needed for de-identification of DICOM stores. */ interface Schema$DicomConfig { /** * Tag filtering profile that determines which tags to keep/remove. */ filterProfile?: string; /** * List of tags to keep. Remove all other tags. */ keepList?: Schema$TagFilterList; /** * List of tags to remove. Keep all other tags. */ removeList?: Schema$TagFilterList; } /** * Represents a DICOM store. */ interface Schema$DicomStore { /** * User-supplied key-value pairs used to organize DICOM stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be associated with a given store. */ labels?: { [key: string]: string; }; /** * Output only. Resource name of the DICOM store, of the form `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/dicomStores/{dicom_store_id}`. */ name?: string; /** * Notification destination for new DICOM instances. Supplied by the client. */ notificationConfig?: Schema$NotificationConfig; } /** * 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 `{}`. */ interface Schema$Empty { } /** * Structure to describe the error encountered during batch operation on one resource. This is used both for sample errors in operation response, and for format of errors in error reports. */ interface Schema$ErrorDetail { /** * The status of the error. */ error?: Schema$Status; /** * The identifier of the resource. */ resource?: string; } /** * Exports data from the specified DICOM store. If a given resource (e.g., a DICOM object with the same SOPInstance UID) already exists in the output, it is overwritten with the version in the source dataset. Exported DICOM data will persist when the DICOM store from which it was exported is deleted. */ interface Schema$ExportDicomDataRequest { /** * The BigQuery output destination. You can only export to a BigQuery dataset that's in the same project as the DICOM store you're exporting from. The BigQuery location requires two IAM roles: `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`. */ bigqueryDestination?: Schema$GoogleCloudHealthcareV1alpha2DicomBigQueryDestination; /** * The Cloud Storage output destination. The Cloud Storage location requires the `roles/storage.objectAdmin` Cloud IAM role. */ gcsDestination?: Schema$GoogleCloudHealthcareV1alpha2DicomGcsDestination; } /** * Request to export resources. */ interface Schema$ExportResourcesRequest { /** * The BigQuery output destination. The BigQuery location requires two IAM roles: `roles/bigquery.dataEditor` and `roles/bigquery.jobUser`. The output will be one BigQuery table per resource type. */ bigqueryDestination?: Schema$GoogleCloudHealthcareV1alpha2FhirBigQueryDestination; /** * The Cloud Storage output destination. The Cloud Storage location requires the `roles/storage.objectAdmin` Cloud IAM role. The exported outputs are organized by FHIR resource types. The server will create one object per resource type. Each object contains newline delimited JSON, and each line is a FHIR resource. */ gcsDestination?: Schema$GoogleCloudHealthcareV1alpha2FhirRestGcsDestination; } /** * Represents an expression text. Example: title: "User account presence" description: "Determines whether the request has a user account" expression: "size(request.user) > 0" */ interface Schema$Expr { /** * An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI. */ description?: string; /** * Textual representation of an expression in Common Expression Language syntax. The application context of the containing message determines which well-known feature set of CEL is supported. */ expression?: string; /** * An optional string indicating the location of the expression for error reporting, e.g. a file name and a position in the file. */ location?: string; /** * An optional title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression. */ title?: string; } /** * Specifies how de-identification of a FHIR store should be handled. */ interface Schema$FhirConfig { /** * Specifies FHIR paths to match and how to transform them. Any field that is not matched by a FieldMetadata will be passed through to the output dataset unmodified. All extensions are removed in the output. */ fieldMetadataList?: Schema$FieldMetadata[]; } /** * Represents a FHIR store. */ interface Schema$FhirStore { /** * Whether to disable referential integrity in this FHIR store. This field is immutable after FHIR store creation. The default value is false, meaning that the API will enforce referential integrity and fail the requests that will result in inconsistent state in the FHIR store. When this field is set to true, the API will skip referential integrity check. Consequently, operations that rely on references, such as GetPatientEverything, will not return all the results if broken references exist. */ disableReferentialIntegrity?: boolean; /** * Whether to disable resource versioning for this FHIR store. This field can not be changed after the creation of FHIR store. If set to false, which is the default behavior, all write operations will cause historical versions to be recorded automatically. The historical versions can be fetched through the history APIs, but cannot be updated. If set to true, no historical versions will be kept. The server will send back errors for attempts to read the historical versions. */ disableResourceVersioning?: boolean; /** * Whether to allow the bulk import API to accept history bundles and directly insert historical resource versions into the FHIR store. Importing resource histories creates resource interactions that appear to have occurred in the past, which clients may not want to allow. If set to false, history bundles within an import will fail with an error. */ enableHistoryImport?: boolean; /** * Whether this FHIR store has the [updateCreate capability](https://www.hl7.org/fhir/capabilitystatement-definitions.html#CapabilityStatement.rest.resource.updateCreate). This determines if the client can use an Update operation to create a new resource with a client-specified ID. If false, all IDs are server-assigned through the Create operation and attempts to Update a non-existent resource will return errors. Please treat the audit logs with appropriate levels of care if client-specified resource IDs contain sensitive data such as patient identifiers, those IDs will be part of the FHIR resource path recorded in Cloud audit logs and Cloud Pub/Sub notifications. */ enableUpdateCreate?: boolean; /** * User-supplied key-value pairs used to organize FHIR stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be associated with a given store. */ labels?: { [key: string]: string; }; /** * Output only. Resource name of the FHIR store, of the form `projects/{project_id}/datasets/{dataset_id}/fhirStores/{fhir_store_id}`. */ name?: string; /** * If non-empty, publish all resource modifications of this FHIR store to this destination. The Cloud Pub/Sub message attributes will contain a map with a string describing the action that has triggered the notification, e.g. "action":"CreateResource". */ notificationConfig?: Schema$NotificationConfig; /** * A list of streaming configs that configure the destinations of streaming export for every resource mutation in this FHIR store. Each store is allowed to have up to 10 streaming configs. After a new config is added, the next resource mutation will be streamed to the new location in addition to the existing ones. When a location is removed from the list, the server will simply stop streaming to that location. Before adding a new config, you must add the required [`bigquery.dataEditor`](https://cloud.google.com/bigquery/docs/access-control#bigquery.dataEditor) role to your project's **Cloud Healthcare Service Agent** [service account](https://cloud.google.com/iam/docs/service-accounts). Some lag (typically on the order of dozens of seconds) is expected before the results show up in the streaming destination. */ streamConfigs?: Schema$StreamConfig[]; /** * Configuration of FHIR Subscription: https://www.hl7.org/fhir/subscription.html. */ subscriptionConfig?: Schema$SubscriptionConfig; /** * Configuration for how incoming FHIR resources will be validated against configured profiles. */ validationConfig?: Schema$ValidationConfig; } /** * Specifies FHIR paths to match, and how to handle de-identification of matching fields. */ interface Schema$FieldMetadata { /** * Deidentify action for one field. */ action?: string; /** * List of paths to FHIR fields to be redacted. Each path is a period-separated list where each component is either a field name or FHIR type name, for example: Patient, HumanName. For "choice" types (those defined in the FHIR spec with the form: field[x]) we use two separate components. e.g. "deceasedAge.unit" is matched by "Deceased.Age.unit". Supported types are: AdministrativeGenderCode, Code, Date, DateTime, Decimal, HumanName, Id, LanguageCode, Markdown, MimeTypeCode, Oid, String, Uri, Uuid, Xhtml. */ paths?: string[]; } interface Schema$Finding { /** * Zero-based ending index of the found text, exclusively. */ end?: string; /** * The type of information stored in this text range (e.g. HumanName, BirthDate, Address, etc.) */ infoType?: string; /** * Zero-based starting index of the found text, inclusively. */ start?: string; } /** * Request message for `GetIamPolicy` method. */ interface Schema$GetIamPolicyRequest { /** * OPTIONAL: A `GetPolicyOptions` object for specifying options to `GetIamPolicy`. This field is only used by Cloud IAM. */ options?: Schema$GetPolicyOptions; } /** * Encapsulates settings provided to GetIamPolicy. */ interface Schema$GetPolicyOptions { /** * Optional. The policy format version to be returned. Acceptable values are 0 and 1. If the value is 0, or the field is omitted, policy format version 1 will be returned. */ requestedPolicyVersion?: number; } /** * The BigQuery table where the output should be written. */ interface Schema$GoogleCloudHealthcareV1alpha2DicomBigQueryDestination { /** * If the destination table already exists and this flag is `TRUE`, the table will be overwritten by the contents of the DICOM store. If the flag is not set and the destination table already exists, the export call returns an error. */ force?: boolean; /** * BigQuery URI to a table, up to 2000 characters long, in the format `bq://projectId.bqDatasetId.tableId` */ tableUri?: string; } /** * The Cloud Storage location where the output should be written, and the export configuration. */ interface Schema$GoogleCloudHealthcareV1alpha2DicomGcsDestination { /** * MIME types supported by DICOM spec. Each file will be written in the following format: `.../{study_id}/{series_id}/{instance_id}[/{frame_number}].{extension}` The frame_number component will exist only for multi-frame instances. Refer to the DICOM conformance statement for permissible MIME types: https://cloud.google.com/healthcare/docs/dicom#wado-rs The following extensions will be used for output files: application/dicom -> .dcm image/jpeg -> .jpg image/png -> .png If unspecified, the instances will be exported in their original DICOM format. */ mimeType?: string; /** * The Cloud Storage destination to export to. URI for a Cloud Storage directory where result files should be written (in the format `gs://{bucket-id}/{path/to/destination/dir}`). If there is no trailing slash, the service will append one when composing the object path. The user is responsible for creating the Cloud Storage bucket referenced in `uri_prefix`. */ uriPrefix?: string; } /** * Specifies the configuration for importing data from Cloud Storage. */ interface Schema$GoogleCloudHealthcareV1alpha2DicomGcsSource { /** * Points to a Cloud Storage URI containing file(s) with content only. The URI must be in the following format: `gs://{bucket_id}/{object_id}`. The URI can include wildcards in `object_id` and thus identify multiple files. Supported wildcards: '*' to match 0 or more non-separator characters '**' to match 0 or more characters (including separators). Must be used at the end of a path and with no other wildcards in the path. Can also be used with a file extension (such as .dcm), which imports all files with the extension in the specified directory and its sub-directories. For example, `gs://my-bucket/my-directory/**.dcm` imports all files with .dcm extensions in `my-directory/` and its sub-directories. '?' to match 1 character All other URI formats are invalid. Files matching the wildcard are expected to contain content only, no metadata. */ uri?: string; } /** * The configuration for exporting to BigQuery. */ interface Schema$GoogleCloudHealthcareV1alpha2FhirBigQueryDestination { /** * BigQuery URI to a dataset, up to 2000 characters long, in the format `bq://projectId.bqDatasetId` */ datasetUri?: string; /** * The configuration for the exported BigQuery schema. */ schemaConfig?: Schema$SchemaConfig; } /** * Final response of exporting resources. This structure will be included in the response to describe the detailed outcome. It will only be included when the operation finishes. */ interface Schema$GoogleCloudHealthcareV1alpha2FhirRestExportResourcesResponse { /** * The name of the FHIR store where resources have been exported, in the format `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/fhirStores/{fhir_store_id}`. */ fhirStore?: string; /** * The total number of resources exported from the requested FHIR store. */ resourceCount?: string; } /** * The configuration for exporting to Cloud Storage. */ interface Schema$GoogleCloudHealthcareV1alpha2FhirRestGcsDestination { /** * URI for a Cloud Storage directory where result files should be written (in the format `gs://{bucket-id}/{path/to/destination/dir}`). If there is no trailing slash, the service will append one when composing the object path. The user is responsible for creating the Cloud Storage bucket referenced in `uri_prefix`. */ uriPrefix?: string; } /** * Specifies the Cloud Storage destination where errors will be recorded. */ interface Schema$GoogleCloudHealthcareV1alpha2FhirRestGcsErrorDestination { /** * URI for a Cloud Storage directory to which error report files should be written (in the format `gs://{bucket-id}/{path/to/destination/dir}`). If there is no trailing slash, the service will append one when composing the object path. The user is responsible for creating the Cloud Storage bucket referenced in `uri_prefix`. */ uriPrefix?: string; } /** * Specifies the configuration for importing data from Cloud Storage. */ interface Schema$GoogleCloudHealthcareV1alpha2FhirRestGcsSource { /** * Points to a Cloud Storage URI containing file(s) to import. The URI must be in the following format: `gs://{bucket_id}/{object_id}`. The URI can include wildcards in `object_id` and thus identify multiple files. Supported wildcards: * `*` to match 0 or more non-separator characters * `**` to match 0 or more characters (including separators). Must be used at the end of a path and with no other wildcards in the path. Can also be used with a file extension (such as .ndjson), which imports all files with the extension in the specified directory and its sub-directories. For example, `gs://my-bucket/my-directory/**.ndjson` imports all files with `.ndjson` extensions in `my-directory/` and its sub-directories. * `?` to match 1 character Files matching the wildcard are expected to contain content only, no metadata. */ uri?: string; } /** * Error response of importing resources. This structure will be included in the error details to describe the detailed error. It will only be included when the operation finishes with some failure. */ interface Schema$GoogleCloudHealthcareV1alpha2FhirRestImportResourcesErrorDetails { /** * The number of resources that had errors. */ errorCount?: string; /** * The name of the FHIR store where resources have been imported, in the format `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/fhirStores/{fhir_store_id}`. */ fhirStore?: string; /** * The total number of resources included in the source data. This is the sum of the success and error counts. */ inputSize?: string; /** * The number of resources that have been imported. */ successCount?: string; } /** * Final response of importing resources. This structure will be included in the response to describe the detailed outcome. It will only be included when the operation finishes successfully. */ interface Schema$GoogleCloudHealthcareV1alpha2FhirRestImportResourcesResponse { /** * The name of the FHIR store where the resources have been imported, in the format `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}/fhirStores/{fhir_store_id}`. */ fhirStore?: string; /** * The total number of resources included in the source data. */ inputSize?: string; } /** * Represents an HL7v2 store. */ interface Schema$Hl7V2Store { /** * User-supplied key-value pairs used to organize HL7v2 stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be associated with a given store. */ labels?: { [key: string]: string; }; /** * Output only. Resource name of the HL7v2 store, of the form `projects/{project_id}/datasets/{dataset_id}/hl7V2Stores/{hl7v2_store_id}`. */ name?: string; /** * The notification destination all messages (both Ingest & Create) are published on. Only the message name is sent as part of the notification. If this is unset, no notifications will be sent. Supplied by the client. */ notificationConfig?: Schema$NotificationConfig; /** * The configuration for the parser. It determines how the server parses the messages. */ parserConfig?: Schema$ParserConfig; } /** * Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. */ interface Schema$HttpBody { /** * The HTTP Content-Type header value specifying the content type of the body. */ contentType?: string; /** * The HTTP request/response body as raw binary. */ data?: string; /** * Application specific response metadata. Must be set in the first response for streaming APIs. */ extensions?: Array<{ [key: string]: any; }>; } /** * Image annotation. */ interface Schema$ImageAnnotation { /** * The list of polygons outlining the sensitive regions in the image. */ boundingPolys?: Schema$BoundingPoly[]; } /** * Specifies how de-identification of image pixel should be handled. */ interface Schema$ImageConfig { /** * Determines how to redact text from image. */ textRedactionMode?: string; } /** * Returns the errors encountered during DICOM store import. */ interface Schema$ImportDicomDataErrorDetails { /** * Deprecated. Use only for debugging purposes. Contains sample errors encountered in imports of individual resources (for example, a Cloud Storage object). */ sampleErrors?: Schema$ErrorDetail[]; } /** * Imports data into the specified DICOM store. Returns an error if any of the files to import are not DICOM files. This API will accept duplicate DICOM instances, by simply ignoring the newly pushed instance (it will not overwrite). */ interface Schema$ImportDicomDataRequest { /** * Cloud Storage source data location and import configuration. The Cloud Storage location requires the `roles/storage.objectViewer` Cloud IAM role. */ gcsSource?: Schema$GoogleCloudHealthcareV1alpha2DicomGcsSource; } /** * Request to import resources. */ interface Schema$ImportResourcesRequest { /** * The content structure in the source location. If not specified, the server treats the input source files as BUNDLE. */ contentStructure?: string; /** * The Cloud Storage destination to write the error report to. The Cloud Storage location requires the `roles/storage.objectAdmin` Cloud IAM role. Note that writing a file to the same destination multiple times will result in the previous version of the file being overwritten. */ gcsErrorDestination?: Schema$GoogleCloudHealthcareV1alpha2FhirRestGcsErrorDestination; /** * Cloud Storage source data location and import configuration. The Cloud Storage location requires the `roles/storage.objectViewer` Cloud IAM role. Each Cloud Storage object should be a text file that contains the format specified in ContentStructu. */ gcsSource?: Schema$GoogleCloudHealthcareV1alpha2FhirRestGcsSource; } /** * A transformation to apply to text that is identified as a specific info_type. */ interface Schema$InfoTypeTransformation { /** * Config for character mask. */ characterMaskConfig?: Schema$CharacterMaskConfig; /** * Config for crypto hash. */ cryptoHashConfig?: Schema$CryptoHashConfig; /** * Config for date shift. */ dateShiftConfig?: Schema$DateShiftConfig; /** * InfoTypes to apply this transformation to. If this is not specified, the transformation applies to any info_type. */ infoTypes?: string[]; /** * Config for text redaction. */ redactConfig?: Schema$RedactConfig; /** * Config for replace with InfoType. */ replaceWithInfoTypeConfig?: Schema$ReplaceWithInfoTypeConfig; } /** * Ingests a message into the specified HL7v2 store. */ interface Schema$IngestMessageRequest { /** * HL7v2 message to ingest. */ message?: Schema$Message; } /** * Acknowledges that a message has been ingested into the specified HL7v2 store. */ interface Schema$IngestMessageResponse { /** * HL7v2 ACK message. */ hl7Ack?: string; /** * Created message resource. */ message?: Schema$Message; } /** * Lists the Annotations in the specified Annotation store. */ interface Schema$ListAnnotationsResponse { /** * The returned Annotations names. Won't be more values than the value of page_size in the request. */ annotations?: string[]; /** * Token to retrieve the next page of results or empty if there are no more results in the list. */ nextPageToken?: string; } /** * Lists the Annotation stores in the given dataset. */ interface Schema$ListAnnotationStoresResponse { /** * The returned Annotation stores. Won't be more Annotation stores than the value of page_size in the request. */ annotationStores?: Schema$AnnotationStore[]; /** * Token to retrieve the next page of results or empty if there are no more results in the list. */ nextPageToken?: string; } /** * Lists the available datasets. */ interface Schema$ListDatasetsResponse { /** * The first page of datasets. */ datasets?: Schema$Dataset[]; /** * Token to retrieve the next page of results, or empty if there are no more results in the list. */ nextPageToken?: string; } /** * Lists the DICOM stores in the given dataset. */ interface Schema$ListDicomStoresResponse { /** * The returned DICOM stores. Won't be more DICOM stores than the value of page_size in the request. */ dicomStores?: Schema$DicomStore[]; /** * Token to retrieve the next page of results or empty if there are no more results in the list. */ nextPageToken?: string; } /** * Lists the FHIR stores in the given dataset. */ interface Schema$ListFhirStoresResponse { /** * The returned FHIR stores. Won't be more FHIR stores than the value of page_size in the request. */ fhirStores?: Schema$FhirStore[]; /** * Token to retrieve the next page of results or empty if there are no more results in the list. */ nextPageToken?: string; } /** * Lists the HL7v2 stores in the given dataset. */ interface Schema$ListHl7V2StoresResponse { /** * The returned HL7v2 stores. Won't be more HL7v2 stores than the value of page_size in the request. */ hl7V2Stores?: Schema$Hl7V2Store[]; /** * Token to retrieve the next page of results or empty if there are no more results in the list. */ nextPageToken?: string; } /** * The response message for Locations.ListLocations. */ interface Schema$ListLocationsResponse { /** * A list of locations that matches the specified filter in the request. */ locations?: Schema$Location[]; /** * The standard List next-page token. */ nextPageToken?: string; } /** * Lists the messages in the specified HL7v2 store. */ interface Schema$ListMessagesResponse { /** * The returned message names. Won't be more values than the value of page_size in the request. */ messages?: string[]; /** * Token to retrieve the next page of results or empty if there are no more results in the list. */ nextPageToken?: string; } /** * The response message for Operations.ListOperations. */ 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[]; } /** * A resource that represents Google Cloud Platform location. */ interface Schema$Location { /** * The friendly name for this location, typically a nearby city name. For example, "Tokyo". */ displayName?: string; /** * Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"} */ labels?: { [key: string]: string; }; /** * The canonical id for this location. For example: `"us-east1"`. */ locationId?: string; /** * Service-specific metadata. For example the available capacity at the given location. */ metadata?: { [key: string]: any; }; /** * Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"` */ name?: string; } /** * A complete HL7v2 message. See http://www.hl7.org/implement/standards/index.cfm?ref=common for details on the standard. */ interface Schema$Message { /** * Output only. The datetime when the message was created. Set by the server. */ createTime?: string; /** * Raw message bytes. */ data?: string; /** * User-supplied key-value pairs used to organize HL7v2 stores. Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: \p{Ll}\p{Lo}{0,62} Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63} No more than 64 labels can be associated with a given store. */ labels?: { [key: string]: string; }; /** * The message type and trigger event for this message. MSH-9. */ messageType?: string; /** * Resource name of the Message, of the form `projects/{project_id}/datasets/{dataset_id}/hl7V2Stores/{hl7_v2_store_id}/messages/{message_id}`. Assigned by the server. */ name?: string; /** * Output only. The parsed version of the raw message data. */ parsedData?: Schema$ParsedData; /** * All patient IDs listed in the PID-2, PID-3, and PID-4 segments of this message. */ patientIds?: Schema$PatientId[]; /** * The hospital that this message came from. MSH-4. */ sendFacility?: string; /** * The datetime the sending application sent this message. MSH-7. */ sendTime?: string; } /** * Specifies where notifications should be sent upon changes to a data store. */ interface Schema$NotificationConfig { /** * The [Cloud Pub/Sub](https://cloud.google.com/pubsub/docs/) topic that notifications of changes are published on. Supplied by the client. PubsubMessage.Data will contain the resource name. PubsubMessage.MessageId is the ID of this message. It is guaranteed to be unique within the topic. PubsubMessage.PublishTime is the time at which the message was published. Notifications are only sent if the topic is non-empty. [Topic names](http